@aigne/afs-did-space 1.12.0-beta.5

package/dist/changelog-schema.d.cts

@@ -0,0 +1,395 @@
+//#region src/changelog-schema.d.ts
+/**
+ * Changelog table schema — single source of truth for the four runtimes:
+ *   - D1 (Cloudflare Worker)         : migrations/0008_changelog.sql + d1-tree-index.ts
+ *   - desktop SQLite (libsql)        : metadata-db.ts ensureChangelogTable()
+ *   - Swift SQLite (mobile)          : SQLiteTreeIndex.swift migrate()
+ *   - Kotlin SQLite (mobile)         : SQLiteTreeIndex.kt migrate()
+ *
+ * The CI parity script (`scripts/check-changelog-ddl-parity.ts`) reads the
+ * DDL strings out of all four locations, normalises whitespace, lower-cases
+ * keywords/identifiers, and asserts byte equality.
+ *
+ * **Do not edit any of those four sources without updating the others.**
+ *
+ * Phase 2 Task 2.1 introduces the schema only — `put`/`delete` start writing
+ * changelog rows in Task 2.4. Until then the table sits empty.
+ */
+/** CREATE TABLE statement. Idempotent (`IF NOT EXISTS`). */
+declare const CHANGELOG_TABLE_SQL = "CREATE TABLE IF NOT EXISTS ds_changelog (\n  seq INTEGER PRIMARY KEY AUTOINCREMENT,\n  scope TEXT NOT NULL,\n  path TEXT NOT NULL,\n  op TEXT NOT NULL,\n  cid TEXT,\n  old_cid TEXT,\n  size INTEGER,\n  mtime INTEGER NOT NULL,\n  device_id TEXT NOT NULL,\n  CHECK (op IN ('put', 'delete'))\n)";
+/**
+ * CREATE INDEX statements. Order matches migration file.
+ *
+ * The cid / old_cid indexes are **scope-composite** (`(scope, cid)` /
+ * `(scope, old_cid)`), NOT bare `(cid)` / `(old_cid)`: the only readers are
+ * `isReferenced` / `isReferencedMany`, which ALWAYS filter `scope = ?` (read-
+ * auth, design §7.2). A bare-cid index forces the `cid IN (…)` seek to fan out
+ * across every scope + the whole append-only history (Model B global object
+ * pool) and residual-filter scope afterwards — the 7180× rows_read blow-up on
+ * staging D1. Leading `scope` collapses the seek to one user's rows. No live
+ * SCOPE-BLIND reader exists (GC liveness uses entries-only `referencedAnywhere`;
+ * the scope-blind three-way `D1GCQueue.isReferenced` is retired), so these
+ * replace the old globals rather than adding to them — index count unchanged,
+ * no extra write-amplification on the hot append-only changelog.
+ */
+declare const CHANGELOG_INDEX_SQL: readonly string[];
+/**
+ * Migration 0110 — swap the legacy bare-cid changelog indexes for the
+ * scope-composite ones above. An explicit `DROP` is required: `CREATE INDEX
+ * IF NOT EXISTS idx_changelog_scope_cid …` lands the new index on fresh DBs,
+ * but an already-deployed DB carries the OLD `idx_changelog_cid` / `_old_cid`
+ * names — those must be dropped or they linger as orphan indexes, still
+ * maintained on every changelog insert. Fresh DBs apply the regenerated 0100
+ * (new names) THEN this (DROP no-ops on the absent old names, CREATE no-ops on
+ * the already-present new ones) → idempotent both ways. Sourced here so the
+ * migration and `ensureTable` share one definition. D1 + Node libsql only
+ * (mobile single-device runtimes have no scope selectivity to gain).
+ */
+declare const CHANGELOG_SCOPE_CID_MIGRATION_SQL: readonly string[];
+/**
+ * Combined DDL block (table + indices), separated by `;\n`.
+ *
+ * This is the canonical form against which Swift/Kotlin literals and the
+ * migration SQL file are compared. The parity script normalises whitespace
+ * and case before byte-comparing, so reformatting any one location is fine
+ * as long as the SQL semantics stay identical.
+ */
+declare const CHANGELOG_DDL: string;
+/**
+ * Phase 2 Task 2.2 — `device_sync_state` table (D1 only).
+ *
+ * Worker-side per-device sync progress tracker. Unlike `changelog`, this
+ * table lives ONLY in Cloudflare D1; mobile runtimes do not mirror it.
+ * Each row records the highest changelog.seq a device has acknowledged
+ * plus heartbeat timestamps.
+ *
+ * Columns:
+ *   - scope         : DID Space scope (matches changelog.scope semantics)
+ *   - device_id     : opaque device identifier from request header
+ *   - last_seq      : highest changelog.seq this device has consumed
+ *   - last_sync_at  : unix millis of last successful advancement of last_seq
+ *   - last_seen_at  : unix millis of most recent heartbeat / HTTP touch
+ *
+ * Composite PRIMARY KEY `(scope, device_id)` means the table is a regular
+ * rowid table (no WITHOUT ROWID) so row updates stay cheap.
+ *
+ * NOT parity-checked by `scripts/check-changelog-ddl-parity.ts` — this DDL
+ * is D1-only. Kept here beside `CHANGELOG_*` so the full D1 schema sits in
+ * one file for future readers.
+ */
+declare const DEVICE_SYNC_STATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS ds_device_sync_state (\n  scope TEXT NOT NULL,\n  device_id TEXT NOT NULL,\n  last_seq INTEGER NOT NULL DEFAULT 0,\n  last_sync_at INTEGER NOT NULL,\n  last_seen_at INTEGER NOT NULL,\n  PRIMARY KEY (scope, device_id)\n)";
+/** CREATE INDEX statements for `device_sync_state`. Order matches migration. */
+declare const DEVICE_SYNC_STATE_INDEX_SQL: readonly string[];
+/**
+ * Phase 2 Task 2.3 — `scope_meta` table (D1 only).
+ *
+ * Per-scope compaction metadata for the Cloudflare Worker. One row per
+ * DID Space scope. Written by G16 emergency compaction; read by the
+ * G5.a sync endpoint to decide whether to 409 incoming pulls whose
+ * `since` sits below the compaction watermark.
+ *
+ * Columns:
+ *   - scope                  : DID Space scope (matches changelog.scope)
+ *   - compacted_below_seq    : highest seq that has been compacted away;
+ *                              incoming syncs with since < this value
+ *                              must receive a 409 requireFullResync.
+ *                              Monotonically non-decreasing.
+ *   - last_compaction_at     : unix millis of most recent compaction pass
+ *   - total_changelog_writes : running counter of changelog rows ever
+ *                              written to this scope (deletes do NOT
+ *                              decrement); used by G16 to decide when to
+ *                              trigger emergency compaction
+ *   - file_count             : live count of `kind='file'` rows in `entries`
+ *                              for this scope. Maintained by the two
+ *                              `trg_entries_file_count_*` triggers below so
+ *                              the per-write capacity guard reads ONE row
+ *                              instead of a full-scope `COUNT(*)` scan (the
+ *                              O(N²) rows_read blow-up that exhausted the D1
+ *                              free tier during bulk sync). UNLIKE
+ *                              total_changelog_writes, deletes DO decrement it
+ *                              (floored at 0).
+ *
+ * Scopes are lazy-initialised: the row is NOT created on first changelog
+ * write. It's only materialised when compaction first runs for the
+ * scope. The `getCompactedBelowSeq` helper returns 0 for missing rows —
+ * the correct "nothing compacted yet" sentinel.
+ *
+ * PRIMARY KEY on `scope` makes this a regular rowid table; no secondary
+ * indices are needed since all lookups are by PK.
+ *
+ * NOT parity-checked by `scripts/check-changelog-ddl-parity.ts` — this
+ * DDL is D1-only (mobile runtimes do not mirror it). Kept here beside
+ * `CHANGELOG_*` and `DEVICE_SYNC_STATE_*` so the full D1 schema sits in
+ * one file for future readers.
+ */
+declare const SCOPE_META_TABLE_SQL = "CREATE TABLE IF NOT EXISTS ds_scope_meta (\n  scope TEXT PRIMARY KEY,\n  compacted_below_seq INTEGER NOT NULL DEFAULT 0,\n  last_compaction_at INTEGER NOT NULL DEFAULT 0,\n  total_changelog_writes INTEGER NOT NULL DEFAULT 0,\n  file_count INTEGER NOT NULL DEFAULT 0\n)";
+/**
+ * Additive ALTER for the `total_bytes` running-total (upload-limits Phase 5,
+ * byte-quota D3). total_bytes is added ONLY via this ALTER — NOT in the CREATE
+ * TABLE above — so the single migration that introduces it works on BOTH a
+ * fresh DB and an already-deployed scope_meta (an `ADD COLUMN` in the CREATE
+ * would collide with the migration's ALTER on a fresh DB; the runner is not
+ * idempotent on "duplicate column"). The runtime probe-then-ALTER in
+ * D1TreeIndex.ensureTable applies it to fresh test/dev DBs; production deploys
+ * apply the generated migration. Defaulted + NOT NULL → safe additive ALTER.
+ */
+declare const SCOPE_META_TOTAL_BYTES_COLUMN_SQL = "ALTER TABLE ds_scope_meta ADD COLUMN total_bytes INTEGER NOT NULL DEFAULT 0";
+/**
+ * Trigger that keeps `scope_meta.file_count` incrementing in lock-step with
+ * new `kind='file'` rows in `entries`. It exists so the capacity guard in
+ * `D1TreeIndex.put()` can read a single `scope_meta` row instead of issuing a
+ * full-scope `SELECT COUNT(*) FROM entries` on every new-file write — that
+ * scan read the WHOLE scope each time, turning a bulk sync of N files into
+ * ~N²/2 D1 `rows_read` and blowing past the free-tier 5M/day ceiling.
+ *
+ * INCREMENT via trigger; DECREMENT in app code — asymmetric on purpose.
+ * Cloudflare's D1 counts a statement's TRIGGER side-effects in `meta.changes`
+ * (verified on workerd: deleting 2 files + 1 dir with an AFTER-DELETE trigger
+ * reports 5, not 3). `deleteByPrefix` RETURNS `meta.changes`, so an
+ * AFTER-DELETE trigger would silently inflate that documented count. Inserts
+ * are safe — neither `put` nor `putBatch` reads `meta.changes` — so the
+ * increment stays a trigger (covering both paths for free), while
+ * `delete`/`deleteByPrefix` decrement `file_count` with their own batch
+ * statement, computed atomically from the pre-delete entries state. See
+ * `D1TreeIndex.delete` / `deleteByPrefix`.
+ *
+ * Trigger semantics:
+ *   - INSERT of a `kind='file'` row → +1 (upsert creates the scope_meta row
+ *     lazily on first file). Dir rows (`kind='dir'`) and `INSERT OR IGNORE`
+ *     no-ops never fire. An overwrite (`ON CONFLICT DO UPDATE` on entries) is
+ *     an UPDATE, not an INSERT, so it correctly leaves the count alone.
+ *
+ * D1-only (mobile runtimes don't mirror scope_meta). NOT parity-checked.
+ *
+ * NOTE: the body contains an inner `;` (required by SQLite trigger grammar).
+ * Any SQL splitter that feeds this to D1 one statement at a time MUST keep
+ * the `CREATE TRIGGER … BEGIN … END` block whole — see
+ * `runtimes/cloudflare/scripts/apply-d1-migrations.mjs` `splitSqlStatements`.
+ */
+declare const SCOPE_META_FILE_COUNT_TRIGGER_SQL: readonly string[];
+/**
+ * Triggers that keep `scope_meta.total_bytes` (upload-limits Phase 5 byte-quota
+ * D3) in lock-step with the `size` of `kind='file'` rows — mirroring the
+ * file_count trigger so the byte quota reads ONE scope_meta row instead of a
+ * `SELECT SUM(size)` full-scope scan (the rejected O(N) rows_read anti-pattern
+ * that caused the 503, did-space-d1-filecount-fix).
+ *
+ *   - INSERT of a new file → `+= NEW.size` (lazy upsert of the scope_meta row).
+ *   - UPDATE (overwrite, same path, new content/size) → `+= NEW.size - OLD.size`.
+ *     Safe as a trigger because put/putBatch do NOT read `meta.changes` — only
+ *     `deleteByPrefix` does, so DELETE decrements in app code (below), exactly
+ *     like file_count. Floored at 0 against drift.
+ *
+ * D1-only (mobile runtimes don't mirror scope_meta). NOT parity-checked. Each
+ * `CREATE TRIGGER … BEGIN … END` block has an inner `;` — keep it whole when
+ * splitting SQL (see apply-d1-migrations.mjs splitSqlStatements).
+ */
+declare const SCOPE_META_TOTAL_BYTES_TRIGGER_SQL: readonly string[];
+/**
+ * One-time backfill: seed `total_bytes` from the current file rows for every
+ * scope. Absolute (`SET = excluded.total_bytes`) so it self-corrects against a
+ * concurrent write between trigger creation and this statement. Migration-only.
+ */
+declare const SCOPE_META_TOTAL_BYTES_BACKFILL_SQL = "INSERT INTO ds_scope_meta (scope, total_bytes)\n  SELECT scope, COALESCE(SUM(size), 0) FROM ds_entries WHERE kind = 'file' GROUP BY scope\n  ON CONFLICT(scope) DO UPDATE SET total_bytes = excluded.total_bytes";
+/**
+ * Decrement statement for `delete()`: −1 iff `path` is currently a file.
+ * Placed in the delete batch BEFORE the `DELETE FROM entries` so the EXISTS
+ * subquery observes the pre-delete row. Floored at 0. Bind order:
+ * `(scope, scope, path)`.
+ */
+declare const SCOPE_META_FILE_COUNT_DELETE_ONE_SQL = "UPDATE ds_scope_meta\n  SET file_count = MAX(0, file_count - 1)\n  WHERE scope = ? AND EXISTS (\n    SELECT 1 FROM ds_entries WHERE scope = ? AND path = ? AND kind = 'file'\n  )";
+/**
+ * Decrement statement for `deleteByPrefix()`: subtract the number of file rows
+ * in the prefix range. Placed in the batch BEFORE the range `DELETE` so the
+ * COUNT observes the pre-delete rows; the COUNT scans only the range being
+ * deleted (never the whole scope). Floored at 0. Bind order:
+ * `(scope, scope, lo, hi)`.
+ */
+declare const SCOPE_META_FILE_COUNT_DELETE_RANGE_SQL = "UPDATE ds_scope_meta\n  SET file_count = MAX(0, file_count - (\n    SELECT COUNT(*) FROM ds_entries\n    WHERE scope = ? AND path >= ? AND path < ? AND kind = 'file'\n  ))\n  WHERE scope = ?";
+/**
+ * One-time backfill: seed `file_count` from the current `entries` rows for
+ * every scope that already has files. Absolute (`SET = excluded.file_count`,
+ * not `+=`) so it is self-correcting if a concurrent write fires a trigger
+ * between trigger creation and this statement. Migration-only — fresh DBs
+ * (tests / first deploy) start empty and need no backfill.
+ */
+declare const SCOPE_META_FILE_COUNT_BACKFILL_SQL = "INSERT INTO ds_scope_meta (scope, file_count)\n  SELECT scope, COUNT(*) FROM ds_entries WHERE kind = 'file' GROUP BY scope\n  ON CONFLICT(scope) DO UPDATE SET file_count = excluded.file_count";
+/**
+ * CREATE INDEX statements for `scope_meta`. Empty by design — lookups are
+ * always by the PRIMARY KEY, so the autogenerated PK index is sufficient.
+ * Exported as an empty array for symmetry with `CHANGELOG_INDEX_SQL` and
+ * `DEVICE_SYNC_STATE_INDEX_SQL` so callers can loop uniformly.
+ */
+declare const SCOPE_META_INDEX_SQL: readonly string[];
+/**
+ * Live Update Resilience Phase 0 (DEC-7 / design §11.4) — `prefix_watermark`.
+ *
+ * Per-`(scope, prefix)` monotonic write counter. `prefix` is the FIRST path
+ * segment of a write path (the `/user` first-level collection root, e.g.
+ * `items`, `tags`). Every file write/delete INSIDE a collection (`depth >= 2`)
+ * bumps the matching row's `version` by 1, in the SAME D1 batch as the
+ * changelog INSERT (typical +1 row write-amplification).
+ *
+ * Web live-update reconcile reads ONE row (`SELECT version WHERE scope=? AND
+ * prefix=?`) to decide "did my list change?" — true O(1), independent of
+ * changelog history size or global write activity (the append-only changelog
+ * `drain` would be `O(global increment)` rows_read and hit the D1 cliff; see
+ * design §11.1-11.3 for the rejected alternatives B/D).
+ *
+ * `version` is prefix-LOCAL: it only counts writes to THIS collection root, so
+ * exposing it as the wire `liveSeq` never leaks another blocklet's timing
+ * (invariant I3). It is a plain monotonic counter, so `+1` gap detection works
+ * within a prefix (Phase 3 push self-check).
+ *
+ * NOT parity-checked by `scripts/check-changelog-ddl-parity.ts` — this table is
+ * D1-only (Cloudflare) + Node sqlite. Mobile (Swift/Kotlin) does NOT mirror it:
+ * mobile sync drains the changelog and never reads the watermark. Same handling
+ * as `scope_meta` / `device_sync_state` above.
+ */
+declare const PREFIX_WATERMARK_TABLE_SQL = "CREATE TABLE IF NOT EXISTS ds_prefix_watermark (\n  scope TEXT NOT NULL,\n  prefix TEXT NOT NULL,\n  version INTEGER NOT NULL DEFAULT 0,\n  PRIMARY KEY (scope, prefix)\n)";
+/**
+ * Phase 3 Task 3.4 — `sync_state` local key-value table.
+ *
+ * Per-scope progress tracker for the local SyncEngine. Lives in the SAME
+ * SQLite DB as `changelog` on desktop (via MetadataDB) and mobile (via
+ * SQLiteTreeIndex). Byte-identical DDL across runtimes so the three-way
+ * parity script can treat it the same way as `changelog`.
+ *
+ * Schema (Task 3.4 minimum):
+ *   key   : `{scope}:local_seq` — max seq this device has pushed to cloud
+ *   key   : `{scope}:cloud_seq` — max seq pulled/applied from other devices
+ *
+ * Task 3.5 extends usage with more keys (device_id, last_sync_at, sync_status)
+ * backed by Keychain/Keystore on mobile. The table shape is unchanged — only
+ * the set of keys written to it grows.
+ *
+ * Values are always TEXT (SQLite's universal type). Integer keys like
+ * `local_seq` are stored as decimal strings and parsed at read time. This
+ * keeps the schema a single source of truth regardless of how many key types
+ * Task 3.5 adds later.
+ *
+ * Scope-prefixed keys let multiple DID Space scopes share the same SQLite DB
+ * without colliding — matching the existing scope isolation in the changelog
+ * table.
+ */
+declare const SYNC_STATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS ds_sync_state (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL\n)";
+/** CREATE INDEX statements for `sync_state`. Empty by design — lookups are by PK. */
+declare const SYNC_STATE_INDEX_SQL: readonly string[];
+/**
+ * Combined DDL for the sync_state table + indices. Exported for the same
+ * three-way parity reasons as `CHANGELOG_DDL` — Swift and Kotlin each embed
+ * a byte-identical literal that must match this string after normalisation.
+ */
+declare const SYNC_STATE_DDL: string;
+/**
+ * Whitespace+case normaliser used by the parity script and tests.
+ *
+ * Strategy:
+ *   1. Strip SQL line comments (`-- ...` to end of line).
+ *   2. Strip C-style block comments (`/* ... *​/`) — defensive, none currently.
+ *   3. Lower-case everything (SQLite keywords + identifiers are case-insensitive).
+ *   4. Strip ALL `;` characters — different sources may add/omit a trailing
+ *      semicolon on the last statement; semantically equivalent so we drop them.
+ *   5. Collapse any whitespace run (spaces, tabs, newlines) into a single space.
+ *   6. Trim leading/trailing whitespace.
+ *   7. Remove spaces immediately around `(`, `)`, `,` so that
+ *      `changelog(scope, seq)` and `changelog ( scope , seq )` compare equal.
+ *
+ * Note: this is intentionally conservative — string literals like `'put'` and
+ * `'delete'` already happen to be lower-case, and SQLite treats string values
+ * as case-sensitive. If a future column ever needed mixed-case literals, we
+ * would have to mask string-literal regions before lower-casing.
+ */
+declare function normalizeDdl(input: string): string;
+/** `kind` discriminator for a changelog row entry on the sync wire. */
+declare const CHANGELOG_ROW_KIND = "did-space:changelog-row";
+/** `kind` discriminator for a manifest file entry on the sync wire. */
+declare const MANIFEST_FILE_KIND = "did-space:file";
+/**
+ * Field list for a changelog row's `meta.extra` (canonical sync wire).
+ * Order is documentary only — consumers read by key, never by position.
+ */
+declare const CHANGELOG_WIRE_EXTRA_FIELDS: readonly ["seq", "op", "originalPath", "cid", "oldCid", "size", "mtime", "deviceId"];
+/** Field list for a manifest entry's `meta.extra` (canonical sync wire). */
+declare const MANIFEST_WIRE_EXTRA_FIELDS: readonly ["cid", "mtime"];
+/**
+ * Canonical `meta.extra` payload of a `.changelog` row. The single position
+ * (`extra`) all four runtimes can decode. `originalPath` is the tree-path with
+ * NO leading slash (matches `changelog.path` column semantics).
+ */
+interface ChangelogWireExtra {
+  seq: number;
+  op: "put" | "delete";
+  originalPath: string;
+  cid: string | null;
+  oldCid: string | null;
+  size: number | null;
+  mtime: number;
+  deviceId: string;
+}
+/**
+ * Input row shape for {@link serializeChangelogEntry} — the on-disk changelog
+ * row returned by `TreeIndex.getChangelogSince` (snake_case columns), a subset
+ * of {@link ChangelogEntry}.
+ */
+interface ChangelogRowInput {
+  seq: number;
+  path: string;
+  op: "put" | "delete";
+  cid: string | null;
+  old_cid: string | null;
+  size: number | null;
+  mtime: number;
+  device_id: string;
+}
+/**
+ * Canonical `meta` of a manifest file entry (`list("", {maxDepth:-1})`).
+ * `cid` is emitted BOTH at top-level (additive, TS/UI) and under `extra`
+ * (Swift/Kotlin) — see the module header.
+ */
+interface ManifestWireMeta {
+  kind: typeof MANIFEST_FILE_KIND;
+  cid: string;
+  size: number;
+  mimeType?: string;
+  extra: {
+    cid: string;
+    mtime: number;
+  };
+}
+/** Input for {@link serializeManifestEntry} — the file's tree metadata. */
+interface ManifestRowInput {
+  cid: string;
+  size: number;
+  mtime: number;
+  mimeType?: string;
+}
+/**
+ * Serialize a changelog row to its canonical `meta.extra` payload. The provider
+ * wraps this as `meta: { kind: CHANGELOG_ROW_KIND, extra: serializeChangelogEntry(row) }`.
+ */
+declare function serializeChangelogEntry(row: ChangelogRowInput): ChangelogWireExtra;
+/**
+ * Serialize a manifest file entry to its canonical `meta`. `cid` is emitted at
+ * BOTH top-level and `extra.cid` (additive — see module header).
+ */
+declare function serializeManifestEntry(row: ManifestRowInput): ManifestWireMeta;
+/**
+ * Parse an untrusted changelog `meta.extra` bag into a typed {@link ChangelogWireExtra}.
+ * Returns `null` when required fields (`op`, `originalPath`) are missing/invalid —
+ * a malformed row is skipped, never crashes the parser. Numeric/optional fields
+ * degrade to safe defaults (`seq=0`, `cid=null`, …).
+ */
+declare function parseChangelogEntry(extra: unknown): ChangelogWireExtra | null;
+/**
+ * Parse an untrusted manifest entry `meta` into its canonical `{ cid, mtime }`.
+ * Reads `extra.cid` FIRST (canonical, all-runtime), falling back to top-level
+ * `meta.cid` (additive). Returns `null` when no cid is resolvable.
+ */
+declare function parseManifestEntry(meta: unknown): {
+  cid: string;
+  mtime: number;
+} | null;
+//#endregion
+export { CHANGELOG_DDL, CHANGELOG_INDEX_SQL, CHANGELOG_ROW_KIND, CHANGELOG_SCOPE_CID_MIGRATION_SQL, CHANGELOG_TABLE_SQL, CHANGELOG_WIRE_EXTRA_FIELDS, ChangelogRowInput, ChangelogWireExtra, DEVICE_SYNC_STATE_INDEX_SQL, DEVICE_SYNC_STATE_TABLE_SQL, MANIFEST_FILE_KIND, MANIFEST_WIRE_EXTRA_FIELDS, ManifestRowInput, ManifestWireMeta, PREFIX_WATERMARK_TABLE_SQL, SCOPE_META_FILE_COUNT_BACKFILL_SQL, SCOPE_META_FILE_COUNT_DELETE_ONE_SQL, SCOPE_META_FILE_COUNT_DELETE_RANGE_SQL, SCOPE_META_FILE_COUNT_TRIGGER_SQL, SCOPE_META_INDEX_SQL, SCOPE_META_TABLE_SQL, SCOPE_META_TOTAL_BYTES_BACKFILL_SQL, SCOPE_META_TOTAL_BYTES_COLUMN_SQL, SCOPE_META_TOTAL_BYTES_TRIGGER_SQL, SYNC_STATE_DDL, SYNC_STATE_INDEX_SQL, SYNC_STATE_TABLE_SQL, normalizeDdl, parseChangelogEntry, parseManifestEntry, serializeChangelogEntry, serializeManifestEntry };
+//# sourceMappingURL=changelog-schema.d.cts.map

package/dist/changelog-schema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changelog-schema.d.cts","names":[],"sources":["../src/changelog-schema.ts"],"mappings":";;AAkBA;;;;;AA4BA;;;;;AAkBA;;;;;AAeA;AAAA,cA7Da,mBAAA;;;;AAqFb;;;;;AAUA;;;;;AA8CA;;cAjHa,mBAAA;;;AAmIb;;;;;AAmCA;;;;;cApJa,iCAAA;;;;;AAiOb;;;;cAlNa,aAAA;AA4Nb;;;;;AAaA;;;;;AAcA;;;;;AAUA;;;;;AA2BA;;AAhEA,cApMa,2BAAA;;cAUA,2BAAA;AA+Wb;;;;;AAMA;;;;;AAOA;;;;;AAqBA;;;;;AA+BA;;;;;AAGA;;;;;AAMA;;;;;AAYA;;;;;AAOA;;AA7FA,cAjUa,oBAAA;;;;;;;;;;;cAkBA,iCAAA;AA4Zb;;;;;;;;;;;;;;AAgBA;;;;;;;;;;;;;;AASA;;;;AAzBA,cAzXa,iCAAA;;;;;;AA6Zb;;;;;;;;;AAiBA;;;cApZa,kCAAA;;;;;;cAmDA,mCAAA;;;;;;;cAUA,oCAAA;;;;;;;;cAaA,sCAAA;;;;;;;;cAcA,kCAAA;;;;;;;cAUA,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BA,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAqHA,oBAAA;;cAMA,oBAAA;;;;;;cAOA,cAAA;;;;;;;;;;;;;;;;;;;;iBAqBG,YAAA,CAAa,KAAA;;cA+BhB,kBAAA;;cAGA,kBAAA;;;;;cAMA,2BAAA;;cAYA,0BAAA;;;;;;UAOI,kBAAA;EACf,GAAA;EACA,EAAA;EACA,YAAA;EACA,GAAA;EACA,MAAA;EACA,IAAA;EACA,KAAA;EACA,QAAA;AAAA;;;;;;UAQe,iBAAA;EACf,GAAA;EACA,IAAA;EACA,EAAA;EACA,GAAA;EACA,OAAA;EACA,IAAA;EACA,KAAA;EACA,SAAA;AAAA;;;;;;UAQe,gBAAA;EACf,IAAA,SAAa,kBAAA;EACb,GAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA;IAAS,GAAA;IAAa,KAAA;EAAA;AAAA;;UAIP,gBAAA;EACf,GAAA;EACA,IAAA;EACA,KAAA;EACA,QAAA;AAAA;;;;;iBAOc,uBAAA,CAAwB,GAAA,EAAK,iBAAA,GAAoB,kBAAA;;;;;iBAiBjD,sBAAA,CAAuB,GAAA,EAAK,gBAAA,GAAmB,gBAAA;;;;;;;iBA2B/C,mBAAA,CAAoB,KAAA,YAAiB,kBAAA;;;;;;iBAyBrC,kBAAA,CAAmB,IAAA;EAAkB,GAAA;EAAa,KAAA;AAAA"}