@knowledge-medium/agent-cli 0.1.0

package/dist/kernel-types/src/data/internals/clientSchema.d.ts

@@ -0,0 +1,273 @@
+/** Client-side SQLite schema additions on top of the PowerSync-managed
+ *  `blocks` table. None of these tables are synced — they're the local
+ *  mechanism for tx context, per-row audit, per-tx audit, upload routing,
+ *  and local side indexes. The client-only triggers live here too —
+ *  server-side Postgres has no `powersync_crud` and no need for any of
+ *  them. See data-layer-redesign §4.2 / §4.3 / §4.4 / §4.5 / §4.1.1.
+ *
+ *  Run from `repoProvider.ts` after PowerSync's own schema initialization:
+ *
+ *      for (const stmt of CLIENT_SCHEMA_STATEMENTS) {
+ *        await db.execute(stmt)
+ *      }
+ */
+/** Single-row table. Triggers read it via
+ *  `(SELECT … FROM tx_context WHERE id = 1)`. Why not a TEMP table:
+ *  triggers in `main` schema cannot reference `temp.X` tables. The
+ *  TxEngine sets all five fields at the start of `writeTransaction`
+ *  and clears them (back to NULL) at the end.
+ *
+ *  `tx_seq` is the integer tx-grouping key the upload-routing triggers
+ *  copy into `ps_crud.tx_id`. PowerSync's `getNextCrudTransaction()`
+ *  groups CRUD entries by `ps_crud.tx_id`; without it, a multi-row
+ *  `repo.tx` uploads as N separate server-side transactions. The text
+ *  `tx_id` (above) is what `row_events` records — distinct because
+ *  audit doesn't need integer grouping and the text form is friendlier
+ *  for log inspection. */
+export declare const CREATE_TX_CONTEXT_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS tx_context (\n    id      INTEGER PRIMARY KEY CHECK (id = 1),\n    tx_id   TEXT,\n    tx_seq  INTEGER,\n    user_id TEXT,\n    scope   TEXT,\n    source  TEXT\n  )\n";
+/** Idempotent seed of the single row. Re-runs are no-ops. */
+export declare const SEED_TX_CONTEXT_ROW_SQL = "\n  INSERT OR IGNORE INTO tx_context (id) VALUES (1)\n";
+/** Per-row audit + invalidation log. Trigger-written. tx_id = NULL for
+ *  sync-applied writes (see the COALESCE / CASE in the row_events
+ *  triggers below). */
+export declare const CREATE_ROW_EVENTS_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS row_events (\n    id          INTEGER PRIMARY KEY AUTOINCREMENT,\n    tx_id       TEXT,\n    block_id    TEXT NOT NULL,\n    kind        TEXT NOT NULL,\n    before_json TEXT,\n    after_json  TEXT,\n    source      TEXT NOT NULL,\n    created_at  INTEGER NOT NULL\n  )\n";
+export declare const CREATE_ROW_EVENTS_TX_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_row_events_tx\n  ON row_events (tx_id)\n";
+export declare const CREATE_ROW_EVENTS_BLOCK_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_row_events_block\n  ON row_events (block_id, created_at DESC)\n";
+export declare const CREATE_ROW_EVENTS_CREATED_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_row_events_created\n  ON row_events (created_at DESC)\n";
+/** Per-tx metadata. One row per `repo.tx` invocation. Sync-applied writes
+ *  don't go through `repo.tx` and therefore don't produce
+ *  `command_events`. */
+export declare const CREATE_COMMAND_EVENTS_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS command_events (\n    tx_id         TEXT PRIMARY KEY,\n    description   TEXT,\n    scope         TEXT NOT NULL,\n    user_id       TEXT NOT NULL,\n    workspace_id  TEXT,\n    mutator_calls TEXT NOT NULL,\n    source        TEXT NOT NULL,\n    created_at    INTEGER NOT NULL\n  )\n";
+export declare const CREATE_COMMAND_EVENTS_CREATED_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_command_events_created\n  ON command_events (created_at DESC)\n";
+export declare const CREATE_COMMAND_EVENTS_WORKSPACE_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_command_events_workspace\n  ON command_events (workspace_id, created_at DESC)\n";
+/** Trigger-maintained side index of `(workspace_id, alias) → block_id`,
+ *  derived from the `alias` entry in each live block's `properties_json`.
+ *
+ *  The previous shape walked `json_each(properties_json, '$.alias')` per
+ *  query, which scans the full workspace partition every time. With
+ *  150-MB-class workspaces this is the dominant cost in alias-heavy
+ *  paths (Roam import, parseReferences, autocomplete). The
+ *  index gives O(log n) `(workspace_id, alias_lower?)` lookup at the
+ *  cost of three triggers and one extra row per (block, alias) pair.
+ *
+ *  Local-only: the table is fully derivable from `blocks.properties_json`
+ *  so it is not synced — PowerSync's CRUD-apply path writes through
+ *  `BLOCKS_RAW_TABLE.put` (an `INSERT … ON CONFLICT DO UPDATE`) which
+ *  fires our INSERT/UPDATE triggers, populating this table on incoming
+ *  sync the same way local writes do.
+ *
+ *  Soft-delete: triggers keep block_aliases empty for blocks where
+ *  `deleted = 1`. Hard-delete (the DELETE row_event trigger on blocks
+ *  is reserved for future purges) also clears via the DELETE trigger
+ *  here. Restoring a tombstone (`UPDATE deleted = 1 → 0`) re-fires the
+ *  UPDATE trigger and re-populates from `properties_json`.
+ *
+ *  PRIMARY KEY (block_id, alias) makes the per-(block, alias) write
+ *  idempotent under `INSERT OR IGNORE` (e.g. duplicate aliases on the
+ *  same block, or backfill running over already-populated rows).
+ *  `alias` is stored verbatim (case preserved); `alias_lower` is the
+ *  pre-computed `LOWER(alias)` so case-insensitive autocomplete doesn't
+ *  re-evaluate `LOWER()` per row.
+ */
+export declare const CREATE_BLOCK_ALIASES_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS block_aliases (\n    block_id     TEXT NOT NULL,\n    workspace_id TEXT NOT NULL,\n    alias        TEXT NOT NULL,\n    alias_lower  TEXT NOT NULL,\n    PRIMARY KEY (block_id, alias)\n  )\n";
+/** Case-sensitive exact-match path: parseReferences `lookupAliasTarget`
+ *  and `findBlockByAliasInWorkspace`. */
+export declare const CREATE_BLOCK_ALIASES_WS_ALIAS_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_block_aliases_ws_alias\n  ON block_aliases (workspace_id, alias)\n";
+/** Tiny key/value table for one-shot schema-bootstrapping markers
+ *  (currently only the alias backfill). Local-only — the markers
+ *  describe the state of a derived index on this device, not anything
+ *  the server cares about.
+ *
+ *  Why a dedicated table instead of "is block_aliases empty?": a
+ *  legitimately empty workspace, or a workspace whose user removed
+ *  every alias, would otherwise re-trigger the full backfill scan on
+ *  every launch — which is exactly what the LIMIT 1 short-circuit was
+ *  meant to avoid. The marker captures "we ran the backfill once for
+ *  this schema version" directly. */
+export declare const CREATE_CLIENT_SCHEMA_STATE_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS client_schema_state (\n    key           TEXT PRIMARY KEY,\n    completed_at  INTEGER NOT NULL\n  )\n";
+/** Case-insensitive substring/prefix path for alias autocomplete. */
+export declare const CREATE_BLOCK_ALIASES_WS_ALIAS_LOWER_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_block_aliases_ws_alias_lower\n  ON block_aliases (workspace_id, alias_lower)\n";
+export declare const DROP_BLOCKS_WORKSPACE_TYPE_INDEX_SQL = "\n  DROP INDEX IF EXISTS idx_blocks_workspace_type\n";
+/** Trigger-maintained membership index over `properties_json.$.types`.
+ *  This replaces the old scalar `$.type` expression index: SQLite
+ *  cannot expression-index array membership directly, so by-type
+ *  queries join through this local side table. */
+export declare const CREATE_BLOCK_TYPES_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS block_types (\n    block_id     TEXT NOT NULL,\n    workspace_id TEXT NOT NULL,\n    type         TEXT NOT NULL,\n    PRIMARY KEY (block_id, type)\n  )\n";
+export declare const CREATE_BLOCK_TYPES_TYPE_WORKSPACE_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_block_types_type_workspace\n  ON block_types (type, workspace_id)\n";
+/** Quarantine for `ps_crud` rows whose upload the server refused with a
+ *  permanent error (FK violation, RLS denial, insufficient privilege,
+ *  4xx that can't recover on retry). The PowerSync upload handler moves
+ *  rejected txs here so the queue can keep draining instead of blocking
+ *  on a write that will never succeed; the row preserves enough context
+ *  for a later UI surface ("N changes couldn't sync") and post-hoc
+ *  inspection.
+ *
+ *  Local-only — the server has no view of what its own rejections
+ *  looked like from the client side, and these rows reference the
+ *  client's `ps_crud.id` which doesn't exist on the server anyway. */
+export declare const CREATE_PS_CRUD_REJECTED_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS ps_crud_rejected (\n    id            INTEGER PRIMARY KEY AUTOINCREMENT,\n    original_id   INTEGER NOT NULL,\n    tx_id         INTEGER NOT NULL,\n    data          TEXT NOT NULL,\n    error_code    TEXT,\n    error_message TEXT,\n    rejected_at   INTEGER NOT NULL\n  )\n";
+export declare const CREATE_PS_CRUD_REJECTED_REJECTED_AT_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_ps_crud_rejected_rejected_at\n  ON ps_crud_rejected (rejected_at DESC)\n";
+export declare const CREATE_PS_CRUD_REJECTED_TX_ID_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_ps_crud_rejected_tx_id\n  ON ps_crud_rejected (tx_id)\n";
+export declare const CREATE_BLOCKS_INSERT_ROW_EVENT_TRIGGER_SQL: string;
+export declare const CREATE_BLOCKS_UPDATE_ROW_EVENT_TRIGGER_SQL: string;
+/** DELETE row_event writer is reserved for hard purges. v1 ships no purge
+ *  mechanism; the trigger exists for future use (e.g. a job that purges
+ *  soft-deleted rows older than N days). Hard deletes do not sync —
+ *  PowerSync sees the row vanish locally; soft-delete via the synced
+ *  `deleted` column is what propagates "this row is gone" through sync. */
+export declare const CREATE_BLOCKS_DELETE_ROW_EVENT_TRIGGER_SQL: string;
+export declare const CREATE_BLOCKS_UPLOAD_INSERT_TRIGGER_SQL: string;
+export declare const CREATE_BLOCKS_UPLOAD_UPDATE_TRIGGER_SQL: string;
+export declare const CREATE_BLOCKS_WORKSPACE_INVARIANT_INSERT_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_parent_workspace_check_insert\n  BEFORE INSERT ON blocks\n  WHEN NEW.parent_id IS NOT NULL\n    AND (SELECT source FROM tx_context WHERE id = 1) IS NOT NULL\n  BEGIN\n    SELECT RAISE(ABORT, 'parent must exist and share workspace_id')\n    WHERE NOT EXISTS (\n      SELECT 1 FROM blocks\n      WHERE id = NEW.parent_id\n        AND workspace_id = NEW.workspace_id\n    );\n  END\n";
+export declare const CREATE_BLOCKS_WORKSPACE_INVARIANT_UPDATE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_parent_workspace_check_update\n  BEFORE UPDATE OF parent_id, workspace_id ON blocks\n  WHEN NEW.parent_id IS NOT NULL\n    AND (SELECT source FROM tx_context WHERE id = 1) IS NOT NULL\n  BEGIN\n    SELECT RAISE(ABORT, 'parent must exist and share workspace_id')\n    WHERE NOT EXISTS (\n      SELECT 1 FROM blocks\n      WHERE id = NEW.parent_id\n        AND workspace_id = NEW.workspace_id\n    );\n  END\n";
+export declare const CREATE_BLOCKS_PARENT_NOT_DELETED_INSERT_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_parent_not_deleted_check_insert\n  BEFORE INSERT ON blocks\n  WHEN NEW.parent_id IS NOT NULL\n    AND NEW.deleted = 0\n    AND (SELECT source FROM tx_context WHERE id = 1) IS NOT NULL\n  BEGIN\n    SELECT RAISE(ABORT,\n      'parent_deleted' || char(31) || NEW.parent_id\n    )\n    WHERE EXISTS (\n      SELECT 1 FROM blocks\n      WHERE id = NEW.parent_id\n        AND deleted = 1\n    );\n  END\n";
+export declare const CREATE_BLOCKS_PARENT_NOT_DELETED_UPDATE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_parent_not_deleted_check_update\n  BEFORE UPDATE OF parent_id, deleted ON blocks\n  WHEN NEW.parent_id IS NOT NULL\n    AND NEW.deleted = 0\n    AND (SELECT source FROM tx_context WHERE id = 1) IS NOT NULL\n  BEGIN\n    SELECT RAISE(ABORT,\n      'parent_deleted' || char(31) || NEW.parent_id\n    )\n    WHERE EXISTS (\n      SELECT 1 FROM blocks\n      WHERE id = NEW.parent_id\n        AND deleted = 1\n    );\n  END\n";
+export declare const CREATE_BLOCKS_ALIAS_INSERT_TRIGGER_SQL: string;
+/** Fires only when `properties_json`, `deleted`, or `workspace_id`
+ *  changes — content edits, parent moves, and order_key changes don't
+ *  touch the alias index. Always wipes the row's prior aliases first
+ *  (cheap: PK lookup), then re-inserts unless the row is now soft-
+ *  deleted. Restoring a tombstone re-populates via the same path. */
+export declare const CREATE_BLOCKS_ALIAS_UPDATE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_alias_update\n  AFTER UPDATE OF properties_json, deleted, workspace_id ON blocks\n  BEGIN\n    DELETE FROM block_aliases WHERE block_id = NEW.id;\n    INSERT OR IGNORE INTO block_aliases (block_id, workspace_id, alias, alias_lower)\n    SELECT NEW.id, NEW.workspace_id, je.value, LOWER(je.value)\n    FROM json_each(NEW.properties_json, '$.alias') AS je\n    WHERE NEW.deleted = 0 AND typeof(je.value) = 'text';\n  END\n";
+/** Hard-delete cleanup. Soft-deletes go through the UPDATE trigger
+ *  above (which sees `NEW.deleted = 1` and writes nothing back). */
+export declare const CREATE_BLOCKS_ALIAS_DELETE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_alias_delete\n  AFTER DELETE ON blocks\n  BEGIN\n    DELETE FROM block_aliases WHERE block_id = OLD.id;\n  END\n";
+/** Workspace-scoped alias uniqueness — enforced at the storage layer
+ *  so the invariant holds regardless of which write path arrives at
+ *  the table (local `tx.create` + `setProperty`, `tx.restore`,
+ *  applyRaw from undo, future mutators). Fires BEFORE every INSERT
+ *  into `block_aliases`; if any other live block already claims the
+ *  same `(workspace_id, alias)`, RAISE(ABORT) rolls back the entire
+ *  user tx atomically.
+ *
+ *  Blank aliases (`NEW.alias = ''`) are skipped to match the
+ *  `tx.aliasLookup` semantics: lookup returns null for `''` because
+ *  blanks aren't meaningful claims. Without the skip, two blocks
+ *  each carrying an empty entry in their alias array (e.g. notes
+ *  the user cleared) would spuriously collide on the second write.
+ *
+ *  The RAISE message is structured: `alias_collision` followed by
+ *  US-separated (char(31)) HEX-encoded workspace_id, alias, and
+ *  attempting block_id. Hex encoding guarantees the delimiter never
+ *  appears inside a field, even if the alias text itself contains
+ *  control chars — earlier comments asserted the codec rejected
+ *  control chars, but `codecs.string` only checks typeof, so the
+ *  encoding has to defend itself rather than relying on data-shape
+ *  invariants. The tx engine hex-decodes each field and looks up
+ *  the existing claimant to construct
+ *  `ProcessorRejection('alias.collision', meta)`.
+ *
+ *  Skipped when `tx_context.source IS NULL` so PowerSync sync-apply
+ *  doesn't fail on dupes propagating from other clients (mirrors the
+ *  workspace-invariant trigger's policy). V1 leaves cross-client
+ *  alias merges as latent; the user-facing merge flow is V2.
+ *  Backfill (`BACKFILL_BLOCK_ALIASES_SQL`) also runs outside a
+ *  `tx_context.source` setting, so the one-time index re-population
+ *  on schema upgrade is tolerant of any latent dupes that predate
+ *  this trigger.
+ *
+ *  Self-reclaim is handled naturally: `blocks_alias_update` DELETEs
+ *  the row's prior aliases before re-inserting, so a row rewriting
+ *  its own alias sees no other claimant at INSERT time. */
+export declare const CREATE_BLOCK_ALIASES_WORKSPACE_UNIQUE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS block_aliases_workspace_alias_unique\n  BEFORE INSERT ON block_aliases\n  WHEN (SELECT source FROM tx_context WHERE id = 1) IS NOT NULL\n    AND NEW.alias != ''\n  BEGIN\n    SELECT RAISE(ABORT,\n      'alias_collision' || char(31) ||\n      hex(NEW.workspace_id) || char(31) ||\n      hex(NEW.alias) || char(31) ||\n      hex(NEW.block_id)\n    )\n    WHERE EXISTS (\n      SELECT 1 FROM block_aliases\n      WHERE workspace_id = NEW.workspace_id\n        AND alias = NEW.alias\n        AND block_id != NEW.block_id\n    );\n  END\n";
+export declare const CREATE_BLOCKS_TYPE_INSERT_TRIGGER_SQL: string;
+export declare const CREATE_BLOCKS_TYPE_UPDATE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_type_update\n  AFTER UPDATE OF properties_json, deleted, workspace_id ON blocks\n  BEGIN\n    DELETE FROM block_types WHERE block_id = NEW.id;\n    INSERT OR IGNORE INTO block_types (block_id, workspace_id, type)\n    SELECT NEW.id, NEW.workspace_id, je.value\n    FROM json_each(NEW.properties_json, '$.types') AS je\n    WHERE NEW.deleted = 0 AND typeof(je.value) = 'text';\n  END\n";
+export declare const CREATE_BLOCKS_TYPE_DELETE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_type_delete\n  AFTER DELETE ON blocks\n  BEGIN\n    DELETE FROM block_types WHERE block_id = OLD.id;\n  END\n";
+/** One-shot backfill from `blocks.properties_json`. Called after the
+ *  CLIENT_SCHEMA_STATEMENTS run, gated on a `client_schema_state` row
+ *  so existing installations populate the index once on the first
+ *  startup with this schema, and steady-state startups are a single
+ *  cheap PK lookup. New installations also no-op (no blocks ⇒
+ *  nothing to backfill, marker still recorded so subsequent starts
+ *  short-circuit).
+ *
+ *  Marker key vs derived state: an earlier shape probed `block_aliases`
+ *  for any row, treating non-empty as proof the backfill ran. That
+ *  conflated "backfill complete" with "this workspace has any aliases
+ *  at all", so a workspace with zero alias-bearing blocks (or one that
+ *  later had every alias removed) re-ran the full table scan on every
+ *  launch. The dedicated marker captures the intent directly.
+ *
+ *  Why not part of CLIENT_SCHEMA_STATEMENTS: the SELECT scans the
+ *  blocks table, which is multi-million rows on big workspaces.
+ *  Running unconditionally on every app start would defeat the index
+ *  the user just paid for. */
+export declare const ALIAS_BACKFILL_MARKER_KEY = "block_aliases_backfill_v1";
+export declare const SELECT_BLOCK_ALIASES_BACKFILL_DONE_SQL = "\n  SELECT 1 FROM client_schema_state WHERE key = 'block_aliases_backfill_v1'\n";
+export declare const RECORD_BLOCK_ALIASES_BACKFILL_DONE_SQL = "\n  INSERT OR REPLACE INTO client_schema_state (key, completed_at)\n  VALUES ('block_aliases_backfill_v1', strftime('%s', 'now') * 1000)\n";
+export declare const BACKFILL_BLOCK_ALIASES_SQL = "\n  INSERT OR IGNORE INTO block_aliases (block_id, workspace_id, alias, alias_lower)\n  SELECT b.id, b.workspace_id, je.value, LOWER(je.value)\n  FROM blocks b, json_each(b.properties_json, '$.alias') AS je\n  WHERE b.deleted = 0 AND typeof(je.value) = 'text'\n";
+export declare const BLOCK_TYPES_BACKFILL_MARKER_KEY = "block_types_backfill_v1";
+export declare const SELECT_BLOCK_TYPES_BACKFILL_DONE_SQL = "\n  SELECT 1 FROM client_schema_state WHERE key = 'block_types_backfill_v1'\n";
+export declare const RECORD_BLOCK_TYPES_BACKFILL_DONE_SQL = "\n  INSERT OR REPLACE INTO client_schema_state (key, completed_at)\n  VALUES ('block_types_backfill_v1', strftime('%s', 'now') * 1000)\n";
+export declare const BACKFILL_BLOCK_TYPES_SQL = "\n  INSERT OR IGNORE INTO block_types (block_id, workspace_id, type)\n  SELECT b.id, b.workspace_id, je.value\n  FROM blocks b, json_each(b.properties_json, '$.types') AS je\n  WHERE b.deleted = 0 AND typeof(je.value) = 'text'\n";
+/** One-shot enqueue of pre-existing UI-state subtrees that the old
+ *  routing left out of the upload queue. Phase 2 dropped the
+ *  `source: 'local-ephemeral'` sink, so every NEW UI-state write goes
+ *  through ps_crud — but rows already in the local DB at upgrade time
+ *  are still server-side missing. Without this backfill, the first
+ *  user-touch on an existing UI-state row (e.g. selection state on a
+ *  panel) would PATCH→upsert and FK-fail on the chain of never-uploaded
+ *  ancestors (`ui-state` → `layout-sessions` → `<session>` → panel).
+ *
+ *  Identification: a row whose latest `row_events.source` is
+ *  `'local-ephemeral'` has never reached the upload queue (later 'user'
+ *  rows would be in ps_crud already; later 'sync' rows mean the server
+ *  already has the row).
+ *
+ *  Atomicity: every enqueued row gets the SAME `tx_id` so PowerSync
+ *  ships them as one server-side transaction. The composite FK on
+ *  `(workspace_id, parent_id)` is DEFERRABLE INITIALLY DEFERRED, so
+ *  the in-tx-but-not-yet-committed parents satisfy each child at
+ *  COMMIT time regardless of insertion order. If the batch somehow
+ *  fails, the orchestrator's per-tx fallback quarantines them all
+ *  together — visible via the rejection-quarantine UI for manual retry. */
+export declare const LOCAL_EPHEMERAL_BACKFILL_MARKER_KEY = "local_ephemeral_upload_backfill_v1";
+export declare const SELECT_LOCAL_EPHEMERAL_BACKFILL_DONE_SQL = "\n  SELECT 1 FROM client_schema_state WHERE key = 'local_ephemeral_upload_backfill_v1'\n";
+export declare const RECORD_LOCAL_EPHEMERAL_BACKFILL_DONE_SQL = "\n  INSERT OR REPLACE INTO client_schema_state (key, completed_at)\n  VALUES ('local_ephemeral_upload_backfill_v1', strftime('%s', 'now') * 1000)\n";
+/** Counts what BACKFILL_LOCAL_EPHEMERAL_UPLOADS_SQL would enqueue. Used
+ *  by the bootstrap wrapper to decide whether to log and to expose a
+ *  number for debugging. */
+export declare const COUNT_LOCAL_EPHEMERAL_BACKFILL_PENDING_SQL = "\n  SELECT COUNT(*) AS n FROM blocks b\n  WHERE b.id IN (\n    SELECT r1.block_id FROM row_events r1\n    WHERE r1.source = 'local-ephemeral'\n      AND NOT EXISTS (\n        SELECT 1 FROM row_events r2\n        WHERE r2.block_id = r1.block_id AND r2.id > r1.id\n      )\n  )\n";
+/** Emits one PUT envelope per qualifying block, all stamped with the
+ *  same `?` tx_id parameter. */
+export declare const BACKFILL_LOCAL_EPHEMERAL_UPLOADS_SQL: string;
+/** Per-name reprojection markers. Once `reprojectRefTypedProperties`
+ *  has done a catch-up pass for property name `X`, a row keyed
+ *  `reproject_ref:<X>` lands in `client_schema_state`. Subsequent
+ *  cold-starts (kernel→merged delta, plugins→user-data delta) skip
+ *  scanning blocks for `X` because the references processor has been
+ *  maintaining `references_json` incrementally on every write since.
+ *
+ *  Marker is cleared (DELETE) when reprojection runs for a name whose
+ *  current schema is no longer ref-typed (cleanup case): a future
+ *  re-add-as-ref needs the catch-up scan again because writes during
+ *  the non-ref window left properties_json values without
+ *  references_json entries. */
+export declare const REPROJECT_REF_MARKER_PREFIX = "reproject_ref:";
+export declare const SELECT_REPROJECT_REF_MARKERS_SQL = "\n  SELECT key FROM client_schema_state WHERE key LIKE 'reproject_ref:%'\n";
+export declare const RECORD_REPROJECT_REF_MARKER_SQL = "\n  INSERT OR REPLACE INTO client_schema_state (key, completed_at)\n  VALUES (?, strftime('%s', 'now') * 1000)\n";
+export declare const CLEAR_REPROJECT_REF_MARKER_SQL = "\n  DELETE FROM client_schema_state WHERE key = ?\n";
+export declare const CLIENT_SCHEMA_STATEMENTS: readonly string[];
+export declare const CLIENT_SCHEMA_TRIGGER_NAMES: readonly ["blocks_row_event_insert", "blocks_row_event_update", "blocks_row_event_delete", "blocks_upload_insert", "blocks_upload_update", "blocks_parent_workspace_check_insert", "blocks_parent_workspace_check_update", "blocks_parent_not_deleted_check_insert", "blocks_parent_not_deleted_check_update", "blocks_alias_insert", "blocks_alias_update", "blocks_alias_delete", "block_aliases_workspace_alias_unique", "blocks_type_insert", "blocks_type_update", "blocks_type_delete"];
+interface ClientSchemaBootstrapDb {
+    execute: (sql: string, params?: unknown[]) => Promise<unknown>;
+    getOptional: <T>(sql: string) => Promise<T | null>;
+}
+/** Run after CLIENT_SCHEMA_STATEMENTS to populate block_aliases from
+ *  pre-existing blocks rows on the first app start that includes the
+ *  alias-index schema. Subsequent starts are a single cheap LIMIT 1
+ *  read because triggers maintain the table from then on.
+ *
+ *  Tests open a fresh database with no blocks → noop. Production
+ *  picks up the existing PowerSync-synced blocks → one large INSERT
+ *  on the first start, then noop on every start after. */
+export declare const backfillBlockAliasesIfEmpty: (db: ClientSchemaBootstrapDb) => Promise<void>;
+export declare const backfillBlockTypesIfEmpty: (db: ClientSchemaBootstrapDb) => Promise<void>;
+/** Enqueue pre-existing UI-state rows for upload on the first app
+ *  start after Phase 2 (see `LOCAL_EPHEMERAL_BACKFILL_MARKER_KEY` for
+ *  the full rationale). `newTxSeq` produces the integer tx_id every
+ *  enqueued row shares, so the server applies them atomically and the
+ *  DEFERRABLE composite FK doesn't trip on intra-batch parent chains. */
+export declare const backfillLocalEphemeralUploadsIfPending: (db: ClientSchemaBootstrapDb, newTxSeq: () => number) => Promise<void>;
+export {};
+//# sourceMappingURL=clientSchema.d.ts.map

package/dist/kernel-types/src/data/internals/clientSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientSchema.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/clientSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH;;;;;;;;;;;;0BAY0B;AAC1B,eAAO,MAAM,2BAA2B,yMASvC,CAAA;AAED,6DAA6D;AAC7D,eAAO,MAAM,uBAAuB,2DAEnC,CAAA;AAED;;uBAEuB;AACvB,eAAO,MAAM,2BAA2B,kTAWvC,CAAA;AAED,eAAO,MAAM,8BAA8B,gFAG1C,CAAA;AAED,eAAO,MAAM,iCAAiC,uGAG7C,CAAA;AAED,eAAO,MAAM,mCAAmC,+FAG/C,CAAA;AAED;;wBAEwB;AACxB,eAAO,MAAM,+BAA+B,8TAW3C,CAAA;AAED,eAAO,MAAM,uCAAuC,uGAGnD,CAAA;AAED,eAAO,MAAM,yCAAyC,uHAGrD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,8BAA8B,iOAQ1C,CAAA;AAED;yCACyC;AACzC,eAAO,MAAM,uCAAuC,0GAGnD,CAAA;AAED;;;;;;;;;;qCAUqC;AACrC,eAAO,MAAM,oCAAoC,yIAKhD,CAAA;AAED,qEAAqE;AACrE,eAAO,MAAM,6CAA6C,sHAGzD,CAAA;AAED,eAAO,MAAM,oCAAoC,yDAEhD,CAAA;AAED;;;kDAGkD;AAClD,eAAO,MAAM,4BAA4B,6LAOxC,CAAA;AAED,eAAO,MAAM,2CAA2C,2GAGvD,CAAA;AAED;;;;;;;;;;sEAUsE;AACtE,eAAO,MAAM,iCAAiC,qTAU7C,CAAA;AAED,eAAO,MAAM,6CAA6C,gHAGzD,CAAA;AAED,eAAO,MAAM,uCAAuC,+FAGnD,CAAA;AAoDD,eAAO,MAAM,0CAA0C,QAgBtD,CAAA;AAED,eAAO,MAAM,0CAA0C,QAmBtD,CAAA;AAED;;;;2EAI2E;AAC3E,eAAO,MAAM,0CAA0C,QAgBtD,CAAA;AA8ED,eAAO,MAAM,uCAAuC,QAenD,CAAA;AAED,eAAO,MAAM,uCAAuC,QAkBnD,CAAA;AAmBD,eAAO,MAAM,oDAAoD,yaAahE,CAAA;AAED,eAAO,MAAM,oDAAoD,ocAahE,CAAA;AAwCD,eAAO,MAAM,mDAAmD,4bAgB/D,CAAA;AAED,eAAO,MAAM,mDAAmD,kdAgB/D,CAAA;AAgCD,eAAO,MAAM,sCAAsC,QAOlD,CAAA;AAED;;;;qEAIqE;AACrE,eAAO,MAAM,sCAAsC,idAUlD,CAAA;AAED;oEACoE;AACpE,eAAO,MAAM,sCAAsC,6JAMlD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DAoC2D;AAC3D,eAAO,MAAM,iDAAiD,2jBAmB7D,CAAA;AAcD,eAAO,MAAM,qCAAqC,QAOjD,CAAA;AAED,eAAO,MAAM,qCAAqC,6aAUjD,CAAA;AAED,eAAO,MAAM,qCAAqC,0JAMjD,CAAA;AAED;;;;;;;;;;;;;;;;;;8BAkB8B;AAC9B,eAAO,MAAM,yBAAyB,8BAA8B,CAAA;AAEpE,eAAO,MAAM,sCAAsC,oFAElD,CAAA;AAED,eAAO,MAAM,sCAAsC,+IAGlD,CAAA;AAED,eAAO,MAAM,0BAA0B,0QAKtC,CAAA;AAED,eAAO,MAAM,+BAA+B,4BAA4B,CAAA;AAExE,eAAO,MAAM,oCAAoC,kFAEhD,CAAA;AAED,eAAO,MAAM,oCAAoC,6IAGhD,CAAA;AAED,eAAO,MAAM,wBAAwB,yOAKpC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;2EAoB2E;AAC3E,eAAO,MAAM,mCAAmC,uCAAuC,CAAA;AAEvF,eAAO,MAAM,wCAAwC,6FAEpD,CAAA;AAED,eAAO,MAAM,wCAAwC,wJAGpD,CAAA;AAED;;4BAE4B;AAC5B,eAAO,MAAM,0CAA0C,0RAUtD,CAAA;AAED;gCACgC;AAChC,eAAO,MAAM,oCAAoC,QAmBhD,CAAA;AAED;;;;;;;;;;;+BAW+B;AAC/B,eAAO,MAAM,2BAA2B,mBAAmB,CAAA;AAE3D,eAAO,MAAM,gCAAgC,+EAE5C,CAAA;AAED,eAAO,MAAM,+BAA+B,qHAG3C,CAAA;AAED,eAAO,MAAM,8BAA8B,wDAE1C,CAAA;AAOD,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EA0C5C,CAAA;AAEV,eAAO,MAAM,2BAA2B,+dAiB9B,CAAA;AAEV,UAAU,uBAAuB;IAC/B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9D,WAAW,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;CACnD;AAED;;;;;;;0DAO0D;AAC1D,eAAO,MAAM,2BAA2B,GACtC,IAAI,uBAAuB,KAC1B,OAAO,CAAC,IAAI,CAQd,CAAA;AAED,eAAO,MAAM,yBAAyB,GACpC,IAAI,uBAAuB,KAC1B,OAAO,CAAC,IAAI,CAKd,CAAA;AAED;;;;yEAIyE;AACzE,eAAO,MAAM,sCAAsC,GACjD,IAAI,uBAAuB,EAC3B,UAAU,MAAM,MAAM,KACrB,OAAO,CAAC,IAAI,CAMd,CAAA"}

package/dist/kernel-types/src/data/internals/commitPipeline.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Commit pipeline (§10): drives a `repo.tx` invocation end-to-end.
+ *
+ *   1. Validate scope vs. read-only mode.
+ *   2. Open `db.writeTransaction(fn)`.
+ *      a. Set `tx_context` (tx_id, user_id, scope, source).
+ *      b. Construct TxImpl + snapshots map.
+ *      c. Run user fn (primitives write through to SQL inline).
+ *      d. INSERT command_events row.
+ *      e. Clear `tx_context` (all four → NULL).
+ *   3. On COMMIT (post-fn-resolve, before promise resolves):
+ *      a. Walk snapshots map: update cache to `after` per id (or evict
+ *         on hard-delete).
+ *      b. (Future) record undo entry.
+ *      c. Resolve repo.tx promise with user fn's return.
+ *   4. Post-resolve: dispatch afterCommit jobs (their own
+ *      writeTransactions). (Stage 1.3: jobs collected only; the
+ *      processor framework that actually fires them lands in 1.5.)
+ *
+ * Failure modes:
+ *   - User fn throws → SQLite rolls back the writeTransaction. Snapshots
+ *     map is discarded. **Cache was never mutated**, so there's nothing
+ *     to revert; outside-tx readers saw the pre-tx state throughout.
+ *     afterCommit jobs are discarded — they only fire on commit (§5.3).
+ *   - DB error inside the writeTransaction → same rollback path.
+ */
+import type { AnyMutator, AnyPostCommitProcessor, AnyPropertySchema, AnySameTxProcessor, RepoTxOptions, Tx, User } from '@/data/api';
+import { type AfterCommitJob, type TxDb } from './txEngine';
+import { type SnapshotsMap } from './txSnapshots';
+import type { BlockCache } from '@/data/blockCache';
+/** Minimal subset of the full PowerSync DB our pipeline + Repo talks
+ *  to. The test harness (`createTestDb`) returns a real
+ *  `PowerSyncDatabase` that satisfies this; production passes the
+ *  same. Both `writeTransaction` (for tx primitives) and the read
+ *  surface (`getAll` / `getOptional` / `get` for `repo.load`) are
+ *  needed. `onChange` is the table-change subscription used by
+ *  reactive query hooks until the row_events tail in Phase 2 ships a
+ *  typed invalidation surface. */
+export interface PowerSyncDbChangeHandler {
+    onChange: () => void | Promise<void>;
+    onError?: (error: unknown) => void;
+}
+export interface PowerSyncDbChangeOptions {
+    tables?: readonly string[];
+    throttleMs?: number;
+}
+export interface PowerSyncDb {
+    writeTransaction<R>(fn: (tx: TxDb) => Promise<R>): Promise<R>;
+    getAll<T>(sql: string, params?: unknown[]): Promise<T[]>;
+    getOptional<T>(sql: string, params?: unknown[]): Promise<T | null>;
+    get<T>(sql: string, params?: unknown[]): Promise<T>;
+    /** Execute an arbitrary SQL statement (no result rows). Used by the
+     *  agent runtime bridge for `mode='execute'` SQL. Avoid in
+     *  application code — every write should go through `repo.tx`. */
+    execute(sql: string, params?: unknown[]): Promise<unknown>;
+    onChange(handler: PowerSyncDbChangeHandler, options?: PowerSyncDbChangeOptions): () => void;
+    /** Release the underlying connection (OPFS sync access handle on
+     *  web, file handle in node). Used by `exportSqliteDb` when
+     *  swapping the live .db file out from under the worker. */
+    close(): Promise<void>;
+}
+export interface RunTxParams<R> {
+    db: PowerSyncDb;
+    cache: BlockCache;
+    fn: (tx: Tx) => Promise<R>;
+    opts: RepoTxOptions;
+    user: User;
+    isReadOnly: boolean;
+    newTxId: () => string;
+    /** Monotonically increasing INTEGER per `repo.tx`. Written into
+     *  `tx_context.tx_seq` so the upload-routing triggers can stamp
+     *  `ps_crud.tx_id` and PowerSync's `getNextCrudTransaction()` groups
+     *  multi-row writes correctly. Required to be strictly increasing
+     *  across calls within a single `Repo`; the default Repo provider
+     *  uses a counter seeded from `Date.now()`. */
+    newTxSeq: () => number;
+    newId: () => string;
+    now: () => number;
+    mutators: ReadonlyMap<string, AnyMutator>;
+    /** Processor registry snapshot, captured at tx start. Used by
+     *  `tx.afterCommit` to validate scheduledArgs at enqueue time. */
+    processors: ReadonlyMap<string, AnyPostCommitProcessor>;
+    /** Same-tx processor registry snapshot, captured at tx start. The
+     *  runner walks this in registration order between `fn` returning
+     *  and the `command_events` insert, inside the writeTransaction.
+     *  Throws (e.g. `ProcessorRejection`) propagate out and roll back
+     *  the user's tx atomically. */
+    sameTxProcessors: ReadonlyMap<string, AnySameTxProcessor>;
+    /** Merged property-schema registry snapshot, captured at the same
+     *  boundary as `processors` so processor code sees a consistent
+     *  runtime bundle. */
+    propertySchemas: ReadonlyMap<string, AnyPropertySchema>;
+}
+export interface TxResult<R> {
+    /** User fn's return value (resolved synchronously after commit walk). */
+    value: R;
+    /** afterCommit jobs scheduled by the tx — to be dispatched by the
+     *  caller (Repo) after the tx promise resolves. Empty if rollback. */
+    afterCommitJobs: AfterCommitJob[];
+    /** Snapshots map for the committed tx — used by the post-commit
+     *  processor framework to compute field-watch matches. Empty map if
+     *  the user fn made no writes. */
+    snapshots: SnapshotsMap;
+    /** Pinned workspace at commit time. `null` for zero-write txs;
+     *  CommittedEvent contracts on this being a string when present, so
+     *  the runner skips field-watch + explicit dispatch entirely when
+     *  null (no work to do anyway — no field changed, and afterCommit
+     *  threw WorkspaceNotPinnedError if called pre-write). */
+    workspaceId: string | null;
+    /** Tx id (for processor CommittedEvent.txId). */
+    txId: string;
+    /** User who ran the tx (for processor CommittedEvent.user). */
+    user: User;
+    /** Processor registry snapshot taken at tx start. The runner walks
+     *  this (not its current registry) so a `setFacetRuntime` call that
+     *  lands while a tx is in flight can't remove or replace processors
+     *  before that tx's field-watch / explicit jobs fire — the spec says
+     *  registries are snapshotted at tx start (§3, §8). */
+    processors: ReadonlyMap<string, AnyPostCommitProcessor>;
+    /** Merged property-schema registry snapshot paired with `processors`. */
+    propertySchemas: ReadonlyMap<string, AnyPropertySchema>;
+}
+export declare const runTx: <R>(params: RunTxParams<R>) => Promise<TxResult<R>>;
+export declare const __debug: {
+    scopeUploadsToServer: (scope: import("@/data/api").ChangeScope) => boolean;
+};
+//# sourceMappingURL=commitPipeline.d.ts.map

package/dist/kernel-types/src/data/internals/commitPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commitPipeline.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/commitPipeline.ts"],"names":[],"mappings":"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"}

package/dist/kernel-types/src/data/internals/coreProperties.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Kernel property schemas (data layer). Exposed as plain
+ * `PropertySchema<T>` exports today; `propertySchemasFacet`
+ * registration arrives with full-runtime wiring in Phase 1 stage 2 / 3.
+ *
+ * `aliasesProp` is the alias list parseReferences writes when a tx
+ * inserts a target block (e.g. `[[Inbox]]` produces a target with
+ * aliases: ['Inbox']). The same schema is consulted by alias-lookup
+ * queries that resolve `[[alias]]` to a target id.
+ */
+import { type PropertySchema } from '@/data/api';
+/** Alias list stored on alias-target / daily-note blocks (§7). The
+ *  encoded shape in `properties_json` is `string[]`; the codec is the
+ *  list-of-strings combinator. */
+export declare const aliasesProp: PropertySchema<string[]>;
+//# sourceMappingURL=coreProperties.d.ts.map

package/dist/kernel-types/src/data/internals/coreProperties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreProperties.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/coreProperties.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAuC,KAAK,cAAc,EAAE,MAAM,YAAY,CAAA;AAErF;;kCAEkC;AAClC,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,MAAM,EAAE,CAI/C,CAAA"}