@knowledge-medium/agent-cli 0.1.0

package/dist/kernel-types/src/data/api/valuePresets.d.ts

@@ -0,0 +1,56 @@
+/** ValuePreset — the user-facing value vocabulary that maps onto codecs.
+ *  See user-defined-properties.md §1 for the full design. */
+import type { ComponentType } from 'react';
+import type { Codec } from './codecs';
+import type { PropertyEditor } from './propertySchema';
+export interface ValuePresetConfigEditorProps<TConfig> {
+    value: TConfig;
+    onChange: (next: TConfig) => void;
+}
+export interface ValuePreset<TValue = unknown, TConfig = void> {
+    /** Stable id; matches the codec's `type` for codecs built by this
+     *  preset. Persisted on user-defined schema blocks. */
+    readonly id: string;
+    /** Human label for the picker. */
+    readonly label: string;
+    /** Build the codec from preset-specific config. Called at schema
+     *  registration time and on runtime rebuild — must be deterministic
+     *  in `config` and only run on validated config (see configCodec). */
+    readonly build: (config: TConfig) => Codec<TValue>;
+    /** Default value used when the schema is registered and the property
+     *  is first materialised. Lives on the resulting `PropertySchema`. */
+    readonly defaultValue: TValue;
+    /** Default config used when the preset is registered through the
+     *  AddPropertyForm or the optimistic-materialize path without
+     *  user-supplied config. Required when `TConfig` is non-void; void
+     *  presets omit it. */
+    readonly defaultConfig?: TConfig;
+    /** Validates and parses raw JSON read from `presetConfigProp` into
+     *  `TConfig`. Required when `TConfig` is non-void. Throws on
+     *  malformed input — `UserSchemasService` catches, logs, and skips
+     *  schemas with invalid config rather than passing untyped JSON to
+     *  `build`. */
+    readonly configCodec?: Codec<TConfig>;
+    /** Editor used for any property whose codec's `type` matches this
+     *  preset's `id`. Required — every preset ships its own editor.
+     *  Exact-name `PropertyEditorOverride.Editor` contributions still
+     *  win first. */
+    readonly Editor: PropertyEditor<TValue>;
+    /** Optional glyph for the property-row button, config sheet, and
+     *  picker. Plugins without designed icons can omit; falls back to a
+     *  generic icon. */
+    readonly Glyph?: ComponentType<{
+        className?: string;
+    }>;
+    /** Optional config UI rendered inside the property-schema block
+     *  renderer (the side panel users open by clicking the property
+     *  glyph). Only meaningful when `TConfig` is non-void. */
+    readonly ConfigEditor?: ComponentType<ValuePresetConfigEditorProps<TConfig>>;
+}
+/** Variance-erased preset type for storage in heterogeneous
+ *  collections (`valuePresetsFacet`'s contributions, etc.). */
+export type AnyValuePreset = ValuePreset<any, any>;
+/** Helper for plugin authors to define a preset with full type
+ *  inference on the value/config slots. */
+export declare const definePreset: <TValue = unknown, TConfig = void>(preset: ValuePreset<TValue, TConfig>) => ValuePreset<TValue, TConfig>;
+//# sourceMappingURL=valuePresets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valuePresets.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/valuePresets.ts"],"names":[],"mappings":"AAAA;6DAC6D;AAE7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEtD,MAAM,WAAW,4BAA4B,CAAC,OAAO;IACnD,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;CAClC;AAED,MAAM,WAAW,WAAW,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,IAAI;IAC3D;2DACuD;IACvD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;0EAEsE;IACtE,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,KAAK,CAAC,MAAM,CAAC,CAAA;IAClD;0EACsE;IACtE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B;;;2BAGuB;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;IAChC;;;;mBAIe;IACf,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;IACrC;;;qBAGiB;IACjB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;IACvC;;wBAEoB;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;IACpD;;8DAE0D;IAC1D,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,4BAA4B,CAAC,OAAO,CAAC,CAAC,CAAA;CAC7E;AAED;+DAC+D;AAE/D,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAElD;2CAC2C;AAC3C,eAAO,MAAM,YAAY,GAAI,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,IAAI,EAC3D,QAAQ,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,KACnC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAW,CAAA"}

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

@@ -0,0 +1,140 @@
+/**
+ * `Block` — sync facade + Handle<BlockData|null> for a single block row
+ * (spec §5.1, §5.2).
+ *
+ * Block satisfies the Handle interface structurally (peek/load/subscribe/
+ * read/status/key) AND adds the OO sugar that 95% of imperative call
+ * sites use: `data` (sync, throws), `childIds` / `children` / `parent`
+ * (sync tree relatives), `get` / `peekProperty` (typed property reads),
+ * `set` / `setContent` / `delete` (single-block write sugar). Picking one
+ * object that does both jobs (vs. a separate `Handle` and `Block`) keeps
+ * the call-site surface uniform and unifies "row reactivity" with "row
+ * imperative work" under one identity-stable instance — see the
+ * data-layer-redesign task §13.2 design discussion.
+ *
+ * Identity: the same `Block` instance is returned from `repo.block(id)`
+ * for a given id (Repo holds them in `blockFacades`). Block does NOT
+ * register with `HandleStore` — its row-grain subscriptions go through
+ * `BlockCache.subscribe(id, …)` (already in place from Phase 1) and the
+ * cache fires whenever the snapshot changes. HandleStore is the registry
+ * for *collection* handles (`repo.children/subtree/ancestors/backlinks`),
+ * which need the dependency-shaped invalidation index that the row-grain
+ * cache already provides for free.
+ */
+import { type BlockData, type Handle, type HandleStatus, type PropertySchema, type Unsubscribe } from '@/data/api';
+import type { Repo } from './repo';
+import type { LoaderHandle } from './internals/handleStore';
+export declare class Block implements Handle<BlockData | null> {
+    readonly id: string;
+    readonly repo: Repo;
+    /** Inflight `load()` promise — dedup'd at the Block level so Suspense
+     *  paths can throw a stable promise across renders. Cleared once it
+     *  settles. The cache also has its own `dedupLoad` helper, but
+     *  `repo.load` deliberately doesn't use it (different `opts` would
+     *  silently merge); doing the dedup here keeps `read()` honest. */
+    private inflight;
+    /** Counts overlapping `load()` calls in flight. Drives `status()`'s
+     *  'loading' branch — needed since the cache itself doesn't know who
+     *  is currently loading what. */
+    private loadingCount;
+    /** Last error from a failed load. `status()` returns 'error' until the
+     *  next successful load clears it. */
+    private lastError;
+    constructor(repo: Repo, id: string);
+    /** Stable Handle key — namespaced so a handle store dedup index could
+     *  include Block (we don't currently register, but the key is part of
+     *  the contract so the option remains open). */
+    get key(): string;
+    /** Sync read; throws BlockNotLoadedError if the row isn't loaded,
+     *  BlockNotFoundError if `repo.load` previously confirmed the row
+     *  doesn't exist (§5.2). A soft-deleted row counts as loaded — the
+     *  facade exposes it with `deleted: true` so undo flows / devtools
+     *  can inspect it; consumers that want only-live filter themselves. */
+    get data(): BlockData;
+    /** Soft access (§5.2):
+     *    undefined → not loaded yet
+     *    null      → confirmed missing (load returned null)
+     *    BlockData → loaded (possibly soft-deleted) */
+    peek(): BlockData | undefined | null;
+    /** Ensure loaded. Idempotent + dedup'd at the Block level so Suspense
+     *  paths can throw a stable promise across renders. Returns null when
+     *  the row doesn't exist.
+     *
+     *  Cache fast-path: if the row is already in `BlockCache` we return
+     *  synchronously without going to SQL. The cache is the source of
+     *  truth post-tx (`repo.tx`'s commit pipeline writes it) and post-
+     *  sync (`rowEventsTail`'s `applySyncSnapshot` keeps it current), so
+     *  a redundant SQL read just costs a connection round-trip that
+     *  contends with PowerSync's upload/download work. The hot path
+     *  (keyboard navigation through `nextVisibleBlock` /
+     *  `previousVisibleBlock`) does 2-3 of these per arrow press —
+     *  occasionally blocked behind a slow sync drain (p99 ~600 ms in a
+     *  big-DB profile). Mirrors `repo.exists`'s short-circuit and the
+     *  `block.peek() ?? await block.load()` idiom.
+     *
+     *  The `confirmed-missing` marker is NOT a fast-path — `load()` is an
+     *  "ensure loaded" operation, and a missing marker is just the cached
+     *  result of a prior load. A caller asking again means they want SQL
+     *  to re-verify; the marker may be stale relative to a sync that
+     *  hasn't drained yet. */
+    load(): Promise<BlockData | null>;
+    /** Subscribe to cache mutations for this id. Listener fires with the
+     *  current `BlockData | null` (null = confirmed missing or evicted). */
+    subscribe(listener: (data: BlockData | null) => void): Unsubscribe;
+    /** Suspense-path read. Returns the value if loaded; throws a Promise
+     *  React can `await` if not loaded yet; throws the stored error if the
+     *  last load failed. (Spec §5.1.) */
+    read(): BlockData | null;
+    /** Handle lifecycle status (spec §5.1):
+     *    'ready'   — snapshot loaded OR row confirmed missing
+     *    'loading' — at least one `load()` call in flight, no value yet
+     *    'error'   — last load failed; cleared by the next successful load
+     *    'idle'    — no load attempted yet, no snapshot in cache */
+    status(): HandleStatus;
+    /** Sync property read with codec.decode + schema defaultValue
+     *  fallback. Throws BlockNotLoadedError if the row isn't loaded. */
+    get<T>(schema: PropertySchema<T>): T;
+    /** Like `get` but doesn't substitute the default — returns undefined
+     *  when the property is absent. */
+    peekProperty<T>(schema: PropertySchema<T>): T | undefined;
+    get types(): readonly string[];
+    hasType(typeId: string): boolean;
+    /** Reactive child-id list. Delegates to `repo.query.childIds({id})` —
+     *  the LoaderHandle owns SQL + caching + invalidation, so call sites
+     *  never need to ask the BlockCache about children directly.
+     *  Imperative call sites do `await block.childIds.load()`; reactive
+     *  ones use `useChildIds(block)` (which subscribes to the same
+     *  handle). */
+    get childIds(): LoaderHandle<string[]>;
+    /** Reactive children-rows list. Same shape as `childIds` but loads
+     *  the full BlockData rows (per-row deps included), suitable for
+     *  imperative tree walks that need content / properties without an
+     *  extra `repo.block(id).load()` per child. Callers wanting Block
+     *  facades do `(await block.children.load()).map(d => repo.block(d.id))`. */
+    get children(): LoaderHandle<BlockData[]>;
+    /** Parent as Block, or null only if this block has no parent
+     *  (workspace root). Returns the identity-stable facade from
+     *  `repo.block(parentId)` regardless of whether the parent row is
+     *  in cache — call `.load()` on the result if you need data.
+     *
+     *  Note: requires this block's own row to be in cache (so we know
+     *  `parentId`). Returns null if this block isn't loaded yet — the
+     *  caller is expected to have awaited a prior `load()` if it's
+     *  reading parent imperatively. */
+    get parent(): Block | null;
+    /** Set a typed property. Each call is its own tx, equivalent to
+     *  `repo.mutate.setProperty({id, schema, value})`. */
+    set<T>(schema: PropertySchema<T>, value: T): Promise<void>;
+    addType(typeId: string): Promise<void>;
+    removeType(typeId: string): Promise<void>;
+    toggleType(typeId: string): Promise<void>;
+    /** Set the block's content. */
+    setContent(content: string): Promise<void>;
+    /** Subtree-aware soft-delete (mirrors legacy `Block.delete`). */
+    delete(): Promise<void>;
+}
+/** Internal helper: throw a typed error for "block confirmed missing
+ *  by repo.load". Called by load paths to convert null returns into a
+ *  thrown error when the caller wants strict behavior. */
+export declare const requireLoadedBlock: (block: Block) => BlockData;
+//# sourceMappingURL=block.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../../../src/data/block.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAG3D,qBAAa,KAAM,YAAW,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC;IACpD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IAEnB;;;;uEAImE;IACnE,OAAO,CAAC,QAAQ,CAAyC;IAEzD;;qCAEiC;IACjC,OAAO,CAAC,YAAY,CAAI;IAExB;0CACsC;IACtC,OAAO,CAAC,SAAS,CAAqB;gBAE1B,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM;IAKlC;;oDAEgD;IAChD,IAAI,GAAG,IAAI,MAAM,CAA8B;IAI/C;;;;2EAIuE;IACvE,IAAI,IAAI,IAAI,SAAS,CAKpB;IAED;;;uDAGmD;IACnD,IAAI,IAAI,SAAS,GAAG,SAAS,GAAG,IAAI;IAOpC;;;;;;;;;;;;;;;;;;;;8BAoB0B;IAC1B,IAAI,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAuCjC;4EACwE;IACxE,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,GAAG,WAAW;IAOlE;;yCAEqC;IACrC,IAAI,IAAI,SAAS,GAAG,IAAI;IAaxB;;;;oEAIgE;IAChE,MAAM,IAAI,YAAY;IAUtB;wEACoE;IACpE,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC;IAOpC;uCACmC;IACnC,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS;IAQzD,IAAI,KAAK,IAAI,SAAS,MAAM,EAAE,CAG7B;IAED,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAMhC;;;;;mBAKe;IACf,IAAI,QAAQ,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC,CAErC;IAED;;;;iFAI6E;IAC7E,IAAI,QAAQ,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC,CAExC;IAED;;;;;;;;uCAQmC;IACnC,IAAI,MAAM,IAAI,KAAK,GAAG,IAAI,CAKzB;IAID;0DACsD;IAChD,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1D,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C,+BAA+B;IACzB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD,iEAAiE;IAC3D,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9B;AAED;;0DAE0D;AAC1D,eAAO,MAAM,kBAAkB,GAAI,OAAO,KAAK,KAAG,SAKjD,CAAA"}

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

@@ -0,0 +1,114 @@
+import type { BlockData } from '@/types';
+/** Counter object for BlockCache write/notify activity (perf-baseline
+ *  follow-up #4). One instance per BlockCache; increments inline in
+ *  the hot path. Snapshot via `snapshot()` for a frozen plain-object
+ *  view consumers can diff between samples. */
+export declare class BlockCacheMetrics {
+    /** Total `setSnapshot(...)` calls (every entry, every path). Includes
+     *  calls reached through `applySyncSnapshot`. */
+    setSnapshotCalls: number;
+    /** `setSnapshot` calls where the incoming fingerprint matched the
+     *  cached one — dedup hit, no listeners walked. */
+    setSnapshotDedupHits: number;
+    /** `setSnapshot` calls that actually wrote and notified. */
+    setSnapshotDedupMisses: number;
+    /** Total `applySyncSnapshot(...)` calls (sync-arrival LWW path). */
+    applySyncSnapshotCalls: number;
+    /** `applySyncSnapshot` calls rejected because the incoming
+     *  `updatedAt` was older than what's already cached. */
+    applySyncSnapshotRejected: number;
+    /** Total internal `notify(id)` invocations across all paths
+     *  (setSnapshot writes, deleteSnapshot, markMissing, clearMissing).
+     *  Counts the call, not the per-listener fan-out. */
+    notifies: number;
+    reset(): void;
+    /** Frozen plain-object snapshot — safe to keep as a baseline for
+     *  diffing between samples. */
+    snapshot(): Readonly<Record<string, number>>;
+}
+/** In-memory mirror of the per-row state of `blocks`. Holds:
+ *
+ *    - per-id BlockData snapshots (with subscriber list)
+ *    - confirmed-missing markers (for the Block facade's loaded/missing
+ *      distinction per spec §5.2)
+ *
+ *  Collection state (children, subtree, ancestors, backlinks) is NOT
+ *  cached here — it lives on `LoaderHandle`s registered with the
+ *  `HandleStore`, which is the single home for collection caching +
+ *  invalidation. Imperative callers that want children read from the
+ *  `repo.children(id)` / `repo.childIds(id)` handles, not from this
+ *  class. */
+export declare class BlockCache {
+    private readonly snapshots;
+    private readonly listeners;
+    private readonly pendingLoads;
+    /** Confirmed-missing markers — ids the loader looked up and the row
+     *  did not exist (or was soft-deleted). Lets the Block facade
+     *  distinguish "not loaded yet" (peek → undefined) from "confirmed
+     *  missing" (peek → null) per spec §5.2. Cleared on setSnapshot
+     *  (the row exists now). */
+    private readonly missingIds;
+    /** Mutable counters for cache write/notify activity. Increments
+     *  inline in the hot path; consumers snapshot via `metrics.snapshot()`
+     *  through `repo.metrics()`. */
+    readonly metrics: BlockCacheMetrics;
+    getSnapshot(id: string): BlockData | undefined;
+    hasSnapshot(id: string): boolean;
+    requireSnapshot(id: string): BlockData;
+    /** Unconditional snapshot write. Used by the local commit pipeline,
+     *  whose write IS the latest authoritative state for the row. Returns
+     *  true if listeners were notified (i.e. the snapshot actually
+     *  changed by fingerprint). */
+    setSnapshot(snapshot: BlockData): boolean;
+    /** LWW-gated snapshot write for sync-arrival paths (row_events tail,
+     *  re-reads from SQL inside `repo.load`, query hydrate-rows). Rejects
+     *  an incoming snapshot whose `updatedAt` is NOT STRICTLY NEWER than
+     *  what's already cached — PowerSync can deliver an older row state
+     *  during the upload window while the local commit pipeline has
+     *  already advanced the cache, and re-reading the SQLite row after a
+     *  sync-clobber would otherwise reintroduce the stale state.
+     *
+     *  Why `<=` not `<`: under rapid local typing, two writes can share
+     *  `Date.now()` ms (and processor writes with `skipMetadata: true`
+     *  preserve the prior `updatedAt`, multiplying the collision
+     *  surface). An in-flight query that reads SQL between two such
+     *  same-ms writes can fire `applySyncSnapshot` LATER with the
+     *  earlier-but-equal-ms content — `<` would accept it and clobber
+     *  the cache with stale content. `<=` rejects equal-ms snapshots;
+     *  same-`updatedAt`-same-content rounds to a no-op anyway via
+     *  fingerprint dedup, so this only blocks the harmful clobber. */
+    applySyncSnapshot(snapshot: BlockData): boolean;
+    deleteSnapshot(id: string): boolean;
+    subscribe(id: string, listener: () => void): () => void;
+    trackedIds(): Set<string>;
+    dedupLoad(id: string, loader: () => Promise<BlockData | undefined>): Promise<BlockData | undefined>;
+    private notify;
+    /** Mark `id` as confirmed-missing — `repo.load` looked it up and the
+     *  row didn't exist (or was soft-deleted). Block.peek will return
+     *  null instead of undefined; Block.data will throw
+     *  BlockNotFoundError instead of BlockNotLoadedError.
+     *  Notifies subscribers on the first transition into missing — a
+     *  subscribed Block facade re-renders when its row is confirmed
+     *  gone. Repeat calls (already missing) are no-ops to avoid
+     *  spurious re-renders.
+     *
+     *  Also drops any cached snapshot for this id. Block.peek/data,
+     *  status(), and repo.exists all consult the snapshot map first; if
+     *  a stale snapshot remained behind a freshly-set missing marker,
+     *  the facade would keep returning the old row state and never
+     *  observe the deletion. Notifies once even when both sides changed
+     *  — subscribers don't care which transition fired, only that they
+     *  should re-read. */
+    markMissing(id: string): boolean;
+    /** True iff `id` was previously confirmed-missing AND no snapshot
+     *  has since arrived. */
+    isMissing(id: string): boolean;
+    /** Clear the confirmed-missing marker — used by tests or by the
+     *  row_events tail when a sync-applied insert means we should re-check.
+     *  Notifies subscribers if the marker was actually cleared so the
+     *  facade exits the "confirmed-missing" branch on its next read.
+     *  (setSnapshot also clears the marker, but it always notifies
+     *  on its own as part of the snapshot-update path.) */
+    clearMissing(id: string): boolean;
+}
+//# sourceMappingURL=blockCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blockCache.d.ts","sourceRoot":"","sources":["../../../../../../src/data/blockCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAgBxC;;;+CAG+C;AAC/C,qBAAa,iBAAiB;IAC5B;qDACiD;IACjD,gBAAgB,SAAI;IACpB;uDACmD;IACnD,oBAAoB,SAAI;IACxB,4DAA4D;IAC5D,sBAAsB,SAAI;IAC1B,oEAAoE;IACpE,sBAAsB,SAAI;IAC1B;4DACwD;IACxD,yBAAyB,SAAI;IAC7B;;yDAEqD;IACrD,QAAQ,SAAI;IAEZ,KAAK,IAAI,IAAI;IASb;mCAC+B;IAC/B,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAU7C;AAED;;;;;;;;;;;aAWa;AACb,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoD;IACjF;;;;gCAI4B;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C;;oCAEgC;IAChC,QAAQ,CAAC,OAAO,oBAA0B;IAE1C,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI9C,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIhC,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS;IAQtC;;;mCAG+B;IAC/B,WAAW,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO;IAiBzC;;;;;;;;;;;;;;;;sEAgBkE;IAClE,iBAAiB,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO;IAU/C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAOnC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAmBvD,UAAU,IAAI,GAAG,CAAC,MAAM,CAAC;IAIzB,SAAS,CACP,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,GAC3C,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAWjC,OAAO,CAAC,MAAM;IAOd;;;;;;;;;;;;;;;0BAesB;IACtB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAShC;6BACyB;IACzB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI9B;;;;;2DAKuD;IACvD,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;CAKlC"}

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

@@ -0,0 +1,102 @@
+import type { PendingStatementParameter } from '@powersync/web';
+import type { BlockData } from '@/data/api';
+/** Storage shape — snake_case columns matching the Postgres schema and the
+ *  local SQLite table. Domain shape (camelCase) lives on `BlockData` in
+ *  `@/data/api`; `parseBlockRow` / `blockToRowParams` are the only places
+ *  either shape leaks into the other. See data-layer-redesign §4.1.1. */
+export interface BlockRow {
+    id: string;
+    workspace_id: string;
+    parent_id: string | null;
+    order_key: string;
+    content: string;
+    properties_json: string;
+    references_json: string;
+    created_at: number;
+    updated_at: number;
+    created_by: string;
+    updated_by: string;
+    deleted: 0 | 1;
+}
+/** Local SQLite column definitions. The PowerSync sync rule projects the
+ *  same column names against Postgres (`scripts/gen-sync-config.ts` reads
+ *  this array directly), so client and server stay structurally aligned —
+ *  see feedback_powersync_sync_config_with_schema. */
+export declare const BLOCK_STORAGE_COLUMNS: readonly [{
+    readonly name: "id";
+    readonly definition: "id TEXT PRIMARY KEY NOT NULL";
+}, {
+    readonly name: "workspace_id";
+    readonly definition: "workspace_id TEXT NOT NULL";
+}, {
+    readonly name: "parent_id";
+    readonly definition: "parent_id TEXT";
+}, {
+    readonly name: "order_key";
+    readonly definition: "order_key TEXT NOT NULL";
+}, {
+    readonly name: "content";
+    readonly definition: "content TEXT NOT NULL DEFAULT ''";
+}, {
+    readonly name: "properties_json";
+    readonly definition: "properties_json TEXT NOT NULL DEFAULT '{}'";
+}, {
+    readonly name: "references_json";
+    readonly definition: "references_json TEXT NOT NULL DEFAULT '[]'";
+}, {
+    readonly name: "created_at";
+    readonly definition: "created_at INTEGER NOT NULL";
+}, {
+    readonly name: "updated_at";
+    readonly definition: "updated_at INTEGER NOT NULL";
+}, {
+    readonly name: "created_by";
+    readonly definition: "created_by TEXT NOT NULL";
+}, {
+    readonly name: "updated_by";
+    readonly definition: "updated_by TEXT NOT NULL";
+}, {
+    readonly name: "deleted";
+    readonly definition: "deleted INTEGER NOT NULL DEFAULT 0";
+}];
+export declare const SELECT_BLOCK_COLUMNS_SQL: string;
+export declare const buildQualifiedBlockColumnsSql: (tableName: string) => string;
+export declare const CREATE_BLOCKS_TABLE_SQL: string;
+/** Sibling iteration index. Matches the server-side
+ *  `idx_blocks_parent_order` in `supabase/migrations/<...>_initial_schema_v2.sql`.
+ *  `(order_key, id)` tiebreak handles fractional-indexing-jittered key
+ *  collisions for deterministic post-sync ordering. */
+export declare const CREATE_BLOCKS_PARENT_ORDER_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_blocks_parent_order\n  ON blocks (parent_id, order_key, id)\n  WHERE deleted = 0\n";
+export declare const CREATE_BLOCKS_WORKSPACE_ACTIVE_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_blocks_workspace_active\n  ON blocks (workspace_id)\n  WHERE deleted = 0\n";
+export declare const UPSERT_BLOCK_SQL: string;
+export declare const BLOCKS_RAW_TABLE: {
+    put: {
+        sql: string;
+        params: PendingStatementParameter[];
+    };
+    delete: {
+        sql: string;
+        params: "Id"[];
+    };
+};
+export declare const buildBlockCrudJsonSql: (rowRef: string) => string;
+export declare const buildBlockSnapshotJsonSql: (rowRef: string) => string;
+export declare const parseBlockSnapshotJson: (value: string | null | undefined) => BlockData | undefined;
+export declare const parseBlockRow: (row: BlockRow) => BlockData;
+type BlockRowParams = [
+    id: string,
+    workspaceId: string,
+    parentId: string | null,
+    orderKey: string,
+    content: string,
+    propertiesJson: string,
+    referencesJson: string,
+    createdAt: number,
+    updatedAt: number,
+    createdBy: string,
+    updatedBy: string,
+    deleted: 0 | 1
+];
+export declare const blockToRowParams: (blockData: BlockData) => BlockRowParams;
+export {};
+//# sourceMappingURL=blockSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blockSchema.d.ts","sourceRoot":"","sources":["../../../../../../src/data/blockSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAgB,MAAM,gBAAgB,CAAA;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,YAAY,CAAA;AAE3D;;;yEAGyE;AACzE,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAIlB,OAAO,EAAE,CAAC,GAAG,CAAC,CAAA;CACf;AASD;;;sDAGsD;AACtD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAagB,CAAA;AAwBlD,eAAO,MAAM,wBAAwB,QAAmC,CAAA;AAExE,eAAO,MAAM,6BAA6B,GAAI,WAAW,MAAM,WAG7C,CAAA;AAElB,eAAO,MAAM,uBAAuB,QAInC,CAAA;AAED;;;uDAGuD;AACvD,eAAO,MAAM,oCAAoC,0HAIhD,CAAA;AAED,eAAO,MAAM,wCAAwC,kHAIpD,CAAA;AAED,eAAO,MAAM,gBAAgB,QAQ5B,CAAA;AAgBD,eAAO,MAAM,gBAAgB;;;;;;;;;CAiBL,CAAA;AAExB,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,WAInD,CAAA;AAsBD,eAAO,MAAM,yBAAyB,GAAI,QAAQ,MAAM,WAIvD,CAAA;AAaD,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,GAAG,IAAI,GAAG,SAAS,0BACQ,CAAA;AAE/E,eAAO,MAAM,aAAa,GAAI,KAAK,QAAQ,KAAG,SAa5C,CAAA;AAEF,KAAK,cAAc,GAAG;IACpB,EAAE,EAAE,MAAM;IACV,WAAW,EAAE,MAAM;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI;IACvB,QAAQ,EAAE,MAAM;IAChB,OAAO,EAAE,MAAM;IACf,cAAc,EAAE,MAAM;IACtB,cAAc,EAAE,MAAM;IACtB,SAAS,EAAE,MAAM;IACjB,SAAS,EAAE,MAAM;IACjB,SAAS,EAAE,MAAM;IACjB,SAAS,EAAE,MAAM;IACjB,OAAO,EAAE,CAAC,GAAG,CAAC;CACf,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,WAAW,SAAS,KAAG,cAavD,CAAA"}

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

@@ -0,0 +1,21 @@
+import { type TypeContribution } from '@/data/api';
+export declare const EXTENSION_TYPE = "extension";
+export declare const PAGE_TYPE = "page";
+export declare const PANEL_TYPE = "panel";
+export declare const PANEL_STACK_TYPE = "panel-stack";
+/** User-defined property schemas live as blocks of this type
+ *  (user-defined-properties §4). Kernel-owned; users don't create or
+ *  remove the type contribution itself. */
+export declare const PROPERTY_SCHEMA_TYPE = "property-schema";
+/** Marker type for the singleton Properties page that hosts every
+ *  property-schema block in a workspace. */
+export declare const PROPERTIES_PAGE_TYPE = "panel:properties";
+/** User-defined types live as blocks of this type
+ *  (user-defined-types Phase 1). Kernel-owned; users don't create or
+ *  remove the type contribution itself. */
+export declare const BLOCK_TYPE_TYPE = "block-type";
+/** Marker type for the singleton Types page that hosts every
+ *  block-type block in a workspace. */
+export declare const TYPES_PAGE_TYPE = "panel:types";
+export declare const KERNEL_TYPE_CONTRIBUTIONS: readonly TypeContribution[];
+//# sourceMappingURL=blockTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blockTypes.d.ts","sourceRoot":"","sources":["../../../../../../src/data/blockTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAanE,eAAO,MAAM,cAAc,cAAc,CAAA;AACzC,eAAO,MAAM,SAAS,SAAS,CAAA;AAC/B,eAAO,MAAM,UAAU,UAAU,CAAA;AACjC,eAAO,MAAM,gBAAgB,gBAAgB,CAAA;AAC7C;;2CAE2C;AAC3C,eAAO,MAAM,oBAAoB,oBAAoB,CAAA;AACrD;4CAC4C;AAC5C,eAAO,MAAM,oBAAoB,qBAAqB,CAAA;AACtD;;2CAE2C;AAC3C,eAAO,MAAM,eAAe,eAAe,CAAA;AAC3C;uCACuC;AACvC,eAAO,MAAM,eAAe,gBAAgB,CAAA;AAE5C,eAAO,MAAM,yBAAyB,EAAE,SAAS,gBAAgB,EAiChE,CAAA"}

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

@@ -0,0 +1,67 @@
+/**
+ * Data-layer facets — the bridge between the kernel + plugin
+ * contributions and the `Repo` lifecycle (spec §6, §8).
+ *
+ * Stage 1.4 ships `mutatorsFacet` only. The remaining four facets
+ * (`queriesFacet`, `propertySchemasFacet`, `propertyEditorOverridesFacet`,
+ * `postCommitProcessorsFacet`) land in stages 1.5+ as the matching
+ * machinery comes online.
+ */
+import type { AnyMutator, AnyPostCommitProcessor, AnyPropertyEditorOverride, AnyPropertySchema, AnyQuery, AnyValuePreset, TypeContribution } from '@/data/api';
+import type { InvalidationRule } from './invalidation.ts';
+export interface LocalSchemaDb {
+    execute: (sql: string) => Promise<unknown>;
+    getOptional: <T>(sql: string) => Promise<T | null>;
+}
+export interface LocalSchemaBackfill {
+    id: string;
+    run: (db: LocalSchemaDb) => Promise<void>;
+}
+export interface LocalSchemaContribution {
+    id: string;
+    statements?: readonly string[];
+    triggerNames?: readonly string[];
+    backfills?: readonly LocalSchemaBackfill[];
+}
+/** Key the registry by `Mutator.name`; duplicates log a warning and
+ *  last-wins (per §6 convention). Mutators with heterogeneous
+ *  Args/Result types share the registry slot via `AnyMutator` (variance
+ *  escape); call-site dispatch (`repo.mutate.X`, `tx.run(m, args)`)
+ *  recovers precise types via the `MutatorRegistry` augmentation. */
+export declare const mutatorsFacet: import("@/extensions/facet").Facet<AnyMutator, ReadonlyMap<string, AnyMutator>>;
+/** Future facets — declared empty for now so plugin authors can
+ *  reference them at compile time without runtime breakage when no
+ *  contributions exist. Wired up in stages 1.5+. */
+export declare const queriesFacet: import("@/extensions/facet").Facet<AnyQuery, ReadonlyMap<string, AnyQuery>>;
+export declare const propertySchemasFacet: import("@/extensions/facet").Facet<AnyPropertySchema, ReadonlyMap<string, AnyPropertySchema>>;
+export declare const typesFacet: import("@/extensions/facet").Facet<TypeContribution, ReadonlyMap<string, TypeContribution>>;
+export declare const propertyEditorOverridesFacet: import("@/extensions/facet").Facet<AnyPropertyEditorOverride, ReadonlyMap<string, AnyPropertyEditorOverride>>;
+/** Open-vocabulary preset registry. Keyed by preset id (matches the
+ *  codec `type` for codecs built by the preset). Last-wins on
+ *  collision, per facet convention. Plugins register through
+ *  `valuePresetsFacet.of(preset, {source: 'plugin'})`. */
+export declare const valuePresetsFacet: import("@/extensions/facet").Facet<AnyValuePreset, ReadonlyMap<string, AnyValuePreset>>;
+export declare const postCommitProcessorsFacet: import("@/extensions/facet").Facet<AnyPostCommitProcessor, ReadonlyMap<string, AnyPostCommitProcessor>>;
+export declare const sameTxProcessorsFacet: import("@/extensions/facet").Facet<import("@/data/api").SameTxProcessor, ReadonlyMap<string, import("@/data/api").SameTxProcessor>>;
+export declare const localSchemaFacet: import("@/extensions/facet").Facet<LocalSchemaContribution, readonly LocalSchemaContribution[]>;
+/** Default inner-property to use when filtering a `ref`/`refList`
+ *  property whose target is of a given block type. Contributed by the
+ *  *target* type's plugin (e.g. daily-notes contributes
+ *  `{targetType: 'daily-note', property: 'daily-note:date'}`) so that
+ *  filter UIs can present "filter this ref as a date" without baking
+ *  daily-note knowledge into the filter component. The compiled
+ *  predicate uses the typed-query `target` traversal — no
+ *  query-engine extension required.
+ *
+ *  Lookup is by target type id; last-wins on collision. Keyed by
+ *  target type (not ref property name) because the contract belongs to
+ *  the target — any user-defined ref pointing at a daily note should
+ *  get the same affordance without per-property registration. */
+export interface RefTargetFilterDefault {
+    readonly targetType: string;
+    /** Name of a registered `PropertySchema` on the target block type. */
+    readonly property: string;
+}
+export declare const refTargetFilterDefaultsFacet: import("@/extensions/facet").Facet<RefTargetFilterDefault, ReadonlyMap<string, RefTargetFilterDefault>>;
+export declare const invalidationRulesFacet: import("@/extensions/facet").Facet<InvalidationRule, readonly InvalidationRule[]>;
+//# sourceMappingURL=facets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"facets.d.ts","sourceRoot":"","sources":["../../../../../../src/data/facets.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,UAAU,EACV,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,QAAQ,EAER,cAAc,EACd,gBAAgB,EACjB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAEzD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC1C,WAAW,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;CACnD;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,GAAG,EAAE,CAAC,EAAE,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1C;AAED,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,SAAS,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAA;CAC3C;AAmCD;;;;qEAIqE;AACrE,eAAO,MAAM,aAAa,iFAexB,CAAA;AAEF;;oDAEoD;AAEpD,eAAO,MAAM,YAAY,6EAevB,CAAA;AAEF,eAAO,MAAM,oBAAoB,+FAe/B,CAAA;AAEF,eAAO,MAAM,UAAU,6FAerB,CAAA;AAEF,eAAO,MAAM,4BAA4B,+GAevC,CAAA;AAEF;;;0DAG0D;AAC1D,eAAO,MAAM,iBAAiB,yFAe5B,CAAA;AAEF,eAAO,MAAM,yBAAyB,yGAepC,CAAA;AAaF,eAAO,MAAM,qBAAqB,qIAehC,CAAA;AAEF,eAAO,MAAM,gBAAgB,iGAG3B,CAAA;AAEF;;;;;;;;;;;;iEAYiE;AACjE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,eAAO,MAAM,4BAA4B,yGAevC,CAAA;AAEF,eAAO,MAAM,sBAAsB,mFAGjC,CAAA"}

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

@@ -0,0 +1,72 @@
+/**
+ * React hooks for the per-user "user page", synced user prefs,
+ * per-plugin sub-blocks, and per-panel ui-state child tree. The
+ * non-React resolvers / mutators live in `stateBlocks.ts`; this file
+ * is the React-aware façade over them.
+ *
+ * Transient app-shell and plugin UI state (focus, selection, edit-mode,
+ * top-level block, etc.) uses `ChangeScope.UiState`; user preferences
+ * use `ChangeScope.UserPrefs` and live on their own child rows so
+ * unrelated properties never share a row-level UPDATE payload. Both
+ * scopes upload through the normal queue — the scope identity is what
+ * drives undo bucketing and schema validation, not the upload routing.
+ */
+import { type PropertySchema, type TypeContribution } from '@/data/api';
+import type { Block } from './block';
+import { type BlockSelectionState } from '@/data/properties';
+export { USER_PREFS_PATH_PART } from '@/data/userPrefs.js';
+export declare function useUIStateBlock(): Block;
+/** Root app-shell UI state, independent of the current panel context. */
+export declare function useRootUIStateBlock(): Block;
+export declare function useLayoutSessionBlock(layoutSessionId?: string): Block;
+export declare function usePanelsForLayoutSession(layoutSessionId?: string): Block[];
+export declare function useUserBlock(): Block;
+/** Hook to access and modify a UI-state property on the active UI-state
+ *  block. The property's schema dictates codec + default; writes are
+ *  scoped via the schema's `changeScope` (typically `UiState`). */
+export declare function useUIStateProperty<T>(schema: PropertySchema<T>): [T, (value: T) => void];
+export declare function useRootUIStateProperty<T>(schema: PropertySchema<T>): [T, (value: T) => void];
+/** Resolve the per-plugin user-prefs sub-block for a given type
+ *  contribution. The block is bootstrapped on first access via
+ *  `getPluginPrefsBlock`; subsequent calls return the same Block facade. */
+export declare function usePluginPrefsBlock(type: TypeContribution): Block;
+/** Read/write a user-pref property on the plugin's own sub-block. The
+ *  schema must declare `changeScope: ChangeScope.UserPrefs` so reads and
+ *  writes route through the synced (and read-only-aware) pref pipeline. */
+export declare const usePluginPrefsProperty: <T>(type: TypeContribution, schema: PropertySchema<T>) => [T, (value: T) => void];
+/** Resolve the per-plugin ui-state sub-block for a given type
+ *  contribution. The mirror of `usePluginPrefsBlock` for persistent
+ *  per-device state — the block lives under the root ui-state subtree
+ *  and never enters the upload queue. */
+export declare function usePluginUIStateBlock(type: TypeContribution): Block;
+/** Read/write a ui-state property on the plugin's own ui-state
+ *  sub-block. The schema must declare `changeScope: ChangeScope.UiState`
+ *  so writes route into the device-local ui-state subtree (and stay
+ *  undo-segregated from document edits). They still upload through the
+ *  normal queue. */
+export declare const usePluginUIStateProperty: <T>(type: TypeContribution, schema: PropertySchema<T>) => [T, (value: T) => void];
+/** Sugar for the global editing flag — `[isEditing, setIsEditing]`. */
+export declare const useIsEditing: () => [boolean, (value: boolean) => void];
+/** Selection state — sticky on the UI-state block. The setter merges
+ *  partial updates into the current snapshot. */
+export declare function useSelectionState(): [
+    BlockSelectionState,
+    (newState: Partial<BlockSelectionState>) => void
+];
+export declare const useInFocus: (blockId: string) => boolean;
+export declare const useIsSelected: (blockId: string) => boolean;
+export declare const useInEditMode: (blockId: string) => boolean;
+/**
+ * Whether `panelBlock` is the currently-active panel in its layout
+ * session. Per-panel boolean (same selector pattern as `useInFocus`):
+ * when activePanelId hops between panels, only the two whose membership
+ * flips re-render — the rest bail via `useSyncExternalStore`'s Object.is.
+ *
+ * When the panel renders OUTSIDE a layout session (no
+ * `layoutSessionBlockId` in context — e.g. a standalone embedded or
+ * preview surface) the concept of "active panel" doesn't apply, so we
+ * return `true`. Consumers that gate UI on "this surface owns
+ * keystrokes" treat non-layout surfaces as trivially active.
+ */
+export declare const useIsActivePanel: (panelBlock: Block) => boolean;
+//# sourceMappingURL=globalState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"globalState.d.ts","sourceRoot":"","sources":["../../../../../../src/data/globalState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,EAGL,KAAK,mBAAmB,EAGzB,MAAM,mBAAmB,CAAA;AAY1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAE1D,wBAAgB,eAAe,IAAI,KAAK,CAOvC;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,IAAI,KAAK,CAM3C;AAED,wBAAgB,qBAAqB,CAAC,eAAe,SAAuB,GAAG,KAAK,CAEnF;AAED,wBAAgB,yBAAyB,CAAC,eAAe,SAAuB,GAAG,KAAK,EAAE,CAEzF;AAED,wBAAgB,YAAY,IAAI,KAAK,CAMpC;AAED;;mEAEmE;AACnE,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GACxB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAGzB;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GACxB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAGzB;AAED;;4EAE4E;AAC5E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,KAAK,CAMjE;AAED;;2EAE2E;AAC3E,eAAO,MAAM,sBAAsB,GAAI,CAAC,EACtC,MAAM,gBAAgB,EACtB,QAAQ,cAAc,CAAC,CAAC,CAAC,KACxB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAItB,CAAA;AAEH;;;yCAGyC;AACzC,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,KAAK,CAMnE;AAED;;;;oBAIoB;AACpB,eAAO,MAAM,wBAAwB,GAAI,CAAC,EACxC,MAAM,gBAAgB,EACtB,QAAQ,cAAc,CAAC,CAAC,CAAC,KACxB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAItB,CAAA;AAEH,uEAAuE;AACvE,eAAO,MAAM,YAAY,QAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAC/B,CAAA;AAEnC;iDACiD;AACjD,wBAAgB,iBAAiB,IAAI;IACnC,mBAAmB;IACnB,CAAC,QAAQ,EAAE,OAAO,CAAC,mBAAmB,CAAC,KAAK,IAAI;CACjD,CAYA;AAED,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,KAAG,OAGzC,CAAA;AAEJ,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,OAQ5C,CAAA;AAEJ,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,OAY5C,CAAA;AAEJ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAAI,YAAY,KAAK,KAAG,OAYpD,CAAA"}