@knowledge-medium/agent-cli 0.1.0

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

@@ -0,0 +1,87 @@
+/**
+ * Recursive CTEs for tree operations against the v2 blocks schema (§11
+ * of the data-layer redesign). Two guards on every recursion:
+ *
+ *   1. `depth < 100` — defensive cap. Catches pathological non-cycle
+ *      deep trees and is the safety net if the visited-id guard fails.
+ *
+ *   2. `INSTR(path, '!' || hex(id) || '/') = 0` — visited-id check via
+ *      path-INSTR. Skips any row whose id already appears in the
+ *      recursion path-so-far. **Without this guard, UNION ALL would
+ *      re-emit cycle members on every loop iteration**, exploding the
+ *      result. With it, each block appears at most once.
+ *
+ * Path encoding: `!hex(id)/` segments separated by `<order_key>`.
+ *   - `hex()` makes the path lexically safe regardless of id format
+ *     (block ids may contain `/`; e.g. deterministic `daily/<ws>/<date>`).
+ *   - `!` (0x21) is the in-segment separator: lexicographically less
+ *     than every char in any order_key alphabet (digits, lowercase
+ *     letters, `_`) AND every uppercase hex char (`0-9A-F`). This is
+ *     what makes `ORDER BY path` produce correct sibling ordering when
+ *     one order_key is a prefix of another (e.g. keys `a` and `aa` —
+ *     comparing position-by-position, `a == a`, then `!` < `a` →
+ *     `a!hex1/` sorts before `aa!hex2/`).
+ *   - Trailing `/` per segment makes the visited-id INSTR match
+ *     unambiguous (`!hex/` is found only as a complete segment, never
+ *     as a prefix of a longer hex).
+ *
+ * Path is internal to the CTE; consumers ignore it.
+ */
+/** Returns the rooted subtree, ordered by path (i.e. depth-first, with
+ *  siblings sorted by `(order_key, id)` via the path encoding). Filters
+ *  `deleted = 0`. */
+export declare const SUBTREE_SQL = "\n  WITH RECURSIVE subtree AS (\n    SELECT *,\n           '!' || hex(id) || '/' AS path,\n           0 AS depth\n      FROM blocks\n     WHERE id = ? AND deleted = 0\n    UNION ALL\n    SELECT child.*,\n           subtree.path || child.order_key || '!' || hex(child.id) || '/',\n           subtree.depth + 1\n      FROM subtree\n      JOIN blocks AS child ON child.parent_id = subtree.id\n     WHERE child.deleted = 0\n       AND subtree.depth < 100\n       AND INSTR(subtree.path, '!' || hex(child.id) || '/') = 0\n  )\n  SELECT * FROM subtree ORDER BY path\n";
+/** Returns the leaf-to-root chain, excluding the start id. Filters
+ *  `deleted = 0`. */
+export declare const ANCESTORS_SQL = "\n  WITH RECURSIVE chain AS (\n    SELECT *,\n           '!' || hex(id) || '/' AS path,\n           0 AS depth\n      FROM blocks\n     WHERE id = ? AND deleted = 0\n    UNION ALL\n    SELECT parent.*,\n           chain.path || '!' || hex(parent.id) || '/',\n           chain.depth + 1\n      FROM chain\n      JOIN blocks AS parent ON parent.id = chain.parent_id\n     WHERE parent.deleted = 0\n       AND chain.depth < 100\n       AND INSTR(chain.path, '!' || hex(parent.id) || '/') = 0\n  )\n  SELECT * FROM chain WHERE id != ? ORDER BY depth ASC\n";
+/** Many-id variant of `ANCESTORS_SQL` — runs the recursive walk for
+ *  every seed id in one statement, tagging each row with the seed it
+ *  belongs to. Used by `core.manyAncestors` to avoid N round-trips
+ *  when a backlinks panel needs the parent chain for every visible
+ *  source block.
+ *
+ *  Caller supplies `idCount` `?` placeholders bound to the seed ids;
+ *  ordering of the input array is not preserved in the result, so
+ *  consumers must group by `chain_start_id` themselves. Each chain is
+ *  returned leaf-to-root (ascending `depth`) so it matches the
+ *  single-id `ANCESTORS_SQL` shape exactly. */
+export declare const manyAncestorsSql: (idCount: number) => string;
+/** Existence check: is :potentialAncestor an ancestor of :id?
+ *  Used by `tx.move`'s cycle-validation: would the new parent be a
+ *  descendant of `id`? Parameter order in the SQL: `?, ?` for
+ *  `(id, potentialAncestor)`. */
+export declare const IS_DESCENDANT_OF_SQL = "\n  WITH RECURSIVE chain AS (\n    SELECT id, parent_id,\n           '!' || hex(id) || '/' AS path,\n           0 AS depth\n      FROM blocks\n     WHERE id = ? AND deleted = 0\n    UNION ALL\n    SELECT b.id, b.parent_id,\n           chain.path || '!' || hex(b.id) || '/',\n           chain.depth + 1\n      FROM blocks AS b\n      JOIN chain ON chain.parent_id = b.id\n     WHERE b.deleted = 0\n       AND chain.depth < 100\n       AND INSTR(chain.path, '!' || hex(b.id) || '/') = 0\n  )\n  SELECT 1 AS hit FROM chain WHERE id = ? LIMIT 1\n";
+/** Bounded scan over a set of affected ids — for each id, walks up
+ *  parent_id and, if its chain closes onto itself, reports every id
+ *  visited along that closing chain (i.e. every member of the cycle
+ *  the input id is part of). Used by the row_events tail to surface
+ *  sync-introduced cycles (§4.7 detection-only telemetry).
+ *
+ *  Parameter shape: pass `idCount` `?` placeholders bound to the ids
+ *  to scan. Caller is responsible for matching the count.
+ *
+ *  Why report every cycle member, not just the input id that closed:
+ *  drains can split per-row when sync-applied writes arrive in
+ *  separate `db.onChange` ticks. For a 2-cycle A↔B introduced by two
+ *  sync writes (A.parent←B, then B.parent←A), the drain that sees
+ *  the first write scans `idList=[A]` against pre-second-write state
+ *  and finds nothing; only the second drain (idList=[B], post-both-
+ *  writes) sees the cycle. Reporting just `start_id` would emit
+ *  `[B]` and lose A. Reporting the full cycle (`[A, B]`) gives
+ *  consumers a complete view from any single drain that catches the
+ *  closure, regardless of which member's mutation triggered the
+ *  drain. The column alias stays `start_id` so the surface caller
+ *  reads (`hits.map(h => h.start_id)`) is unchanged.
+ *
+ *  Why scoped to affected ids (not all blocks): cycle scans are O(n)
+ *  per starting row and we don't need to find every cycle in the DB
+ *  — only the ones the just-applied sync writes might have closed. */
+export declare const cycleScanSql: (idCount: number) => string;
+/** Direct children of a parent, ordered `(order_key, id)`, filtered
+ *  `deleted = 0`. */
+export declare const CHILDREN_SQL = "\n  SELECT * FROM blocks\n   WHERE parent_id = ? AND deleted = 0\n   ORDER BY order_key, id\n";
+/** Same as CHILDREN_SQL but returns only `id` — for the child-id-only
+ *  handle (`repo.childIds`) which doesn't need to hydrate the full row
+ *  and only declares structural deps (`parent-edge`). */
+export declare const CHILDREN_IDS_SQL = "\n  SELECT id FROM blocks\n   WHERE parent_id = ? AND deleted = 0\n   ORDER BY order_key, id\n";
+//# sourceMappingURL=treeQueries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeQueries.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/treeQueries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;qBAEqB;AACrB,eAAO,MAAM,WAAW,sjBAkBvB,CAAA;AAED;qBACqB;AACrB,eAAO,MAAM,aAAa,4iBAkBzB,CAAA;AAED;;;;;;;;;;+CAU+C;AAC/C,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MA0BlD,CAAA;AAED;;;iCAGiC;AACjC,eAAO,MAAM,oBAAoB,miBAkBhC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;sEAwBsE;AACtE,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,MAqB9C,CAAA;AAED;qBACqB;AACrB,eAAO,MAAM,YAAY,kGAIxB,CAAA;AAED;;yDAEyD;AACzD,eAAO,MAAM,gBAAgB,mGAI5B,CAAA"}

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

@@ -0,0 +1,155 @@
+/**
+ * Tx engine — implements the public `Tx` interface (`src/data/api/tx.ts`)
+ * over a PowerSync `writeTransaction` callback context. Spec §5.3, §10.
+ *
+ * Write-through to SQL: every primitive runs INSERT / UPDATE inline
+ * against the writeTransaction's lock context. Triggers fire per
+ * primitive (row_events written, upload routing decided). The engine
+ * captures `(before, after)` per id in a tx-private snapshots map for
+ * commit-walk handle diffing + undo recording. The shared cache is NOT
+ * mutated mid-tx (v4.24) — outside-tx readers see only committed state.
+ *
+ * Reads:
+ *   - `tx.get` / `tx.childrenOf` / `tx.parentOf` — SQL via the
+ *     writeTransaction (read-your-own-writes natively).
+ *   - `tx.peek` — sync; snapshots map first (own writes), then the
+ *     pre-tx cache; never reads SQL.
+ *
+ * What lives here:  primitives, cycle check, single-workspace pin,
+ * snapshots capture, codec at the four boundary sites.
+ *
+ * What lives in `commitPipeline.ts`:  the writeTransaction shell,
+ * tx_context set/clear, command_events insert, post-commit cache walk,
+ * undo recording, afterCommit dispatch.
+ */
+import type { AnyMutator, AnyPostCommitProcessor, BlockData, BlockDataPatch, ChangeScope, Mutator, NewBlockData, PropertySchema, Tx, TxMeta, TxSource, TxWriteOpts, User } from '@/data/api';
+import { type SnapshotsMap } from './txSnapshots';
+import type { BlockCache } from '@/data/blockCache';
+/** Minimal subset of `@powersync/common`'s `LockContext` we actually use.
+ *  Production passes the real type; the test harness's
+ *  `writeTransaction` callback exposes the same shape. */
+export interface TxDb {
+    execute(sql: string, params?: unknown[]): Promise<unknown>;
+    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>;
+}
+/** Per-tx scheduling record produced by `tx.afterCommit`. The commit
+ *  pipeline picks these up post-commit; rollback discards them. */
+export interface AfterCommitJob {
+    processorName: string;
+    args: unknown;
+    delayMs?: number;
+}
+/** A single mutator call captured during the tx — pushed by `tx.run`
+ *  (spec §4.4 / §13.3). Written into `command_events.mutator_calls`
+ *  as JSON at commit time so audit and undo can see what each tx did
+ *  in mutator-grain terms, not just the row-grain row_events log. */
+export interface MutatorCallRecord {
+    name: string;
+    args: unknown;
+}
+/** Construction context for `TxImpl`. The pipeline assembles this and
+ *  hands it off; primitives use the fields directly. */
+export interface TxImplContext {
+    txDb: TxDb;
+    snapshots: SnapshotsMap;
+    cache: BlockCache;
+    meta: TxMeta;
+    afterCommitJobs: AfterCommitJob[];
+    /** Mutable list of mutator calls captured during the tx. Pushed by
+     *  `tx.run`; the pipeline pre-populates with the outermost call from
+     *  `repo.mutate.X` / `repo.run`. JSON-serialized into
+     *  `command_events.mutator_calls` at commit time. */
+    mutatorCalls: MutatorCallRecord[];
+    /** Now provider — injected for testability (deterministic timestamps). */
+    now: () => number;
+    /** Mutator registry snapshot (taken at tx start). For stage 1.3 the
+     *  registry is empty in v1; tx.run with an unregistered mutator
+     *  throws MutatorNotRegisteredError. */
+    mutators: ReadonlyMap<string, AnyMutator>;
+    /** Processor registry snapshot (taken at tx start). Used by
+     *  `tx.afterCommit` to validate `scheduledArgs` against the
+     *  processor's `scheduledArgsSchema` at enqueue time so a bad arg
+     *  fails the originating tx (clean rollback) instead of failing
+     *  later at fire time. */
+    processors: ReadonlyMap<string, AnyPostCommitProcessor>;
+    /** UUID generator — injected for testability. */
+    newId: () => string;
+}
+export declare class TxImpl implements Tx {
+    readonly meta: TxMeta;
+    private readonly ctx;
+    /** True once `meta.workspaceId` has been pinned by the first write
+     *  (or first write candidate that the engine validated to insert). */
+    private workspacePinned;
+    constructor(ctx: TxImplContext);
+    get(id: string): Promise<BlockData | null>;
+    peek(id: string): BlockData | null;
+    create(data: NewBlockData, opts?: TxWriteOpts): Promise<string>;
+    createOrGet(data: NewBlockData & {
+        id: string;
+    }, opts?: TxWriteOpts): Promise<{
+        id: string;
+        inserted: boolean;
+    }>;
+    delete(id: string): Promise<void>;
+    restore(id: string, patch?: BlockDataPatch, opts?: TxWriteOpts): Promise<void>;
+    update(id: string, patch: BlockDataPatch, opts?: TxWriteOpts): Promise<void>;
+    move(id: string, target: {
+        parentId: string | null;
+        orderKey: string;
+    }, opts?: TxWriteOpts): Promise<void>;
+    setProperty<T>(id: string, schema: PropertySchema<T>, value: T, opts?: TxWriteOpts): Promise<void>;
+    getProperty<T>(id: string, schema: PropertySchema<T>): Promise<T>;
+    run<Args, R>(mutator: Mutator<Args, R>, args: Args): Promise<R>;
+    childrenOf(parentId: string | null, workspaceId?: string): Promise<BlockData[]>;
+    parentOf(childId: string): Promise<BlockData | null>;
+    aliasLookup(alias: string, workspaceId: string): Promise<BlockData | null>;
+    afterCommit<P extends string>(processorName: P, args: unknown, options?: {
+        delayMs?: number;
+    }): void;
+    /** Drive the row at `id` to exactly `target` (or soft-delete if target
+     *  is null). Bypasses the public primitives — intentionally — because
+     *  undo replay restores arbitrary snapshot state that the narrow patch
+     *  shape of `tx.update` can't express (e.g. `parent_id` + `order_key`
+     *  + `deleted` flipping in one write). Spec §10 step 7 + the
+     *  BlockDataPatch comment in `api/blockData.ts`.
+     *
+     *  Cycle / parent-deleted UX checks are skipped: the snapshot was
+     *  captured from a previously-committed tx, so the target state is
+     *  known to be valid (the engine validated it then). The
+     *  workspace-invariant trigger still fires on UPDATE-of-parent_id, so
+     *  the storage-level guarantee holds. `updatedAt` / `updatedBy` are
+     *  stamped to the replay tx's user + now() — a redo at 10:01 by user
+     *  B is correctly attributed to B@10:01, not the original write.
+     *
+     *  Captures `(currentRow, applied)` into the snapshots map so the
+     *  pipeline's commit-walk updates the cache and fires handles for the
+     *  rolled-back row. */
+    applyRaw(id: string, target: BlockData | null): Promise<void>;
+    /** Validate that a write to `workspaceId` is allowed in this tx.
+     *  Pre-pin (no writes yet) anything goes. Post-pin, must match. */
+    private checkWorkspace;
+    /** Pin the tx's workspace_id from the first successful primitive.
+     *  Idempotent. Mutates `this.meta` so external readers see the pin. */
+    private pinWorkspace;
+    private metadataPatch;
+    /** Build a fresh BlockData for `tx.create` / `tx.createOrGet` insert
+     *  paths. Engine sets all four metadata columns from tx_context unless
+     *  `opts.skipMetadata` (used only by bookkeeping writes). */
+    private buildNewBlockRow;
+    private requireExisting;
+    private requireParentInWorkspace;
+}
+/** Build the initial `meta` for a tx — used by the pipeline at the
+ *  start of `repo.tx`. The workspaceId starts null; the first write
+ *  primitive pins it. */
+export declare const newTxMeta: (params: {
+    txId: string;
+    scope: ChangeScope;
+    source: TxSource;
+    user: User;
+    description?: string;
+}) => TxMeta;
+//# sourceMappingURL=txEngine.d.ts.map

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

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

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

@@ -0,0 +1,32 @@
+/**
+ * Per-tx snapshots map. The single source of "what this tx wrote" — used
+ * by the commit pipeline (§10) for cache update + handle diffing + undo
+ * entry, and by `tx.peek` for sync within-tx reads.
+ *
+ * Capture rule: on the first touch of an id during a tx, the engine
+ * SELECTs the current row (`before`). Subsequent writes for the same id
+ * update `after`. On rollback the map is discarded — there is nothing to
+ * revert because the shared cache was never mutated mid-tx (v4.24).
+ */
+import type { BlockData } from '@/data/api';
+export interface SnapshotEntry {
+    /** State at first touch. `null` means no row existed when this tx
+     *  first looked at the id (i.e. the tx is creating it). */
+    before: BlockData | null;
+    /** State after this tx's most recent write. `null` means hard-delete
+     *  (not used by tx primitives in v1; soft-delete keeps the row with
+     *  `deleted: true`). */
+    after: BlockData | null;
+}
+/** Tx-private snapshots map. One per `repo.tx` invocation. */
+export type SnapshotsMap = Map<string, SnapshotEntry>;
+export declare const newSnapshotsMap: () => SnapshotsMap;
+/** Record a write. If this is the first touch of `id`, `before` is the
+ *  passed-in current state (the engine SELECTed it just before issuing
+ *  the write). On subsequent writes, `before` is preserved and only
+ *  `after` is updated. */
+export declare const recordWrite: (snapshots: SnapshotsMap, id: string, before: BlockData | null, after: BlockData | null) => void;
+/** Look up an own-write for a given id. Used by `tx.peek` to see this
+ *  tx's pending writes before the cache. */
+export declare const peekSnapshot: (snapshots: SnapshotsMap, id: string) => BlockData | null | undefined;
+//# sourceMappingURL=txSnapshots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txSnapshots.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/txSnapshots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C,MAAM,WAAW,aAAa;IAC5B;+DAC2D;IAC3D,MAAM,EAAE,SAAS,GAAG,IAAI,CAAA;IACxB;;4BAEwB;IACxB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;CACxB;AAED,8DAA8D;AAC9D,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAErD,eAAO,MAAM,eAAe,QAAO,YAAyB,CAAA;AAE5D;;;0BAG0B;AAC1B,eAAO,MAAM,WAAW,GACtB,WAAW,YAAY,EACvB,IAAI,MAAM,EACV,QAAQ,SAAS,GAAG,IAAI,EACxB,OAAO,SAAS,GAAG,IAAI,KACtB,IAOF,CAAA;AAED;4CAC4C;AAC5C,eAAO,MAAM,YAAY,GACvB,WAAW,YAAY,EACvB,IAAI,MAAM,KACT,SAAS,GAAG,IAAI,GAAG,SAGrB,CAAA"}

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

@@ -0,0 +1,37 @@
+import { type AnyPropertySchema, type BlockPredicate, type ResolvedTypedBlockQuery } from '@/data/api';
+export interface CompiledTypedBlockQuery {
+    readonly sql: string;
+    readonly params: readonly unknown[];
+}
+export type TypedBlockQueryProjection = 'rows' | 'ids';
+export declare const jsonPathForProperty: (name: string) => string;
+export declare const normalizeTypedBlockQuery: (query: ResolvedTypedBlockQuery) => ResolvedTypedBlockQuery;
+export declare const hasAncestorScope: (predicates: readonly BlockPredicate[]) => boolean;
+/** Does this `where[name]` value narrow the candidate set, or does
+ *  it only match rows lacking the property? `null` and the operator
+ *  form `{exists: false}` are semantic duplicates — both compile to
+ *  `IS NULL` — so both have to be classified as non-selective; if
+ *  only one were, ancestor-gate and dep-wiring decisions would drift
+ *  based on which shorthand the caller happened to use. */
+export declare const isSelectiveWhereValue: (value: unknown) => boolean;
+/** Ancestor-scope predicates require at least one candidate-bounding
+ *  filter; otherwise the recursive walk seeds from every live block
+ *  in the workspace. Throw before the walk runs — callers that
+ *  pre-fetch ancestor dep nodes (e.g. `resolveTypedBlocks`) call this
+ *  before issuing the dep SQL so an invalid query doesn't trigger
+ *  exactly the expensive walk the gate is meant to prevent. */
+export declare const assertAncestorWalkBounded: (query: ResolvedTypedBlockQuery) => void;
+/** Build the `candidates AS (...)` CTE body that selects the
+ *  fully self-filtered result set for a typed-block query. Shared
+ *  between the main SQL compiler and the ancestor-dep seed walk in
+ *  `resolveTypedBlocks` so both observe the SAME candidate set —
+ *  the row-dep declarations stay scoped to rows that actually feed
+ *  into the result. */
+export declare const buildCandidatesCte: (query: ResolvedTypedBlockQuery, propertySchemas: ReadonlyMap<string, AnyPropertySchema>) => {
+    sql: string;
+    params: unknown[];
+};
+export declare const compileTypedBlockQuery: (query: ResolvedTypedBlockQuery, propertySchemas: ReadonlyMap<string, AnyPropertySchema>, opts?: {
+    projection?: TypedBlockQueryProjection;
+}) => CompiledTypedBlockQuery;
+//# sourceMappingURL=typedBlockQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typedBlockQuery.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/typedBlockQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAE7B,MAAM,YAAY,CAAA;AAGnB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAA;CACpC;AAED,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,KAAK,CAAA;AAEtD,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,MACY,CAAA;AA2U/D,eAAO,MAAM,wBAAwB,GACnC,OAAO,uBAAuB,KAC7B,uBAUD,CAAA;AAEF,eAAO,MAAM,gBAAgB,GAAI,YAAY,SAAS,cAAc,EAAE,KAAG,OAC3B,CAAA;AAK9C;;;;;2DAK2D;AAC3D,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,OAOtD,CAAA;AAcD;;;;;+DAK+D;AAC/D,eAAO,MAAM,yBAAyB,GAAI,OAAO,uBAAuB,KAAG,IAmB1E,CAAA;AAED;;;;;uBAKuB;AACvB,eAAO,MAAM,kBAAkB,GAC7B,OAAO,uBAAuB,EAC9B,iBAAiB,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,KACtD;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAoEjC,CAAA;AA0BD,eAAO,MAAM,sBAAsB,GACjC,OAAO,uBAAuB,EAC9B,iBAAiB,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACvD,OAAM;IAAC,UAAU,CAAC,EAAE,yBAAyB,CAAA;CAAM,KAClD,uBAkDF,CAAA"}

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

@@ -0,0 +1,88 @@
+/**
+ * Undo / redo manager (spec §10 step 7, §17 line 2228).
+ *
+ * Per-scope undo + redo stacks. Every committed `repo.tx` whose scope
+ * is undoable (`BlockDefault`, `References`) gets one entry on its
+ * scope's undo stack — the entry holds the tx's snapshots map, which
+ * already captures `(before, after)` per touched id. Replay walks the
+ * map and uses `TxImpl.applyRaw` to drive each row to either `before`
+ * (undo direction) or `after` (redo direction). Replays themselves
+ * are not recorded on the undo stack — they push the SAME entry across
+ * stacks (manager-managed), so the cycle is symmetric and idempotent
+ * across repeated undo/redo presses.
+ *
+ * What this is NOT:
+ *   - Checkpoint coalescing for fine-grained typing (§16.4 — deferred).
+ *     v1 granularity is one entry per `repo.tx`; CodeMirror's internal
+ *     undo handles per-keystroke during edit-mode, and the document
+ *     write happens once on save/blur — already coarse-grained.
+ *   - Events-derived undo (§16.6 — deferred). row_events.before_json
+ *     enables a future drift-tolerant variant; for now snapshots are
+ *     in-memory only.
+ *
+ * Scope semantics:
+ *   - `BlockDefault` — user undo stack (the cmd-Z target).
+ *   - `References` — separate bucket; recorded for parity with the spec
+ *     but not exposed to user undo (§7.3, §5.8). `repo.undo` defaults
+ *     to `BlockDefault`.
+ *   - `UserPrefs` — never recorded. Preference writes sync, but cmd-Z
+ *     should not toggle recents / app settings.
+ *   - `UiState` — never recorded (selection / focus state isn't
+ *     undoable). The `record` call no-ops on this scope.
+ */
+import { ChangeScope } from '@/data/api';
+import type { SnapshotsMap } from './txSnapshots';
+export interface UndoEntry {
+    scope: ChangeScope;
+    txId: string;
+    snapshots: SnapshotsMap;
+    description?: string;
+}
+export interface UndoManagerOptions {
+    /** Cap per-scope stack depth. Older entries fall off. Default 100;
+     *  matches typical editor undo bounds. */
+    maxDepth?: number;
+}
+export declare class UndoManager {
+    private readonly undoStacks;
+    private readonly redoStacks;
+    private readonly listenersByScope;
+    private readonly maxDepth;
+    constructor(opts?: UndoManagerOptions);
+    /** Push an entry onto the undo stack of its scope. Side-effects:
+     *  clears the redo stack for that scope (a new action invalidates
+     *  the redo branch). No-op for non-undoable scopes and zero-write txs.
+     *
+     *  Subscriber-visible state must be consistent at notify-time, so the
+     *  redo clear happens BEFORE pushUndo's notify fires — otherwise a
+     *  listener that recomputes `depths()` would see the stale pre-clear
+     *  redo count and keep redo UI enabled. */
+    record(entry: UndoEntry): void;
+    peekUndo(scope: ChangeScope): UndoEntry | null;
+    peekRedo(scope: ChangeScope): UndoEntry | null;
+    popUndo(scope: ChangeScope): UndoEntry | null;
+    popRedo(scope: ChangeScope): UndoEntry | null;
+    pushUndo(scope: ChangeScope, entry: UndoEntry): void;
+    pushRedo(scope: ChangeScope, entry: UndoEntry): void;
+    /** Subscribe to stack-shape changes for `scope`. Fires after any
+     *  record / push / pop on either the undo or redo stack of that
+     *  scope. Used by reactive UI (toast button enable-state, future
+     *  Edit-menu Undo/Redo) to re-read `peekUndo` / `depths`. Returns
+     *  an unsubscribe; listener exceptions are isolated by CallbackSet. */
+    subscribe(scope: ChangeScope, listener: () => void): () => void;
+    /** Drop all stacks (for tests + an eventual "clear history" UX).
+     *  Notifies subscribers on every scope that previously had state. */
+    clear(): void;
+    /** Stack depths — used by UI to enable / disable undo/redo buttons. */
+    depths(scope: ChangeScope): {
+        undo: number;
+        redo: number;
+    };
+    /** Only document/reference scopes are undoable. */
+    private isUndoable;
+    private getUndo;
+    private getRedo;
+    private listenersFor;
+    private notify;
+}
+//# sourceMappingURL=undoManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"undoManager.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/undoManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,WAAW,EAAmB,MAAM,YAAY,CAAA;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,WAAW,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,YAAY,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC;8CAC0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA2C;IACtE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA2C;IACtE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA+C;IAChF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,IAAI,GAAE,kBAAuB;IAIzC;;;;;;;+CAO2C;IAC3C,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAO9B,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI;IAI9C,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI;IAI9C,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI;IAM7C,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI;IAM7C,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;IAOpD,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;IAOpD;;;;2EAIuE;IACvE,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI/D;yEACqE;IACrE,KAAK,IAAI,IAAI;IAUb,uEAAuE;IACvE,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAO1D,mDAAmD;IACnD,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,MAAM;CAGf"}

package/dist/kernel-types/src/data/invalidation.d.ts

@@ -0,0 +1,47 @@
+import type { BlockData } from '@/data/api';
+export type PluginInvalidationKeys = ReadonlySet<string> | readonly string[];
+export type PluginInvalidationMap = ReadonlyMap<string, PluginInvalidationKeys>;
+export interface ChangeSnapshotSide {
+    id?: string;
+    parentId: string | null;
+    orderKey?: string;
+    workspaceId: string;
+    deleted?: boolean;
+    /** Block content. Surfaced here for the kernel `content` invalidation
+     *  channel — fires when content actually changes, so substring-search
+     *  / recent-blocks queries don't invalidate on UiState property
+     *  writes. Type-level only: runtime values are full `BlockData`
+     *  snapshots that already carry `content`. */
+    content?: string;
+    references?: ReadonlyArray<{
+        id: string;
+        sourceField?: string;
+    }>;
+    /** Encoded property bag — same shape as `BlockData.properties`. Surfaced
+     *  here so invalidation rules can diff per-property values without
+     *  importing `BlockData`. The runtime values are full `BlockData`
+     *  snapshots (`SnapshotEntry`); this type is the slim view rules see. */
+    properties?: Readonly<Record<string, unknown>>;
+}
+export interface ChangeSnapshot {
+    before: ChangeSnapshotSide | null;
+    after: ChangeSnapshotSide | null;
+}
+export interface InvalidationRowEvent {
+    blockId: string;
+    kind: string;
+    before: BlockData | null;
+    after: BlockData | null;
+}
+export type PluginInvalidationEmit = (channel: string, key: string) => void;
+export interface InvalidationRule {
+    id: string;
+    collectFromSnapshots?: (snapshots: ReadonlyMap<string, ChangeSnapshot>, emit: PluginInvalidationEmit) => void;
+    collectFromRowEvent?: (event: InvalidationRowEvent, emit: PluginInvalidationEmit) => void;
+}
+export type MutablePluginInvalidationMap = Map<string, Set<string>>;
+export declare const emitPluginInvalidation: (out: MutablePluginInvalidationMap, channel: string, key: string) => void;
+export declare const createPluginInvalidationEmitter: (out: MutablePluginInvalidationMap) => PluginInvalidationEmit;
+export declare const collectPluginInvalidationsFromSnapshots: (rules: readonly InvalidationRule[], snapshots: ReadonlyMap<string, ChangeSnapshot>) => PluginInvalidationMap | undefined;
+export declare const pluginInvalidationSize: (pluginInvalidations: PluginInvalidationMap | undefined) => number;
+//# sourceMappingURL=invalidation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invalidation.d.ts","sourceRoot":"","sources":["../../../../../../src/data/invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C,MAAM,MAAM,sBAAsB,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,MAAM,EAAE,CAAA;AAC5E,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;AAE/E,MAAM,WAAW,kBAAkB;IACjC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;kDAI8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAChE;;;6EAGyE;IACzE,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACjC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,GAAG,IAAI,CAAA;IACxB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;CACxB;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;AAE3E,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,oBAAoB,CAAC,EAAE,CACrB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,EAC9C,IAAI,EAAE,sBAAsB,KACzB,IAAI,CAAA;IACT,mBAAmB,CAAC,EAAE,CACpB,KAAK,EAAE,oBAAoB,EAC3B,IAAI,EAAE,sBAAsB,KACzB,IAAI,CAAA;CACV;AAED,MAAM,MAAM,4BAA4B,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;AAEnE,eAAO,MAAM,sBAAsB,GACjC,KAAK,4BAA4B,EACjC,SAAS,MAAM,EACf,KAAK,MAAM,KACV,IAQF,CAAA;AAED,eAAO,MAAM,+BAA+B,GAC1C,KAAK,4BAA4B,KAChC,sBAC0D,CAAA;AAE7D,eAAO,MAAM,uCAAuC,GAClD,OAAO,SAAS,gBAAgB,EAAE,EAClC,WAAW,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,KAC7C,qBAAqB,GAAG,SAM1B,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,qBAAqB,qBAAqB,GAAG,SAAS,KACrD,MAOF,CAAA"}

package/dist/kernel-types/src/data/kernelDataExtension.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Kernel data-layer AppExtension — wraps the kernel mutators, queries,
+ * property schemas, and any core-only post-commit processors as facet
+ * contributions so the FacetRuntime carries them. The Repo bootstraps
+ * with kernel registries directly, but `repo.setFacetRuntime(runtime)`
+ * REPLACES those registries, so the runtime's data facets must include
+ * the kernel contributions to keep `repo.mutate.<kernel>` and
+ * `repo.query.<kernel>` working after that call.
+ *
+ * Property schemas (Phase 3 — chunk A): the kernel descriptors live
+ * in `data/properties.ts` + `data/internals/coreProperties.ts` and are
+ * exported as plain consts; this extension surfaces them through
+ * `propertySchemasFacet` so non-React surfaces (the property panel's
+ * schema lookup, future CLI / server-side audit) and plugin authors
+ * can resolve names through the same registry that plugin schemas
+ * register into.
+ *
+ * Queries (Phase 4 — chunk B): KERNEL_QUERIES are facet-contributed
+ * here so `repo.setFacetRuntime(runtime)` includes them alongside
+ * plugin queries. Repo also registers them at construction time
+ * (RepoOptions.registerKernelQueries, default true) so `repo.query.X`
+ * works pre-Stage-1 in the same way `repo.mutate.X` does — the
+ * setFacetRuntime call replaces the registry with the merged
+ * kernel + plugin set, so the kernel queries must be in the runtime
+ * to keep `repo.query.<kernel>` working after that call.
+ *
+ * No facet sources beyond the data layer here — UI facets
+ * (renderers, actions, contexts) live in their own extensions.
+ */
+import type { AppExtension } from '@/extensions/facet';
+export declare const kernelDataExtension: AppExtension;
+//# sourceMappingURL=kernelDataExtension.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelDataExtension.d.ts","sourceRoot":"","sources":["../../../../../../src/data/kernelDataExtension.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAkBH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGtD,eAAO,MAAM,mBAAmB,EAAE,YAahC,CAAA"}

package/dist/kernel-types/src/data/kernelPage.d.ts

@@ -0,0 +1,36 @@
+/** Per-workspace kernel-page bootstrap. Each workspace owns a small set
+ *  of singleton pages (Properties, Types, future Saved Queries /
+ *  Dashboards / Command palette). They share a shape: deterministic
+ *  uuid-v5 id derived from `workspaceId`, alias-based human-readable
+ *  surface, navigable as a normal page (`PAGE_TYPE`) plus a marker
+ *  block-type so `block_types`-indexed lookups can find them, and
+ *  soft-delete-restore on first reach.
+ *
+ *  Idempotent across offline launches — two clients booting offline
+ *  converge on the same row at next sync.
+ */
+import { Block } from '@/data/block';
+import type { Repo } from '@/data/repo';
+export interface KernelPageSpec {
+    /** uuid v5 namespace; the page id is `uuidv5(workspaceId, namespace)`.
+     *  Choose a fresh, randomly-generated namespace per page kind so two
+     *  kernel pages never collide on the same row. */
+    namespace: string;
+    /** Primary alias. Used as the page's `content` and as the sole entry
+     *  of its aliases prop. */
+    alias: string;
+    /** Marker block-type tagged alongside `PAGE_TYPE`. The marker is what
+     *  callers query for (`subscribeBlocks({types: [markerType]})`). */
+    markerType: string;
+    /** OrderKey for the page under the workspace root. Defaults to 'a0';
+     *  kernel pages share this value and tiebreak by id (stable enough
+     *  for navigation, no uniqueness invariant to maintain). */
+    orderKey?: string;
+}
+/** Deterministic block id for a kernel page in a given workspace. */
+export declare const kernelPageBlockId: (workspaceId: string, namespace: string) => string;
+/** Get-or-create a per-workspace kernel page. Repairs a live page that's
+ *  missing the expected types or alias; restores a soft-deleted row;
+ *  otherwise creates fresh. */
+export declare const getOrCreateKernelPage: (repo: Repo, workspaceId: string, spec: KernelPageSpec) => Promise<Block>;
+//# sourceMappingURL=kernelPage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelPage.d.ts","sourceRoot":"","sources":["../../../../../../src/data/kernelPage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAYvC,MAAM,WAAW,cAAc;IAC7B;;sDAEkD;IAClD,SAAS,EAAE,MAAM,CAAA;IACjB;+BAC2B;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb;wEACoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB;;gEAE4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,GAAI,aAAa,MAAM,EAAE,WAAW,MAAM,KAAG,MAC3C,CAAA;AAEhC;;+BAE+B;AAC/B,eAAO,MAAM,qBAAqB,GAChC,MAAM,IAAI,EACV,aAAa,MAAM,EACnB,MAAM,cAAc,KACnB,OAAO,CAAC,KAAK,CAmDf,CAAA"}

package/dist/kernel-types/src/data/localSchema.d.ts

@@ -0,0 +1,5 @@
+import type { AppExtension } from '@/extensions/facet.js';
+import { type LocalSchemaContribution, type LocalSchemaDb } from './facets.ts';
+export declare const resolveLocalSchemaContributions: (extensions: readonly AppExtension[]) => readonly LocalSchemaContribution[];
+export declare const applyLocalSchemaContributions: (db: LocalSchemaDb, contributions: readonly LocalSchemaContribution[]) => Promise<void>;
+//# sourceMappingURL=localSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localSchema.d.ts","sourceRoot":"","sources":["../../../../../../src/data/localSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EACnB,MAAM,aAAa,CAAA;AAEpB,eAAO,MAAM,+BAA+B,GAC1C,YAAY,SAAS,YAAY,EAAE,KAClC,SAAS,uBAAuB,EACyB,CAAA;AAE5D,eAAO,MAAM,6BAA6B,GACxC,IAAI,aAAa,EACjB,eAAe,SAAS,uBAAuB,EAAE,KAChD,OAAO,CAAC,IAAI,CAYd,CAAA"}

package/dist/kernel-types/src/data/metricsConsoleHook.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Devtools-console hook for `repo.metrics()`. Mirrors the
+ * `ensureRoamImportWindowHook` pattern — idempotent, hung off the
+ * same `window.__omniliner` namespace.
+ *
+ * Quickest cold-start workflow:
+ *
+ *   __omniliner.metrics.reset()
+ *   // do the thing (open page, type a keystroke, scroll, etc.)
+ *   __omniliner.metrics.print()
+ *
+ * `print()` formats the snapshot as console.table groups so percentile
+ * timings line up at a glance. `snapshot()` returns the raw frozen
+ * object if you want to programmatically diff two captures.
+ *
+ * Also exposes the `Repo` instance directly as
+ * `window.__omniliner.repo` so devtools-console one-liners
+ * (`__omniliner.repo.handleStore.size()`) work without a hook.
+ */
+import { Repo } from './repo';
+export declare const ensureMetricsConsoleHook: (repo: Repo) => void;
+//# sourceMappingURL=metricsConsoleHook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metricsConsoleHook.d.ts","sourceRoot":"","sources":["../../../../../../src/data/metricsConsoleHook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AA+D7B,eAAO,MAAM,wBAAwB,GAAI,MAAM,IAAI,KAAG,IAsDrD,CAAA"}