@interocitor/core 0.0.0-beta.10

package/dist/core/manifest.js

@@ -0,0 +1,203 @@
+/**
+ * Manifest — reading, writing, creating, and validating cloud manifests.
+ *
+ * Extracted from Interocitor. Not part of the public API.
+ */
+import { paths, textEncoder, textDecoder, generateId, computeContentHash } from "./internals.js";
+import { assertExpectedMeshId } from "./codec.js";
+import { MeshEncryptionMismatchError } from "./errors.js";
+export async function readJson(adapter, path) {
+    const data = await adapter.readFile(path);
+    return JSON.parse(textDecoder.decode(data));
+}
+export async function readJsonIfExists(adapter, path) {
+    try {
+        return await readJson(adapter, path);
+    }
+    catch {
+        return null;
+    }
+}
+export function assertServerAuth(manifest, serverId) {
+    if (manifest.writtenBy !== serverId) {
+        throw new Error(`Unauthorized manifest writer: ${manifest.writtenBy}`);
+    }
+}
+export async function validateManifestHash(manifest) {
+    const { contentHash, ...payload } = manifest;
+    const expected = await computeContentHash(payload);
+    if (contentHash !== expected) {
+        throw new Error('Manifest content hash mismatch');
+    }
+}
+export async function writeJson(adapter, path, value) {
+    console.log('[interocitor:write] manifest.writeJson', { path, kind: path.endsWith('/manifest.json') ? 'pointer' : path.includes('/manifest-') ? 'manifest' : path.includes('/devices/') ? 'device' : path.includes('/changes/') ? 'changes' : 'other' });
+    await adapter.writeFile(path, textEncoder.encode(JSON.stringify(value, null, 2)));
+}
+export async function createBootstrapManifest(ctx, meshId) {
+    const p = paths(ctx.remotePath);
+    const now = new Date().toISOString();
+    const payload = {
+        generation: 1,
+        parentGeneration: 0,
+        writtenBy: ctx.serverId,
+        writtenAt: now,
+        version: 3,
+        meshId: meshId || generateId('mesh'),
+        schema: ctx.schema?.version ?? 1,
+        encrypted: ctx.encrypted,
+        server: {
+            managed: ctx.serverManaged,
+            relayUrl: null,
+            serverId: ctx.serverId,
+        },
+        createdAt: now,
+        epoch: 0,
+        watermarkHlc: '',
+        snapshotPath: null,
+        deltaPath: null,
+    };
+    const manifest = {
+        ...payload,
+        contentHash: await computeContentHash(payload),
+    };
+    const manifestFile = `manifest-${manifest.generation}.json`;
+    const pointer = {
+        currentGeneration: manifest.generation,
+        file: manifestFile,
+    };
+    await writeJson(ctx.adapter, p.manifestFile(manifest.generation), manifest);
+    ctx.emit({
+        type: 'trace:manifest',
+        op: 'write',
+        reason: 'bootstrap',
+        generation: manifest.generation,
+        path: p.manifestFile(manifest.generation),
+    });
+    await writeJson(ctx.adapter, p.manifestPointer, pointer);
+    ctx.emit({
+        type: 'trace:manifest',
+        op: 'write',
+        reason: 'bootstrap-pointer',
+        generation: manifest.generation,
+        path: p.manifestPointer,
+    });
+    return { pointer, manifest };
+}
+export async function loadOrCreateManifest(ctx, codecState, local, poisonRemote, reason = 'unknown') {
+    const p = paths(ctx.remotePath);
+    ctx.emit({ type: 'trace:manifest', op: 'read', reason, path: p.manifestPointer });
+    const globalPointer = await readJsonIfExists(ctx.adapter, p.manifestPointer);
+    let pointer;
+    let manifest;
+    let bootstrapped = false;
+    if (globalPointer) {
+        pointer = globalPointer;
+        const manifestPath = `${ctx.remotePath}/${pointer.file}`;
+        ctx.emit({ type: 'trace:manifest', op: 'read', reason, path: manifestPath, generation: pointer.currentGeneration });
+        manifest = await readJson(ctx.adapter, manifestPath);
+    }
+    else {
+        bootstrapped = true;
+        ctx.emit({ type: 'trace:manifest', op: 'bootstrap-create', reason, path: p.manifestPointer });
+        const existingMeshId = await local.getMeta('meshId');
+        const bootstrap = await createBootstrapManifest(ctx, typeof existingMeshId === 'string' ? existingMeshId : undefined);
+        // Skip the read-after-write — we just minted both files in this process,
+        // they are exactly what's on disk. No GETs needed.
+        pointer = bootstrap.pointer;
+        manifest = bootstrap.manifest;
+    }
+    const manifestPath = `${ctx.remotePath}/${pointer.file}`;
+    await validateManifestHash(manifest);
+    try {
+        await assertExpectedMeshId(local, codecState.manifest, manifest.meshId);
+    }
+    catch (err) {
+        throw await poisonRemote(err, manifestPath);
+    }
+    if (manifest.version !== 3) {
+        throw new Error(`Unsupported manifest version ${manifest.version} (expected 3).`);
+    }
+    if (ctx.schema?.version !== undefined && manifest.schema !== ctx.schema.version) {
+        ctx.emit({ type: 'schema:mismatch', local: ctx.schema.version, remote: manifest.schema });
+        throw new Error(`Schema version mismatch: local=${ctx.schema.version}, remote=${manifest.schema}`);
+    }
+    if (manifest.server.managed) {
+        assertServerAuth(manifest, ctx.serverId);
+    }
+    // Encryption-mode parity check.
+    //
+    // The remote manifest pins the mesh's encryption mode at bootstrap.
+    // If the engine reconnects with a different `encrypted` flag (typical
+    // app bug: passphrase loaded asynchronously, so the first session
+    // wrote plaintext and the next session derives a key and tries to
+    // decrypt), every change file would fail decode and poison the remote.
+    //
+    // Surface this as an actionable error *before* any decode runs and
+    // *without* poisoning. The remote is not corrupt — the local config
+    // is wrong.
+    if (typeof manifest.encrypted === 'boolean' && manifest.encrypted !== ctx.encrypted) {
+        throw new MeshEncryptionMismatchError(manifest.encrypted, ctx.encrypted);
+    }
+    return { manifest, bootstrapped };
+}
+export async function upsertDeviceMetadata(adapter, remotePath, deviceId, opts) {
+    const p = paths(remotePath);
+    const now = new Date().toISOString();
+    // Bootstrap fast-path: caller asserts no prior record. Skip the GET.
+    // Worst case if caller is wrong: we clobber displayName/deviceType the
+    // user set on a different device — which would itself indicate the
+    // bootstrap flag was misused. Sync engine only sets bootstrap=true
+    // when it just minted the manifest in this same connect cycle.
+    const existing = opts?.bootstrap
+        ? null
+        : await readJsonIfExists(adapter, p.deviceFile(deviceId));
+    const touchedObserved = opts?.observedManifestGeneration !== undefined
+        || opts?.observedEpoch !== undefined
+        || opts?.observedWatermarkHlc !== undefined
+        || opts?.observedGcFloorHlc !== undefined;
+    const next = {
+        deviceId,
+        registeredAt: existing?.registeredAt ?? now,
+        lastSeenAt: opts?.skipTouchIfUnchanged ? (existing?.lastSeenAt ?? now) : now,
+        userId: existing?.userId,
+        name: existing?.name,
+        displayName: opts?.displayName ?? existing?.displayName,
+        deviceType: opts?.deviceType ?? existing?.deviceType,
+        retired: existing?.retired,
+        observedManifestGeneration: opts?.observedManifestGeneration ?? existing?.observedManifestGeneration,
+        observedEpoch: opts?.observedEpoch ?? existing?.observedEpoch,
+        observedWatermarkHlc: opts?.observedWatermarkHlc ?? existing?.observedWatermarkHlc,
+        observedGcFloorHlc: opts?.observedGcFloorHlc ?? existing?.observedGcFloorHlc,
+        observedAt: touchedObserved
+            ? (opts?.skipTouchIfUnchanged ? (existing?.observedAt ?? now) : now)
+            : existing?.observedAt,
+        cutOffAt: existing?.cutOffAt,
+        cutOffReason: existing?.cutOffReason,
+    };
+    if (opts?.skipTouchIfUnchanged && existing && JSON.stringify(existing) === JSON.stringify(next))
+        return;
+    if (opts?.skipTouchIfUnchanged && touchedObserved && existing) {
+        const observedChanged = existing.observedManifestGeneration !== next.observedManifestGeneration
+            || existing.observedEpoch !== next.observedEpoch
+            || existing.observedWatermarkHlc !== next.observedWatermarkHlc
+            || existing.observedGcFloorHlc !== next.observedGcFloorHlc
+            || existing.displayName !== next.displayName
+            || existing.deviceType !== next.deviceType
+            || existing.retired !== next.retired
+            || existing.cutOffAt !== next.cutOffAt
+            || existing.cutOffReason !== next.cutOffReason
+            || existing.userId !== next.userId
+            || existing.name !== next.name;
+        if (!observedChanged)
+            return;
+        next.lastSeenAt = existing.lastSeenAt;
+        next.observedAt = existing.observedAt;
+    }
+    if (opts?.skipTouchIfUnchanged && existing) {
+        next.lastSeenAt = existing.lastSeenAt;
+        if (!touchedObserved)
+            next.observedAt = existing.observedAt;
+    }
+    await writeJson(adapter, p.deviceFile(deviceId), next);
+}

package/dist/core/pull.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pull — download remote changes and merge into local state.
+ *
+ * Extracted from Interocitor. Not part of the public API.
+ */
+import type { StorageAdapter, LocalStoreAdapter, Row, Op, SyncEvent, DatabaseSchemaDefinition } from './types.ts';
+import type { HLC } from './types.ts';
+import type { CodecState } from './codec.ts';
+export interface PullContext {
+    adapter: StorageAdapter;
+    local: LocalStoreAdapter;
+    remotePath: string;
+    codecState: CodecState;
+    hlc: HLC;
+    deviceId: string;
+    tables: Record<string, Record<string, Row>>;
+    knownTables: Set<string>;
+    schema?: DatabaseSchemaDefinition;
+    emit: (event: SyncEvent) => void;
+    ensureRowsCached: (ops: Op[]) => Promise<void>;
+    poisonRemote: (error: unknown, path?: string) => Promise<Error>;
+    loadOrCreateManifest: () => Promise<void>;
+}
+/** Returns the updated HLC after pull. */
+export declare function pull(ctx: PullContext): Promise<HLC>;
+//# sourceMappingURL=pull.d.ts.map

package/dist/core/pull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../src/core/pull.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EACjB,GAAG,EACH,EAAE,EAEF,SAAS,EACT,wBAAwB,EACzB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAKtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,iBAAiB,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC;IACvB,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAC5C,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IACjC,gBAAgB,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IAChE,oBAAoB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAiBD,0CAA0C;AAC1C,wBAAsB,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAiGzD"}

package/dist/core/pull.js

@@ -0,0 +1,113 @@
+/**
+ * Pull — download remote changes and merge into local state.
+ *
+ * Extracted from Interocitor. Not part of the public API.
+ */
+import { hlcParse, hlcReceive, hlcCompareStr, hlcSerialize } from "./hlc.js";
+import { applyChangeEntry } from "./crdt.js";
+import { paths, textDecoder, log } from "./internals.js";
+import { decodeChangePayload } from "./codec.js";
+import { readJsonIfExists } from "./manifest.js";
+function emitAffectedRows(affected, knownTables, emit) {
+    for (const row of affected) {
+        knownTables.add(row._meta.table);
+        if (row._meta.deleted) {
+            emit({ type: 'delete', table: row._meta.table, rowId: row._meta.rowId });
+        }
+        else {
+            emit({ type: 'change', table: row._meta.table, rowId: row._meta.rowId, row });
+        }
+    }
+}
+/** Returns the updated HLC after pull. */
+export async function pull(ctx) {
+    const { adapter, local, remotePath, codecState, tables, knownTables, emit } = ctx;
+    let hlc = ctx.hlc;
+    log('debug', 'pull() — start');
+    emit({ type: 'sync:start' });
+    try {
+        await ctx.loadOrCreateManifest();
+        const p = paths(remotePath);
+        const cursorRaw = await local.getMeta('cursor');
+        const cursor = typeof cursorRaw === 'string' ? cursorRaw : '';
+        // Fast path: if global head hasn't advanced past cursor, skip listing.
+        const head = await readJsonIfExists(adapter, p.changesHead);
+        emit({
+            type: 'trace:head',
+            op: 'read',
+            reason: 'pull-fast-path',
+            path: p.changesHead,
+            priorHlc: head?.latestHlc ?? null,
+        });
+        if (head?.latestHlc && cursor && hlcCompareStr(head.latestHlc, cursor) <= 0) {
+            log('debug', 'pull() — head unchanged, skipping');
+            emit({
+                type: 'trace:head',
+                op: 'skip-no-change',
+                reason: 'pull-fast-path',
+                path: p.changesHead,
+                priorHlc: head.latestHlc,
+                nextHlc: cursor,
+            });
+            emit({ type: 'sync:complete', entriesMerged: 0 });
+            return hlc;
+        }
+        // List the flat changes folder once.
+        let files;
+        try {
+            files = await adapter.listFiles(p.changesFolder);
+        }
+        catch {
+            log('debug', 'pull() — changes folder not found, nothing to merge');
+            emit({ type: 'sync:complete', entriesMerged: 0 });
+            return hlc;
+        }
+        files.sort((a, b) => a.name.localeCompare(b.name));
+        let totalMerged = 0;
+        let latestMergedHlc = cursor;
+        for (const file of files) {
+            if (file.name === 'head.json')
+                continue;
+            try {
+                const chgIdx = file.name.lastIndexOf('-chg_');
+                if (chgIdx === -1)
+                    continue;
+                const fileHlc = file.name.slice(0, chgIdx);
+                if (cursor && hlcCompareStr(fileHlc, cursor) <= 0)
+                    continue;
+                const raw = textDecoder.decode(await adapter.readFile(file.path));
+                const entry = await decodeChangePayload(codecState, local, raw, file.path);
+                if (cursor && hlcCompareStr(entry.hlc, cursor) <= 0)
+                    continue;
+                const remoteHlc = hlcParse(entry.hlc);
+                hlc = hlcReceive(hlc, remoteHlc);
+                await ctx.ensureRowsCached(entry.ops);
+                const affected = applyChangeEntry(tables, entry, codecState.manifest?.schema ?? 1, ctx.schema);
+                if (affected.length > 0) {
+                    await local.putRows(affected);
+                    totalMerged += affected.length;
+                    emitAffectedRows(affected, knownTables, emit);
+                }
+                if (!latestMergedHlc || hlcCompareStr(entry.hlc, latestMergedHlc) > 0) {
+                    latestMergedHlc = entry.hlc;
+                }
+            }
+            catch (err) {
+                emit({ type: 'decode:error', error: err instanceof Error ? err : new Error(String(err)), path: file.path, context: { stage: 'pull', name: file.name } });
+                throw await ctx.poisonRemote(err, file.path);
+            }
+        }
+        if (latestMergedHlc && latestMergedHlc !== cursor) {
+            await local.setMeta('cursor', latestMergedHlc);
+        }
+        await local.setMeta('hlc', hlcSerialize(hlc));
+        log('debug', 'pull() — complete', { totalMerged });
+        emit({ type: 'sync:complete', entriesMerged: totalMerged });
+        return hlc;
+    }
+    catch (err) {
+        log('error', 'pull() — failed', err);
+        emit({ type: 'sync:error', error: err });
+        throw err;
+    }
+}

package/dist/core/row-id.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Stable client-side row ID generator.
+ *
+ * Use for synced rows. Do not use auto-increment IDs across devices.
+ * Default output uses `crypto.randomUUID()` when available.
+ */
+export interface CreateRowIdOptions {
+    /** Optional prefix like `task`, `meal`, `note`. */
+    prefix?: string;
+}
+export declare function createRowId(options?: CreateRowIdOptions): string;
+//# sourceMappingURL=row-id.d.ts.map

package/dist/core/row-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-id.d.ts","sourceRoot":"","sources":["../../src/core/row-id.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAQD,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,MAAM,CAKpE"}

package/dist/core/row-id.js

@@ -0,0 +1,11 @@
+function randomHex(bytes) {
+    const buf = new Uint8Array(bytes);
+    crypto.getRandomValues(buf);
+    return Array.from(buf, b => b.toString(16).padStart(2, '0')).join('');
+}
+export function createRowId(options = {}) {
+    const base = typeof crypto.randomUUID === 'function'
+        ? crypto.randomUUID()
+        : `${randomHex(8)}-${randomHex(4)}-${randomHex(4)}-${randomHex(4)}-${randomHex(12)}`;
+    return options.prefix ? `${options.prefix}_${base}` : base;
+}

package/dist/core/schema-types.d.ts

@@ -0,0 +1,26 @@
+import type { IndexableSchemaField, OptionalSchemaField, SchemaField } from './types.ts';
+type BaseField<T, K extends import('./types.ts').SchemaFieldKind> = SchemaField<T, K> & {
+    readonly optional: OptionalSchemaField<T, K>;
+};
+type BaseIndexableField<T> = IndexableSchemaField<T> & {
+    readonly optional: OptionalSchemaField<T, import('./types.ts').IndexableSchemaFieldKind>;
+};
+export declare const types: {
+    string: BaseIndexableField<string>;
+    number: BaseIndexableField<number>;
+    boolean: BaseIndexableField<boolean>;
+    date: BaseIndexableField<Date>;
+    Date: BaseIndexableField<Date>;
+    json: BaseField<unknown, "json">;
+    /** Type a JSON field explicitly: `types.typed<MyType[]>('json')` */
+    typed<T>(kind: "json"): BaseField<T, "json">;
+    enum<const T extends string>(..._values: T[]): BaseIndexableField<T>;
+    index<T>(field: IndexableSchemaField<T> & {
+        __optional?: never;
+    }): IndexableSchemaField<T>;
+    unique<T>(field: IndexableSchemaField<T> & {
+        __optional?: never;
+    }): IndexableSchemaField<T>;
+};
+export {};
+//# sourceMappingURL=schema-types.d.ts.map

package/dist/core/schema-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-types.d.ts","sourceRoot":"","sources":["../../src/core/schema-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzF,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,YAAY,EAAE,eAAe,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IACtF,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC9C,CAAC;AAEF,KAAK,kBAAkB,CAAC,CAAC,IAAI,oBAAoB,CAAC,CAAC,CAAC,GAAG;IACrD,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,EAAE,OAAO,YAAY,EAAE,wBAAwB,CAAC,CAAC;CAC1F,CAAC;AAaF,eAAO,MAAM,KAAK;YAC8D,kBAAkB,CAAC,MAAM,CAAC;YAC1B,kBAAkB,CAAC,MAAM,CAAC;aACzB,kBAAkB,CAAC,OAAO,CAAC;UAC9B,kBAAkB,CAAC,IAAI,CAAC;UACxB,kBAAkB,CAAC,IAAI,CAAC;UAC9B,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAEhG,oEAAoE;UAC9D,CAAC,QAAQ,MAAM,GAAG,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;eAIjC,CAAC,SAAS,MAAM,cAAc,CAAC,EAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC;UAI9D,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,GAAG;QAAE,UAAU,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,oBAAoB,CAAC,CAAC,CAAC;WAInF,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,GAAG;QAAE,UAAU,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,oBAAoB,CAAC,CAAC,CAAC;CAG5F,CAAC"}

package/dist/core/schema-types.js

@@ -0,0 +1,31 @@
+function withOptional(field) {
+    const base = field;
+    Object.defineProperty(base, 'optional', {
+        value: { ...field, optional: true, __optional: true },
+        enumerable: true,
+        configurable: false,
+        writable: false,
+    });
+    return base;
+}
+export const types = {
+    string: withOptional({ kind: 'string' }),
+    number: withOptional({ kind: 'number' }),
+    boolean: withOptional({ kind: 'boolean' }),
+    date: withOptional({ kind: 'date' }),
+    Date: withOptional({ kind: 'date' }),
+    json: withOptional({ kind: 'json' }),
+    /** Type a JSON field explicitly: `types.typed<MyType[]>('json')` */
+    typed(kind) {
+        return withOptional({ kind });
+    },
+    enum(..._values) {
+        return withOptional({ kind: 'enum' });
+    },
+    index(field) {
+        return { ...field, index: true };
+    },
+    unique(field) {
+        return { ...field, index: true, unique: true };
+    },
+};

package/dist/core/schema-types.type-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema-types.type-test.d.ts.map

package/dist/core/schema-types.type-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-types.type-test.d.ts","sourceRoot":"","sources":["../../src/core/schema-types.type-test.ts"],"names":[],"mappings":""}

package/dist/core/schema-types.type-test.js

@@ -0,0 +1,224 @@
+import { types } from "./schema-types.js";
+// ─── Scalar types carry their generic ────────────────────────────────
+const _s = types.string;
+const _n = types.number;
+const _b = types.boolean;
+const _d = types.date;
+const _D = types.Date;
+const _j = types.json;
+void _s;
+void _n;
+void _b;
+void _d;
+void _D;
+void _j;
+// ─── enum() infers literal union from const generic ─────────────────
+const statusType = types.enum('open', 'done', 'archived');
+void statusType;
+const indexedStatus = types.index(types.enum('open', 'done', 'archived'));
+const uniqueRole = types.unique(types.enum('admin', 'viewer'));
+void indexedStatus;
+void uniqueRole;
+// @ts-expect-error — 'open'|'done'|'other' is wider than the target 'open'|'done'
+const _wrongEnum = types.enum('open', 'done', 'other');
+void _wrongEnum;
+// @ts-expect-error — string is wider than 'open'|'done'
+const _enumNotString = types.index(types.string);
+void _enumNotString;
+// ─── index() and unique() return the same flat shape with flags set ──
+const indexedString = types.index(types.string);
+const uniqueNumber = types.unique(types.number);
+const indexedDate = types.index(types.Date);
+void indexedString;
+void uniqueNumber;
+void indexedDate;
+// @ts-expect-error — IndexableSchemaField<string> is not IndexableSchemaField<number>
+const _wrongGeneric = types.index(types.string);
+void _wrongGeneric;
+// ─── json is not indexable ──────────────────────────────────────────
+// @ts-expect-error — SchemaField<unknown> (json) is not IndexableSchemaField
+types.index(types.json);
+// @ts-expect-error — SchemaField<unknown> (json) is not IndexableSchemaField
+types.unique(types.json);
+// ─── Can't pass an already-indexed field back into index/unique ──────
+// (IndexableSchemaField is still IndexableSchemaField — nesting compiles,
+//  but index/unique are idempotent by design; the flag just stays true)
+// ─── Bare string literal is not a valid field descriptor ─────────────
+// @ts-expect-error — 'string' is not IndexableSchemaField
+types.index('string');
+// ─── Full schema definition compiles ────────────────────────────────
+const schema = {
+    tables: {
+        tasks: {
+            fields: {
+                status: types.index(types.enum('open', 'done', 'archived')),
+                assignee: types.unique(types.string),
+                priority: types.index(types.number),
+                dueDate: types.Date,
+                payload: types.json,
+            },
+        },
+    },
+};
+void schema;
+// ─── Generic DatabaseSchemaDefinition + InferSchemaType ─────────────
+// Build a typed schema via `satisfies` — TS widens to the generic but keeps
+// the phantom types intact for inference.
+const typedSchema = {
+    tables: {
+        tasks: {
+            fields: {
+                title: types.string,
+                status: types.enum('open', 'done'),
+                priority: types.number,
+            },
+        },
+        notes: {
+            fields: {
+                content: types.string,
+                pinned: types.boolean,
+            },
+        },
+    },
+};
+// Field types are correct
+const _taskTitle = 'hello';
+const _taskStatus = 'open';
+const _taskPrio = 42;
+const _noteContent = 'text';
+const _notePinned = true;
+void _taskTitle;
+void _taskStatus;
+void _taskPrio;
+void _noteContent;
+void _notePinned;
+// InferTableType matches direct extraction
+const _same = {};
+void _same;
+// @ts-expect-error — 'other' is not in the 'open'|'done' union
+const _badStatus = 'other';
+void _badStatus;
+// @ts-expect-error — number is not string
+const _badTitle = 42;
+void _badTitle;
+// ─── TableSchemaDefinition<T> typed fields ───────────────────────────
+// Valid typed table schema compiles
+const _validTableSchema = {
+    fields: { title: types.string, priority: types.number },
+};
+void _validTableSchema;
+// Field type mismatch — SchemaField<number> is not SchemaField<string>
+const _mismatchedField = {
+    // @ts-expect-error — IndexableSchemaField<number> is not SchemaField<string>
+    fields: { title: types.number },
+};
+void _mismatchedField;
+// ─── SyncConfig<S> carries schema type ──────────────────────────────
+// Config typed explicitly — schema must match S
+const _config = {
+    remotePath: '/App',
+    appName: 'App',
+    schema: {
+        tables: { tasks: { fields: { title: types.string } } },
+    },
+};
+void _config;
+// Schema field type mismatch caught inline
+const _badConfig = {
+    remotePath: '/App',
+    appName: 'App',
+    schema: {
+        tables: { tasks: { fields: {
+                    // @ts-expect-error — IndexableSchemaField<number> is not SchemaField<string>
+                    title: types.number,
+                } } },
+    },
+};
+void _badConfig;
+const tasksTable = typedEngine.table('tasks');
+const _addOk = { title: 'x', status: 'open', priority: 1 };
+// @ts-expect-error — missing required field status
+const _addBad = { title: 'x', priority: 1 };
+const _replaceOk = { title: 'x', status: 'open', priority: 1 };
+// @ts-expect-error — missing required field priority
+const _replaceBad = { title: 'x', status: 'open' };
+void _addOk;
+void _replaceOk;
+// _TasksRow should be { title: string; ... } | undefined — not Record<string,unknown>
+const _checkRow = { title: 'x', status: 'open', priority: 1 };
+void _checkRow;
+// @ts-expect-error — 'nonexistent' is not keyof DB (no fallback overload)
+typedEngine.table('nonexistent');
+// ─── Regression: satisfies DatabaseSchemaDefinition infers correctly ─
+const userSchema = {
+    tables: {
+        weekPlans: {
+            fields: {
+                weekId: types.string,
+                plan: types.json,
+                createdAt: types.date,
+            },
+        },
+        receipts: {
+            fields: {
+                id: types.string,
+                weekId: types.index(types.string),
+                totalActual: types.number,
+            },
+        },
+    },
+};
+const _wp = { weekId: 'w1', plan: {}, createdAt: new Date() };
+const _r = { id: 'r1', weekId: 'w1', totalActual: 42 };
+void _wp;
+void _r;
+// @ts-expect-error — number not assignable to string
+const _badWp = { weekId: 42, plan: {}, createdAt: new Date() };
+void _badWp;
+// ─── _type phantom: no undefined bleeding into field types ───────────
+const _weekId = 'hello'; // string not string|undefined
+const _date = new Date(); // Date not Date|undefined
+const _num = 42; // number
+// @ts-expect-error — string is not number
+const _badNum = 'x';
+// ─── Optional fields ─────────────────────────────────────────────────
+const _optionalStringField = types.string.optional;
+const _optionalJsonField = types.typed('json').optional;
+// @ts-expect-error — optional fields cannot be indexed
+const _optionalIndexedString = types.index(types.string.optional);
+// @ts-expect-error — optional fields cannot be unique
+const _optionalUniqueString = types.unique(types.string.optional);
+const optionalSchema = {
+    tables: {
+        tasks: {
+            fields: {
+                title: types.string,
+                note: types.string.optional,
+                payload: types.typed('json').optional,
+            },
+        },
+    },
+};
+const _optionalOk1 = { title: 'x' };
+const _noteRead = _optRow.note;
+// @ts-expect-error — optional field is string | undefined, not string
+const _noteStrict = _optRow.note;
+void _noteRead;
+void _noteStrict;
+const _optionalOk2 = { title: 'x', note: 'hello', payload: { foo: 'bar' } };
+// @ts-expect-error — title required
+const _optionalBad1 = { note: 'hello' };
+// @ts-expect-error — note must be string when present
+const _optionalBad2 = { title: 'x', note: 42 };
+// @ts-expect-error — payload must match typed JSON payload
+const _optionalBad3 = { title: 'x', payload: { foo: 42 } };
+void _optionalStringField;
+void _optionalJsonField;
+void _optionalIndexedString;
+void _optionalUniqueString;
+void _optionalOk1;
+void _optionalOk2;
+void _weekId;
+void _date;
+void _num;
+void _badNum;