@knowledge-medium/agent-cli 0.1.0

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

@@ -0,0 +1,366 @@
+/**
+ * HandleStore + LoaderHandle (spec §5.1, §9.1, §9.2).
+ *
+ * HandleStore is the central registry for `Handle<T>` instances.
+ *
+ *   - Identity rule: same key (`(name, stable typed serialization(args))`)
+ *     → same handle instance returned from `getOrCreate`.
+ *   - Ref-count GC: handles dispose `gcTimeMs` after refCount reaches zero
+ *     (drained subscribers + drained in-flight loads).
+ *   - Invalidation index: handles declare `Dependency`s during `resolve`;
+ *     the store walks an inverted index when `invalidate(change)` fires.
+ *
+ * LoaderHandle is the base implementation used by Repo's collection
+ * factories (`repo.children`, `repo.subtree`, etc.). It plumbs:
+ *
+ *   - peek / load / subscribe / read / status (the Handle<T> surface),
+ *   - structural diffing (lodash.isEqual default; spec §9.4),
+ *   - dependency declaration via a `ResolveContext` passed to the loader,
+ *   - retain/release wiring on subscribe/unsubscribe so the store can GC.
+ *
+ * Block does NOT register here — it has its own row-grain subscription
+ * via BlockCache.subscribe and is identity-stable through `Repo.blockFacades`.
+ * The Handle interface on Block (§5.2) is a structural fit on top of those
+ * existing primitives; HandleStore is the home for collection handles only.
+ */
+import type { Dependency, Handle, HandleStatus, Unsubscribe } from '@/data/api';
+import { type ChangeSnapshot, type InvalidationRule, type PluginInvalidationMap } from '@/data/invalidation.js';
+/** Dependency kinds (spec §9.2). A handle whose `Dependency` matches an
+ *  incoming `ChangeNotification` is invalidated and re-resolved. The
+ *  concrete union lives in the public query API because query resolvers
+ *  declare these deps through `QueryCtx.depend(...)`. */
+export type { Dependency } from '@/data/api';
+/** Set of changes the store walks against handle dependencies. The
+ *  fast path (TxEngine post-commit) and the slow path (row_events tail)
+ *  both produce notifications of this shape. Empty fields mean "no
+ *  changes of that kind." */
+export interface ChangeNotification {
+    rowIds?: ReadonlySet<string> | readonly string[];
+    /** Parent edges affected — for a row whose parent_id changed, BOTH
+     *  the old and new parent ids appear here; for a same-parent order_key
+     *  change, the parent id appears here so ordered child lists refresh
+     *  (spec §9.2). */
+    parentIds?: ReadonlySet<string> | readonly string[];
+    workspaceIds?: ReadonlySet<string> | readonly string[];
+    tables?: ReadonlySet<string> | readonly string[];
+    /** Plugin-owned channel/key invalidations. Handles declare matching
+     *  `{kind:'plugin', channel, key}` deps. */
+    plugin?: PluginInvalidationMap;
+}
+/** Context handed to a handle's loader. The loader calls `depend(...)`
+ *  during resolve so the store can route future invalidations. */
+export interface ResolveContext {
+    depend(dep: Dependency): void;
+}
+/** Loader callback shape for LoaderHandle. Receives a ResolveContext for
+ *  dep declaration and returns the value the handle exposes. */
+export type Loader<T> = (ctx: ResolveContext) => Promise<T>;
+export interface HandleStoreOptions {
+    gcTimeMs?: number;
+    /** Schedule GC. Default `setTimeout`; tests inject a manual scheduler. */
+    schedule?: (cb: () => void, ms: number) => () => void;
+}
+interface RegisteredHandle {
+    key: string;
+    /** Walks deps; returns true if this handle should be invalidated. */
+    matches: (change: ChangeNotification) => boolean;
+    /** Called by the store when an invalidation hits. The handle re-runs
+     *  its loader and notifies subscribers if the value changed. When a
+     *  `NotifyBatch` is passed, the handle MUST call `batch.finish(...)`
+     *  exactly once for this invocation (either with a notify thunk to
+     *  flush when all batch members are done, or with `null` to release
+     *  its slot without contributing a notify). */
+    invalidate: (batch?: NotifyBatch) => void;
+    /** Called when GC fires — handle clears its state, the store removes
+     *  the entry from the registry. */
+    dispose: () => void;
+    /** Called from the store when the first subscriber is added or a load
+     *  starts; cancels any pending GC. */
+    retain: () => void;
+    /** Called when the last subscriber drops or a load completes; if
+     *  refCount reaches zero, schedules dispose. */
+    release: () => void;
+    /** Called for every change that flows through `store.invalidate(...)`,
+     *  regardless of whether `matches` returned true. The handle records
+     *  changes that arrived while a load is in flight so they can be
+     *  re-checked against the freshly-collected deps once the loader
+     *  settles. No-op when the handle isn't currently loading. */
+    observeDuringLoad: (change: ChangeNotification) => void;
+    /** Number of currently-registered Dependencies. Read by
+     *  `HandleStore.snapshotInventory()` to surface fat-handle outliers
+     *  without exposing the full dep list. */
+    depCount: () => number;
+}
+/** Coordinates notify-fan-out across multiple handles invalidated by the
+ *  same `ChangeNotification`. Without this, each handle's loader settles
+ *  on its own task and fires its notify independently; if loaders settle
+ *  in different macrotasks (the common case for SQL-backed loaders), the
+ *  browser can paint between them. The visible symptom on indent/move:
+ *  the moved block disappears from its old parent's list, layout collapses,
+ *  then it reappears under the new parent on the next paint.
+ *
+ *  Semantics:
+ *    - Each handle invalidated as part of one `store.invalidate(...)`
+ *      call registers itself with the batch via `register()` and MUST
+ *      call `finish(notifyOrNull)` exactly once for that registration —
+ *      with a notify thunk if it wants to fire after the barrier, or
+ *      `null` to release its slot (errors, deferred-no-listeners,
+ *      mid-load coalescing, structural-diff no-ops).
+ *    - The barrier closes once `close()` has been called AND all
+ *      registered slots have finished. At that point every queued notify
+ *      runs synchronously in registration order, landing in one
+ *      microtask so React 18 auto-batching captures them in one commit.
+ *    - Slots that finish synchronously during the invalidate walk are
+ *      drained the same way; if all matched handles short-circuit, the
+ *      barrier flushes immediately on `close()`.
+ *    - Mid-load handles forward `null` and don't re-register their
+ *      post-settle reload into this batch; that reload's notify lands
+ *      in its own microtask. The dominant indent/move case is ready
+ *      handles, so the batch covers the symptom; mid-load is a
+ *      best-effort fallback.
+ */
+declare class NotifyBatch {
+    private remaining;
+    private closed;
+    private flushed;
+    private readonly queue;
+    /** Reserve a slot — must be paired with exactly one `finish(...)`. */
+    register(): void;
+    /** Release a slot, optionally contributing a notify to flush when the
+     *  barrier closes. Pass `null` for "no notify from this slot." */
+    finish(notify: (() => void) | null): void;
+    /** Signal that no more `register()` calls will arrive. If the slot
+     *  count is already zero this flushes immediately. */
+    close(): void;
+    private maybeFlush;
+}
+/** Mutable counter object for handle-related metrics (perf-baseline
+ *  follow-up #4). One instance per HandleStore; LoaderHandles read it
+ *  through `store.metrics` so handle-level events (loader runs,
+ *  mid-load invalidations, structural-diff dedup) aggregate across the
+ *  full lifetime of the store rather than being lost when handles GC.
+ *
+ *  Counters are plain `number` fields and increment inline; the cost
+ *  is sub-nanosecond in the hot path. Snapshot via `snapshot()` for a
+ *  frozen plain-object view consumers can diff between samples. */
+export declare class HandleStoreMetrics {
+    /** Total invalidate(...) calls that did not early-return. The
+     *  empty-store + empty-change short-circuits are NOT counted (those
+     *  are the cost-free path; counting them would inflate the average
+     *  walk-per-call ratio). */
+    invalidations: number;
+    /** Total handles iterated across all invalidate calls. With the
+     *  current linear walk this equals `invalidations × handles.size`
+     *  on average; with the inverted-index optimisation it should drop
+     *  to `handlesMatched`. Watching this in production is the fastest
+     *  way to verify the optimisation has the intended effect. */
+    handlesWalked: number;
+    /** Total handles whose `matches(change)` returned true. */
+    handlesMatched: number;
+    /** Total `LoaderHandle.invalidate()` calls. Equals `handlesMatched`
+     *  unless callers invalidate handles directly (e.g. tests). */
+    loaderInvalidations: number;
+    /** Total `runLoader()` invocations — actual loader function calls
+     *  against SQL. Smaller than `loaderInvalidations` because:
+     *    - mid-load invalidations are coalesced via `pendingReinvalidate`
+     *      (they don't kick a fresh runLoader, they piggyback on the
+     *      already-inflight settle path),
+     *    - the cold `load()` from `subscribe()` also bumps this. */
+    loaderRuns: number;
+    /** `LoaderHandle.invalidate()` calls that arrived while a load was
+     *  inflight — these flip `pendingReinvalidate` instead of starting
+     *  a new runLoader. */
+    midLoadInvalidations: number;
+    /** Microtask-scheduled reloads triggered by `pendingReinvalidate`
+     *  during the settle path. Pairs with `midLoadInvalidations` (each
+     *  midLoad event eventually produces at most one reload, modulo
+     *  coalescing). */
+    reloadsAfterSettle: number;
+    /** `notify(value)` calls where the structural diff (spec §9.4)
+     *  determined the value was unchanged → listener walk skipped. */
+    notifiesSkippedByDiff: number;
+    /** `notify(value)` calls that actually walked the listener set. */
+    notifiesFired: number;
+    /** Invalidations that hit a handle with zero subscribers and no
+     *  inflight load — the handle was marked stale instead of eagerly
+     *  re-running its loader. The next `.load()` will re-resolve. This
+     *  counter exists to verify the optimisation is firing in workloads
+     *  where slow `.load()`-only queries (e.g. alias autocomplete) used
+     *  to thrash on every block write. */
+    loaderInvalidationsDeferred: number;
+    /** ctx.depend(...) calls that registered a dep the loader had already
+     *  declared in this same run — the duplicate is dropped instead of
+     *  re-pushed. Drives down the matches() walk cost for handles that
+     *  walk a graph and accidentally re-depend on shared nodes (e.g.
+     *  many-ancestors converging on a common root). A non-zero value here
+     *  is a hint that a resolver is over-registering — usually harmless,
+     *  but the counter exists so we can see how much work the dedup is
+     *  actually saving. */
+    depsDeduplicatedAtRegistration: number;
+    reset(): void;
+    /** Frozen plain-object snapshot. Safe to keep as a baseline for
+     *  diffing — does not share state with the live counter. */
+    snapshot(): Readonly<Record<string, number>>;
+}
+/** Identity-stable registry of handles. */
+export declare class HandleStore {
+    private readonly handles;
+    private readonly gcTimeMs;
+    private readonly schedule;
+    /** Metrics counters. LoaderHandle bumps handle-level fields through
+     *  this same object so all aggregates share one snapshot. */
+    readonly metrics: HandleStoreMetrics;
+    constructor(opts?: HandleStoreOptions);
+    /** Returns the GC delay in ms (used by LoaderHandle for its own
+     *  scheduling). */
+    getGcTimeMs(): number;
+    getScheduler(): (cb: () => void, ms: number) => () => void;
+    /** Get-or-create. Identity rule: same key → same instance. */
+    getOrCreate<T extends RegisteredHandle>(key: string, factory: () => T): T;
+    /** Remove a key (called by the handle itself on dispose). */
+    remove(key: string): void;
+    /** Walk all registered handles, invalidate the ones whose deps match. */
+    invalidate(change: ChangeNotification): void;
+    /** Test/debug: how many handles are currently registered. */
+    size(): number;
+    /** Snapshot of live-state aggregates over registered handles. Pairs
+     *  with `metrics.snapshot()` (counters) to give a complete read on
+     *  the store with one call. Use this to find fat-handle outliers
+     *  (resolvers declaring lots of deps) without having to walk
+     *  `this.handles` from a devtools eval.
+     *
+     *  `topHeavy` is the K=3 handles with the most deps. Three is enough
+     *  to spot a pattern (one outlier vs a cluster) and small enough to
+     *  surface in a log line. */
+    snapshotInventory(): Readonly<{
+        handleCount: number;
+        totalDeps: number;
+        maxDeps: number;
+        p50Deps: number;
+        p95Deps: number;
+        topHeavy: ReadonlyArray<Readonly<{
+            key: string;
+            depCount: number;
+        }>>;
+    }>;
+    /** Dispose every handle (test cleanup). */
+    clear(): void;
+}
+/** Generic loader-backed handle. The collection factories (`repo.children`,
+ *  `repo.subtree`, etc.) construct one of these with a key + loader. */
+export declare class LoaderHandle<T> implements Handle<T>, RegisteredHandle {
+    readonly key: string;
+    private readonly store;
+    private readonly loader;
+    private readonly equality;
+    private value;
+    private status_;
+    private error;
+    private readonly listeners;
+    private deps;
+    /** Inflight `load()` promise — dedup'd. Cleared once it settles. */
+    private inflight;
+    /** Suspense throw target — same as `inflight` while loading; let the
+     *  caller `await` the same promise React threw. */
+    private suspendingPromise;
+    /** Ref count = subscribers + inflight (1 if loading). Drives GC. */
+    private refCount;
+    private cancelGc;
+    private disposed;
+    /** Set when `invalidate()` fires while a load is in flight. The
+     *  inflight load may have already read stale data from SQL before the
+     *  invalidating commit landed, so its result cannot be trusted on
+     *  its own. We let the load settle (so the suspending promise React
+     *  is awaiting still resolves) and immediately re-run the loader to
+     *  pick up the post-invalidation state. */
+    private pendingReinvalidate;
+    /** Changes observed while this load is in flight. Recorded
+     *  unconditionally (not gated on `matches`) so deps that the loader
+     *  declares LATER — e.g. per-row deps published by `hydrateRows` after
+     *  SQL returns — can be checked against the queue once the loader
+     *  settles. Without this, a child-row commit landing between SQL
+     *  read and per-row `ctx.depend(...)` would slip past `matches`
+     *  (only the upfront `parent-edge` dep is known at that point) and
+     *  the handle would settle with stale `BlockData[]`. */
+    private changesDuringLoad;
+    /** Set when an invalidation lands on a handle with zero subscribers
+     *  and no inflight load. Eagerly re-running the loader for nobody is
+     *  pure waste — and worse, the run blocks write transactions on the
+     *  same SQLite connection (alias-autocomplete saw ~640ms reads
+     *  pacing block-creation writes). Instead we mark stale; the next
+     *  `.load()` bypasses the cached-value short-circuit and re-resolves.
+     *  Subscribed handles ignore this flag — they still re-run eagerly
+     *  so listeners stay in sync. */
+    private stale;
+    constructor(args: {
+        store: HandleStore;
+        key: string;
+        loader: Loader<T>;
+        /** Optional custom equality; defaults to lodash.isEqual (spec §9.4). */
+        equality?: (a: T, b: T) => boolean;
+    });
+    peek(): T | undefined;
+    status(): HandleStatus;
+    load(): Promise<T>;
+    /** Actually run the loader. Skips the cached-value short-circuit; used
+     *  by `load()` (cold path) and `invalidate()` (force re-resolve).
+     *
+     *  Dep visibility during the load:
+     *    - Each `ctx.depend(dep)` call is published to `this.deps`
+     *      immediately so a mid-load `invalidate({…})` can match
+     *      upfront-declared deps even before the loader awaits SQL.
+     *    - On load success we replace `this.deps` with the freshly-
+     *      collected list (drops any deps from the prior resolve that
+     *      this resolve didn't re-declare).
+     *    - On load failure we restore the prior deps so the next attempt
+     *      still has a sensible matching baseline. */
+    private runLoader;
+    subscribe(listener: (value: T) => void): Unsubscribe;
+    read(): T;
+    matches(change: ChangeNotification): boolean;
+    private matchesAgainst;
+    depCount(): number;
+    observeDuringLoad(change: ChangeNotification): void;
+    invalidate(batch?: NotifyBatch): void;
+    retain(): void;
+    release(): void;
+    dispose(): void;
+    private notify;
+    /** Test-only: snapshot of declared dependencies. */
+    __depsForTest(): readonly Dependency[];
+}
+export declare const stableArgsKey: (args: unknown) => string;
+/** Compose a Handle key from a name + optional args. Used by Repo
+ *  factories to construct identity-stable keys. */
+export declare const handleKey: (name: string, args?: unknown) => string;
+/** Per-id snapshot pair shape. Mirrors `SnapshotEntry` from
+ *  `txSnapshots.ts` without importing it (handleStore stays free of
+ *  internals dependencies). */
+export type { ChangeSnapshot } from '@/data/invalidation.js';
+/** Compute a `ChangeNotification` from a tx's per-id snapshots map.
+ *  Used by the TxEngine fast path (§9.3): post-commit, the engine
+ *  passes its snapshots map here and feeds the result into
+ *  `handleStore.invalidate(...)`.
+ *
+ *  Rules:
+ *    - `rowIds`: every id touched by the tx (any field change is enough
+ *       to invalidate row deps).
+ *    - `parentIds`: union of `before.parentId` / `after.parentId` when
+ *       the row's *membership* in a parent's live-children set changed
+ *       (creation, soft-deletion, restore, parent move), or the live
+ *       sibling order changed under the same parent (`order_key` update).
+ *       Pure content / property edits don't fire parent-edge deps.
+ *    - `workspaceIds`: every workspace_id touched (covers backlinks
+ *       handles' coarse workspace dep).
+ *    - `plugin`: channel/key invalidations emitted by plugin rules.
+ *
+ *  Note: `tables` is intentionally NOT auto-emitted. The `kind:'table'`
+ *  dep mechanism is still wired through `handleStore.invalidate(...)`,
+ *  but no production query depends on it — auto-emitting `['blocks']`
+ *  on every commit walked the channel for nothing. A plugin that
+ *  genuinely needs a coarse-table fallback should call
+ *  `handleStore.invalidate({tables: [...]})` directly, or (better)
+ *  contribute an `InvalidationRule` that emits a narrow plugin channel.
+ */
+export declare const snapshotsToChangeNotification: (snapshots: ReadonlyMap<string, ChangeSnapshot>, invalidationRules?: readonly InvalidationRule[]) => ChangeNotification;
+//# sourceMappingURL=handleStore.d.ts.map

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

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

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

@@ -0,0 +1,77 @@
+/**
+ * Narrow-dep invalidation for kernel queries.
+ *
+ * Replaces a handful of `{kind:'workspace', workspaceId}` deps that used to
+ * fire on every write in the workspace (including UiState focus writes,
+ * which is what drove the navigation perf regression) with channels keyed
+ * to the dimensions each query actually filters on.
+ *
+ * Channels emitted by this rule:
+ *
+ *   typedBlocks (`core.byType` / `core.typedBlocks`):
+ *   - `typedBlocks.live`      — any block create / soft-delete / restore
+ *                               (membership change in the live set)
+ *   - `typedBlocks.type`      — block_types index changed for (ws, type)
+ *   - `typedBlocks.property`  — a property value changed for (ws, name)
+ *   - `typedBlocks.reference` — incoming-edge set changed for (ws, target)
+ *   - `typedBlocks.referenceField` — same, sourceField-granular
+ *   - `typedBlocks.structure` — a known block's parent/workspace/live
+ *                               shape changed (for id projections that
+ *                               walk ancestor chains)
+ *   - `typedBlocks.refsOf`    — a known block's outgoing reference set
+ *                               changed (for aggregate context queries)
+ *   - `typedBlocks.label`     — content or alias changed for a known
+ *                               block used as a display label
+ *
+ *   alias index (`core.aliasLookup` / `core.aliasMatches` /
+ *   `core.aliasesInWorkspace`):
+ *   - `kernel.aliases`        — block_aliases set changed in (ws) — the
+ *                               `alias` property differs across the diff,
+ *                               or a row with non-empty aliases entered
+ *                               or left the live set
+ *
+ *   content scans (`core.searchByContent` / `core.recentBlocks`):
+ *   - `kernel.content`        — content edited or live-set membership
+ *                               changed in (ws). Recent-block ordering
+ *                               by `updated_at` is intentionally NOT a
+ *                               trigger — bumping recency on every
+ *                               UiState property write would put us
+ *                               back at the workspace-broad cost.
+ *
+ * Per-row deps from `hydrateBlocks` already cover updates to rows that
+ * are currently in the result; these channels close the gap for rows
+ * that *could enter or leave* the result.
+ *
+ * The rule runs both in the fast tx path (`collectFromSnapshots`) and in
+ * the row_events tail (`collectFromRowEvent`) so sync-applied writes
+ * fire the same channels.
+ */
+import type { ChangeSnapshot, InvalidationRule } from '@/data/invalidation.js';
+export declare const TYPED_BLOCKS_LIVE_CHANNEL = "typedBlocks.live";
+export declare const TYPED_BLOCKS_TYPE_CHANNEL = "typedBlocks.type";
+export declare const TYPED_BLOCKS_PROPERTY_CHANNEL = "typedBlocks.property";
+export declare const TYPED_BLOCKS_REFERENCE_CHANNEL = "typedBlocks.reference";
+export declare const TYPED_BLOCKS_REFERENCE_FIELD_CHANNEL = "typedBlocks.referenceField";
+export declare const TYPED_BLOCKS_STRUCTURE_CHANNEL = "typedBlocks.structure";
+export declare const TYPED_BLOCKS_REFS_OF_CHANNEL = "typedBlocks.refsOf";
+export declare const TYPED_BLOCKS_LABEL_CHANNEL = "typedBlocks.label";
+export declare const KERNEL_ALIASES_CHANNEL = "kernel.aliases";
+export declare const KERNEL_CONTENT_CHANNEL = "kernel.content";
+export declare const typedBlocksLiveKey: (workspaceId: string) => string;
+export declare const typedBlocksTypeKey: (workspaceId: string, type: string) => string;
+export declare const typedBlocksPropertyKey: (workspaceId: string, name: string) => string;
+export declare const typedBlocksReferenceKey: (workspaceId: string, targetId: string) => string;
+export declare const typedBlocksReferenceFieldKey: (workspaceId: string, targetId: string, sourceField: string) => string;
+export declare const typedBlocksStructureKey: (workspaceId: string, blockId: string) => string;
+export declare const typedBlocksRefsOfKey: (workspaceId: string, blockId: string) => string;
+export declare const typedBlocksLabelKey: (workspaceId: string, blockId: string) => string;
+export declare const kernelAliasesKey: (workspaceId: string) => string;
+export declare const kernelContentKey: (workspaceId: string) => string;
+type Emit = (channel: string, key: string) => void;
+/** Diff a single ChangeSnapshot and emit every channel this rule owns
+ *  (typedBlocks.* + kernel.aliases + kernel.content). Pure — no side
+ *  effects beyond `emit`. */
+export declare const emitKernelInvalidations: (snapshot: ChangeSnapshot, emit: Emit, fallbackBlockId?: string) => void;
+export declare const kernelInvalidationRule: InvalidationRule;
+export {};
+//# sourceMappingURL=kernelInvalidation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelInvalidation.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/kernelInvalidation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAE9E,eAAO,MAAM,yBAAyB,qBAAqB,CAAA;AAC3D,eAAO,MAAM,yBAAyB,qBAAqB,CAAA;AAC3D,eAAO,MAAM,6BAA6B,yBAAyB,CAAA;AACnE,eAAO,MAAM,8BAA8B,0BAA0B,CAAA;AACrE,eAAO,MAAM,oCAAoC,+BAA+B,CAAA;AAChF,eAAO,MAAM,8BAA8B,0BAA0B,CAAA;AACrE,eAAO,MAAM,4BAA4B,uBAAuB,CAAA;AAChE,eAAO,MAAM,0BAA0B,sBAAsB,CAAA;AAC7D,eAAO,MAAM,sBAAsB,mBAAmB,CAAA;AACtD,eAAO,MAAM,sBAAsB,mBAAmB,CAAA;AAItD,eAAO,MAAM,kBAAkB,GAAI,aAAa,MAAM,KAAG,MAAqB,CAAA;AAC9E,eAAO,MAAM,kBAAkB,GAAI,aAAa,MAAM,EAAE,MAAM,MAAM,KAAG,MACxC,CAAA;AAC/B,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM,EAAE,MAAM,MAAM,KAAG,MAC5C,CAAA;AAC/B,eAAO,MAAM,uBAAuB,GAAI,aAAa,MAAM,EAAE,UAAU,MAAM,KAAG,MAC7C,CAAA;AACnC,eAAO,MAAM,4BAA4B,GACvC,aAAa,MAAM,EACnB,UAAU,MAAM,EAChB,aAAa,MAAM,KAClB,MAA+D,CAAA;AAClE,eAAO,MAAM,uBAAuB,GAAI,aAAa,MAAM,EAAE,SAAS,MAAM,KAAG,MAC7C,CAAA;AAClC,eAAO,MAAM,oBAAoB,GAAI,aAAa,MAAM,EAAE,SAAS,MAAM,KAAG,MAC1C,CAAA;AAClC,eAAO,MAAM,mBAAmB,GAAI,aAAa,MAAM,EAAE,SAAS,MAAM,KAAG,MACzC,CAAA;AAElC,eAAO,MAAM,gBAAgB,GAAI,aAAa,MAAM,KAAG,MAAqB,CAAA;AAC5E,eAAO,MAAM,gBAAgB,GAAI,aAAa,MAAM,KAAG,MAAqB,CAAA;AA6C5E,KAAK,IAAI,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;AAoFlD;;6BAE6B;AAC7B,eAAO,MAAM,uBAAuB,GAClC,UAAU,cAAc,EACxB,MAAM,IAAI,EACV,kBAAkB,MAAM,KACvB,IAiMF,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,gBAiBpC,CAAA"}

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

@@ -0,0 +1,174 @@
+/**
+ * Kernel tree mutators (spec §13.3). Each is registered as a `Mutator`
+ * via `defineMutator` and dispatched from `repo.mutate.X(args)` or
+ * `repo.run('name', args)`.
+ *
+ * All mutators run inside a `repo.tx` (the dispatch wrapper opens one
+ * automatically with the mutator's scope) and use the public Tx
+ * primitives plus the tree CTEs from stage 1.3. Order keys are
+ * computed via `fractional-indexing-jittered` (§4.7 / §16.12).
+ *
+ * Subtree handling note: legacy `Block.delete()` cascaded a soft-delete
+ * across descendants; the new `delete` mutator preserves that behavior
+ * via DFS over `tx.childrenOf`. Walking by repeated child-queries keeps
+ * us on the public Tx surface (no raw SQL needed inside mutators); the
+ * round-trips are bounded by tree depth, which is small in practice.
+ */
+import { type AnyMutator, type BlockReference, type PropertySchema } from '@/data/api';
+export declare const setContent: import("@/data/api").Mutator<{
+    id: string;
+    content: string;
+}, void>;
+export declare const setProperty: import("@/data/api").Mutator<{
+    id: string;
+    schema: PropertySchema<unknown>;
+    value: unknown;
+}, void>;
+export declare const deleteBlock: import("@/data/api").Mutator<{
+    id: string;
+}, void>;
+interface CreateChildArgs {
+    parentId: string;
+    content?: string;
+    properties?: Record<string, unknown>;
+    references?: BlockReference[];
+    /** Where to insert under the parent. Default 'last'. */
+    position?: {
+        kind: 'first';
+    } | {
+        kind: 'last';
+    } | {
+        kind: 'after';
+        siblingId: string;
+    } | {
+        kind: 'before';
+        siblingId: string;
+    };
+    /** Optional explicit id (deterministic-id callers). Engine assigns
+     *  a UUID when absent. */
+    id?: string;
+}
+export declare const createChild: import("@/data/api").Mutator<CreateChildArgs, string>;
+interface SiblingArgs {
+    siblingId: string;
+    content?: string;
+    properties?: Record<string, unknown>;
+    references?: BlockReference[];
+    id?: string;
+}
+export declare const createSiblingAbove: import("@/data/api").Mutator<SiblingArgs, string>;
+export declare const createSiblingBelow: import("@/data/api").Mutator<SiblingArgs, string>;
+interface InsertChildrenArgs {
+    parentId: string;
+    items: Array<{
+        id?: string;
+        content?: string;
+        properties?: Record<string, unknown>;
+        references?: BlockReference[];
+    }>;
+    /** Where to insert the run under the parent. Default 'last'. */
+    position?: {
+        kind: 'first';
+    } | {
+        kind: 'last';
+    } | {
+        kind: 'after';
+        siblingId: string;
+    } | {
+        kind: 'before';
+        siblingId: string;
+    };
+}
+export declare const insertChildren: import("@/data/api").Mutator<InsertChildrenArgs, string[]>;
+interface MoveArgs {
+    id: string;
+    parentId: string | null;
+    position: {
+        kind: 'first';
+    } | {
+        kind: 'last';
+    } | {
+        kind: 'after';
+        siblingId: string;
+    } | {
+        kind: 'before';
+        siblingId: string;
+    };
+}
+export declare const move: import("@/data/api").Mutator<MoveArgs, void>;
+export declare const setOrderKey: import("@/data/api").Mutator<{
+    id: string;
+    orderKey: string;
+}, void>;
+export declare const indent: import("@/data/api").Mutator<{
+    id: string;
+}, void>;
+interface OutdentArgs {
+    id: string;
+    /** Optional view boundary. If `self.parentId === topLevelBlockId`,
+     *  outdent is a no-op — the block is a direct child of the current
+     *  view's root and outdenting would move it outside the visible
+     *  zoom scope (or to the workspace root for root-level views).
+     *  Returns `false` in that case so callers can fall back. */
+    topLevelBlockId?: string;
+}
+export declare const outdent: import("@/data/api").Mutator<OutdentArgs, boolean>;
+interface SplitArgs {
+    id: string;
+    /** Content for the new sibling-before (the prefix). */
+    before: string;
+    /** New content for the original block (the suffix). */
+    after: string;
+}
+export declare const split: import("@/data/api").Mutator<SplitArgs, string>;
+/** How target and source content are combined.
+ *  - `'concat'`  → `into.content + from.content`. Default; matches the
+ *    Backspace-at-block-start caller that needs zero-separator splice.
+ *  - `'keepTarget'` → keep target content; fall back to source's only when
+ *    target is empty (avoids silent loss in the canonical-stub-absorbs-
+ *    real-page case). Used for type-aware page merges where two prose
+ *    bodies don't compose meaningfully.
+ *  - `{separator}` → join with an explicit string between the two.
+ */
+export type ContentStrategy = 'concat' | 'keepTarget' | {
+    separator: string;
+};
+interface MergeArgs {
+    /** The block that absorbs the other's content + properties + children. */
+    intoId: string;
+    /** The block whose data folds into the target, then soft-deleted. */
+    fromId: string;
+    /** How to combine content. Defaults to `'concat'` for back-compat. */
+    contentStrategy?: ContentStrategy;
+}
+export declare const merge: import("@/data/api").Mutator<MergeArgs, void>;
+/** All kernel mutators in one array — registered with `Repo` by
+ *  `repo.setFacetRuntime` (or the bootstrapping helper that supplies
+ *  the facet runtime). Typed as `AnyMutator[]` because the mutators
+ *  have heterogeneous `Args`/`Result` shapes; precise types stay at
+ *  the per-mutator definition sites and reach callers through the
+ *  `MutatorRegistry` augmentation. */
+export declare const KERNEL_MUTATORS: ReadonlyArray<AnyMutator>;
+/** Register every kernel mutator with `MutatorRegistry` so call sites
+ *  using `repo.mutate.<name>(args)` and `repo.mutate['core.<name>'](args)`
+ *  get precise arg + result types without `as` casts. Plugins extend the
+ *  same interface from their own module per §12.1. */
+declare module '@/data/api' {
+    interface MutatorRegistry {
+        'core.setContent': typeof setContent;
+        'core.setProperty': typeof setProperty;
+        'core.delete': typeof deleteBlock;
+        'core.createChild': typeof createChild;
+        'core.createSiblingAbove': typeof createSiblingAbove;
+        'core.createSiblingBelow': typeof createSiblingBelow;
+        'core.insertChildren': typeof insertChildren;
+        'core.move': typeof move;
+        'core.setOrderKey': typeof setOrderKey;
+        'core.indent': typeof indent;
+        'core.outdent': typeof outdent;
+        'core.split': typeof split;
+        'core.merge': typeof merge;
+    }
+}
+export {};
+//# sourceMappingURL=kernelMutators.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+import type { AnyPostCommitProcessor } from '@/data/api';
+export declare const KERNEL_PROCESSORS: ReadonlyArray<AnyPostCommitProcessor>;
+//# sourceMappingURL=kernelProcessors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernelProcessors.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/internals/kernelProcessors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,sBAAsB,CAAM,CAAA"}