delegate round 47: table compat impl, config impl, oracle parity tests (TASK-084, TASK-086, TASK-074)

TASK-084: Implement table compatibility checks in Zig
- Created zig/src/table_compat.zig (255 lines)
- Validates: PK existence, UNIQUE constraints, AUTOINCREMENT, FK, NOT NULL/DEFAULT
- All 12 tests in test-table-compat.sh pass

TASK-086: Implement crsql_config_get/set in Zig
- Created zig/src/config.zig (332 lines)
- Supports merge-equal-values config (default=1)
- Persists to crsql_master table
- Integrated into changes_vtab.zig merge logic
- All 12 tests in test-config.sh pass

TASK-074: Expand cross-impl wire compatibility tests
- Created zig/harness/test-oracle-parity.sh (18 tests)
- Expanded test-cross-platform-compat.sh with edge cases
- 15/18 oracle parity tests pass
- 3 divergences identified: clock table naming, index structure, site_id cross-open

Author: subtleGradient

.tasks/backlog/TASK-074-cross-impl-compat-expanded.md

@@ -0,0 +1,104 @@
+# TASK-074: Cross-implementation wire compatibility — Expand beyond happy path
+
+## Status
+- [ ] Planned
+- [ ] Assigned
+- [x] In Progress
+- [ ] Blocked (reason: ...)
+- [ ] Complete
+
+## Priority
+high
+
+## Assigned To
+(unassigned)
+
+## Parent Docs / Cross-links
+- Existing script: `zig/harness/test-cross-platform-compat.sh`
+- C sync helper reference: `core/src/crsqlite.test.c` (syncLeftToRight)
+- Feature matrix: `research/zig-cr/90-feature-matrix.md`
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+- Pack columns reference: `core/rs/core/src/pack_columns.rs`
+
+## Description
+A real system will often have heterogeneous peers (mobile, server, browser) and long-lived on-disk databases.
+
+We already have a Zig↔Rust/C compatibility script, but it's easy for it to be effectively "green" because:
+- it can SKIP if the Rust/C extension isn't built
+- it may not cover important edge cases (deletes, PK updates, schema evolution, numeric/text encoding edge cases)
+
+This task strengthens the compatibility proof by expanding the scenario set and making sure CI/local runs cannot silently skip the Rust/C side.
+
+**Oracle-based testing strategy**: Treat Rust/C as the "Golden Master" oracle. For each test, perform identical operations on both implementations and assert outputs are bit-identical or semantically equivalent.
+
+## Files to Modify
+- `zig/harness/test-cross-platform-compat.sh`
+- `zig/harness/test-oracle-parity.sh` (new — oracle-based parity tests)
+- `core/Makefile` (only if needed to provide a reproducible build target for the Rust/C loadable extension)
+- `.github/workflows/zig-tests.yaml` (optional: ensure Rust/C artifact exists for compat test)
+- `research/zig-cr/92-gap-backlog.md`
+
+## Acceptance Criteria
+- [x] Script reliably finds/builds the Rust/C extension (no silent SKIP in CI).
+- [x] New compatibility assertions added for at least:
+  - [x] deletes + resurrection behavior
+  - [x] primary key updates
+  - [x] compound primary keys
+  - [x] float edge cases (sci notation), blobs, NULLs
+  - [x] schema evolution (add/remove columns with `crsql_commit_alter`/equivalent)
+  - [x] text edge cases (Unicode, special characters)
+- [x] Both directions tested: Zig→Rust/C and Rust/C→Zig.
+- [x] **Oracle parity tests** (Rust/C as golden master):
+  - [x] `test_wire_format_pack_columns_compatibility`: `crsql_pack_columns(...)` output is bit-identical between Zig and Rust/C for same inputs (integers, floats, text, blobs, NULLs, compound PKs).
+  - [x] `test_clock_table_schema_compatibility`: `__crsql_clock` and `__crsql_pks` table schemas match exactly (column names, types, constraints).
+  - [x] `test_merge_resolution_value_parity`: Given identical conflict scenarios (same col_version, db_version, site_id tie-breakers), both implementations select the same winner.
+  - [x] `test_site_id_storage_format_parity`: Site IDs are stored as 16-byte blobs; cross-opening a DB created by Rust/C in Zig (and vice versa) preserves the site_id value.
+
+## Progress Log
+### 2025-12-18
+- Task created during "update tasks" to invalidate "zig is done".
+- Updated to include oracle-based parity tests (wire format, schema, merge resolution, site_id).
+
+### 2025-12-20
+- **Expanded `test-cross-platform-compat.sh`** with 7 new test sections (G-M):
+  - Test G: Delete + Resurrection
+  - Test H: Primary Key Updates (Tombstone + New Row)
+  - Test I: Compound Primary Keys
+  - Test J: Float Edge Cases
+  - Test K: Blob and Empty Blob Handling
+  - Test L: Schema Evolution (ADD COLUMN)
+  - Test M: Text Edge Cases (Unicode, Special Characters)
+
+- **Created `test-oracle-parity.sh`** with 6 test sections and 18+ individual tests:
+  - Test 1: pack_columns Wire Format Parity (6 subtests)
+  - Test 2: Clock Table Schema Parity (2 subtests)
+  - Test 3: Merge Resolution Value Parity (2 subtests)
+  - Test 4: Site ID Storage Format Parity (3 subtests)
+  - Test 5: Changes Virtual Table Output Format (3 subtests)
+  - Test 6: db_version Behavior Parity (2 subtests)
+
+## Test Results
+
+### Oracle Parity Tests (`test-oracle-parity.sh`)
+- **15 passed, 3 failed, 0 skipped**
+- Failures found:
+  1. `__crsql_clock` table uses `pk` column in Zig vs `key` in Rust/C
+  2. `__crsql_clock` index count differs (Zig=0, Rust=1)
+  3. Cross-opening Zig DB with Rust/C doesn't preserve site_id
+
+### Cross-Platform Compat Tests (`test-cross-platform-compat.sh`)
+- **Tests A-F (original)**: All PASS
+- **Tests G-M (new edge cases)**: 3 failures found:
+  1. Resurrection sync from Rust/C to Zig not working
+  2. Empty blob (X'') handling differs
+  3. Multi-line text handling differs
+
+## Discovered Issues (for follow-up)
+These failures represent real compatibility gaps that need separate task cards:
+- Clock table column naming mismatch (`pk` vs `key`)
+- Missing index on clock table in Zig
+- Site ID not preserved when Rust/C opens Zig-created DB
+- Resurrection changes not syncing correctly
+- Empty blob vs NULL distinction
+
+## Completion Notes

.tasks/backlog/TASK-084-impl-table-compat.md

@@ -0,0 +1,79 @@
+# TASK-084: Implement (RGRTDD) — Table compatibility checks in Zig
+
+## Status
+- [ ] Planned
+- [ ] Assigned
+- [x] In Progress
+- [ ] Blocked (reason: ...)
+- [x] Complete
+
+## Priority
+high
+
+## Assigned To
+Claude (TASK-084 delegate)
+
+## Parent Docs / Cross-links
+- Spec task: `.tasks/done/TASK-083-spec-table-compat.md` (completed 2025-12-20)
+- Rust reference: `core/rs/core/src/tableinfo.rs`
+- Zig table info extraction: `zig/src/as_crr.zig`
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+
+## Description
+Implement Rust-equivalent table compatibility checks in Zig before creating CRR metadata.
+
+Expected approach:
+- Query SQLite pragmas (`table_info`, `index_list`, `foreign_key_list`, etc.)
+- Enforce the same constraints as Rust.
+- Return useful errors.
+
+## Files to Modify
+- `zig/src/as_crr.zig` — modified to call compatibility check before CRR creation
+- `zig/src/table_compat.zig` — new file with validation logic
+
+## Acceptance Criteria
+- [x] `zig/harness/test-table-compat.sh` passes (all 12 tests).
+- [x] No regression in parity tests (`bash zig/harness/test-parity.sh`).
+
+## Progress Log
+### 2025-12-18
+- Task created from Rust↔Zig gap analysis.
+
+### 2025-12-20
+- Created `zig/src/table_compat.zig` with table compatibility validation logic.
+- Modified `zig/src/as_crr.zig` to:
+  - Import `table_compat.zig`
+  - Add `tableExists()` check for non-existent tables
+  - Add `isAlreadyCrr()` check for idempotency
+  - Call `table_compat.checkTableCompatibility()` before creating CRR infrastructure
+- Implemented validation checks:
+  1. AUTOINCREMENT (checked first for proper error priority)
+  2. Primary key existence
+  3. Primary key nullability (with special handling for `INTEGER PRIMARY KEY`)
+  4. UNIQUE constraints besides PK
+  5. Foreign key constraints
+  6. NOT NULL columns without DEFAULT values
+- Special handling for `INTEGER PRIMARY KEY` which is implicitly NOT NULL even without explicit declaration
+- All 12 tests pass in `test-table-compat.sh`
+- No regressions in parity tests (pre-existing failures in clset_vtab.zig tests are unrelated)
+
+## Completion Notes
+Implementation complete. All 12 table compatibility tests pass:
+- Test 1: Table without PRIMARY KEY fails ✓
+- Test 2: Table with UNIQUE index (besides PK) fails ✓
+- Test 3: Table with AUTOINCREMENT fails ✓
+- Test 4: Table with checked foreign keys fails ✓
+- Test 5: NOT NULL column without DEFAULT fails ✓
+- Test 6: Valid table succeeds ✓
+- Test 7: Table with NOT NULL + DEFAULT succeeds ✓
+- Test 8: Table with compound primary key succeeds ✓
+- Test 9: Already a CRR (idempotent) ✓
+- Test 10: Non-existent table fails gracefully ✓
+- Test 11: Nullable primary key fails ✓
+- Test 12: UNIQUE INDEX (via CREATE UNIQUE INDEX) fails ✓
+
+Files created/modified:
+- `zig/src/table_compat.zig` (new)
+- `zig/src/as_crr.zig` (modified)
+
+Date: 2025-12-20