@knowledge-medium/agent-cli 0.1.0

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * Production bootstrap for the new data layer (replaces
+ * `src/data/repoInstance.ts`).
+ *
+ * Per-user PowerSync database — the database itself is the user
+ * isolation boundary (no shared CRUD queue, no shared cache, no risk
+ * of one session's pending uploads being retried under another user's
+ * JWT). Sign-out clears the Supabase session but leaves the local DB
+ * intact; sign-in as the same user reopens the same DB and unsynced
+ * edits resume uploading. Sign-in as a different user opens a fresh
+ * DB.
+ *
+ * What this DOES:
+ *   - Open a `PowerSyncDatabase` keyed by user id
+ *   - Run PowerSync's `init()` (sets up powersync_crud + ps_oplog)
+ *   - Run the new client-side DDL: `blocks` + core indexes,
+ *     workspaces + workspace_members tables/indexes,
+ *     `CLIENT_SCHEMA_STATEMENTS` (tx_context, row_events,
+ *     command_events, core side indexes, and triggers), then static
+ *     data-plugin local schema contributions
+ *   - Connect to the PowerSync server when `hasRemoteSyncConfig`
+ *
+ * What this does NOT do (vs. legacy):
+ *   - No `block_event_context` / `block_events` tables (replaced by
+ *     `tx_context` + `row_events` from clientSchema.ts)
+ *   - No legacy CRUD-routing triggers (replaced by the 5 audit/upload
+ *     triggers in clientSchema.ts that key on `tx_context.source`)
+ *   - No `UndoRedoManager` (undo lands in a future stage; engine
+ *     doesn't depend on it)
+ */
+import { PowerSyncDatabase } from '@powersync/web';
+export declare const dbFilenameForUser: (userId: string) => string;
+export declare const getPowerSyncDb: (userId: string) => PowerSyncDatabase;
+export declare const ensurePowerSyncReady: (userId: string, useRemoteSync?: boolean) => Promise<void>;
+//# sourceMappingURL=repoProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repoProvider.d.ts","sourceRoot":"","sources":["../../../../../../src/data/repoProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,iBAAiB,EAA4C,MAAM,gBAAgB,CAAA;AAkD5F,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,WAG/C,CAAA;AA8CD,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,KAAG,iBAM/C,CAAA;AAOD,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,MAAM,EACd,gBAAe,OAA6B,kBAuC7C,CAAA"}

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

@@ -0,0 +1,57 @@
+/**
+ * User-local state plumbing — per-user "user page", synced user prefs,
+ * per-plugin sub-blocks, and per-panel ui-state child tree. Pure
+ * (non-React) helpers live here; React hooks that consume them live in
+ * `globalState.ts`. Splitting along this fault line keeps module-init
+ * import graphs out of `react`/`@/context/repo`, which is what lets
+ * `pluginStateExtensions.ts` import these helpers statically without
+ * cycling through `repoProvider → staticDataExtensions → plugin/*`.
+ *
+ * Deterministic ids derived from (workspace, user, ...) keep two
+ * offline clients converging on the same row when they later sync.
+ */
+import { ChangeScope, type PropertySchema, type TypeContribution, type User } from '@/data/api';
+import { Block } from './block';
+import type { Repo } from './repo';
+import type { BlockContextType } from '@/types';
+import { type BlockSelectionState } from '@/data/properties';
+export declare const requireWorkspaceId: (repo: Repo, caller: string) => string;
+export declare const requireSchemaScope: <T>(schema: PropertySchema<T>, scope: ChangeScope, caller: string) => PropertySchema<T>;
+/** Per-user "user page" block — created (or restored) on first access.
+ *  The alias matches the user's display name so alias-based lookup
+ *  surfaces can target it directly. Memoized per (repo, workspaceId,
+ *  userId) — `use()` requires a stable promise per render.
+ *
+ *  The fast path uses `repo.load` to skip the tx entirely when the row
+ *  is already live in cache or in SQL. Tombstone branch lives INSIDE
+ *  the tx because `repo.load` filters `deleted = 0` (so tombstones
+ *  always come back as `null`); we have to use `tx.get` to see them. */
+export declare const getUserBlock: ((repo: Repo, workspaceId: string, user: User) => Promise<Block>) & import("lodash").MemoizedFunction;
+export declare const getUserPrefsBlock: ((repo: Repo, workspaceId: string, user: User) => Promise<Block>) & import("lodash").MemoizedFunction;
+/** Per-plugin preferences sub-block under the root user-prefs block.
+ *  Each plugin gets its own child keyed by the type contribution's `id`,
+ *  carrying that id as its block type marker. Splitting preferences across
+ *  per-plugin rows (rather than packing them all into the root block's
+ *  `properties_json`) bounds the blast radius of any single PATCH upload
+ *  to one plugin's settings — the row-level UPDATE trigger writes the full
+ *  `properties_json` column on any property change, so unrelated plugins'
+ *  values are no longer at risk of being clobbered by a peer's edit. */
+export declare const getPluginPrefsBlock: ((repo: Repo, workspaceId: string, user: User, type: TypeContribution) => Promise<Block>) & import("lodash").MemoizedFunction;
+/** Resolve the UI-state block scoped to the current panel context.
+ *  In a panel context (`context.panelId`), returns the panel's own
+ *  block — per-panel UI state lives directly on it. Outside a panel,
+ *  returns the user-level `ui-state` child of the user page. */
+export declare const getUIStateBlock: ((repo: Repo, workspaceId: string, user: User, context: BlockContextType) => Promise<Block>) & import("lodash").MemoizedFunction;
+export declare const getLayoutSessionBlock: ((uiStateBlock: Block, layoutSessionId: string) => Promise<Block>) & import("lodash").MemoizedFunction;
+/** Per-plugin ui-state sub-block under the root ui-state block. The
+ *  mirror of `getPluginPrefsBlock` for state that is persistent but
+ *  per-device (and therefore should NOT sync) — e.g. "what blocks did
+ *  the user open recently on this device". Writes flow through
+ *  `ChangeScope.UiState` so they stay out of the upload queue. */
+export declare const getPluginUIStateBlock: ((repo: Repo, workspaceId: string, user: User, type: TypeContribution) => Promise<Block>) & import("lodash").MemoizedFunction;
+/** Sync selection-state read; doesn't subscribe — for use in
+ *  imperative shortcut handlers. Returns the schema default when
+ *  nothing's stored. */
+export declare const getSelectionStateSnapshot: (uiStateBlock: Block) => BlockSelectionState;
+export declare const resetBlockSelection: (uiStateBlock: Block) => Promise<void>;
+//# sourceMappingURL=stateBlocks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stateBlocks.d.ts","sourceRoot":"","sources":["../../../../../../src/data/stateBlocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EACL,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,gBAAgB,EAErB,KAAK,IAAI,EACV,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAC/C,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAA;AAqC1B,eAAO,MAAM,kBAAkB,GAAI,MAAM,IAAI,EAAE,QAAQ,MAAM,KAAG,MAM/D,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAClC,QAAQ,cAAc,CAAC,CAAC,CAAC,EACzB,OAAO,WAAW,EAClB,QAAQ,MAAM,KACb,cAAc,CAAC,CAAC,CAKlB,CAAA;AAuGD;;;;;;;;wEAQwE;AACxE,eAAO,MAAM,YAAY,UACV,IAAI,eAAe,MAAM,QAAQ,IAAI,KAAG,OAAO,CAAC,KAAK,CAAC,qCAsCpE,CAAA;AAED,eAAO,MAAM,iBAAiB,UACf,IAAI,eAAe,MAAM,QAAQ,IAAI,KAAG,OAAO,CAAC,KAAK,CAAC,qCAKpE,CAAA;AAED;;;;;;;wEAOwE;AACxE,eAAO,MAAM,mBAAmB,UAEtB,IAAI,eACG,MAAM,QACb,IAAI,QACJ,gBAAgB,KACrB,OAAO,CAAC,KAAK,CAAC,qCAclB,CAAA;AAED;;;gEAGgE;AAChE,eAAO,MAAM,eAAe,UAElB,IAAI,eACG,MAAM,QACb,IAAI,WACD,gBAAgB,KACxB,OAAO,CAAC,KAAK,CAAC,qCAWlB,CAAA;AAGD,eAAO,MAAM,qBAAqB,kBACX,KAAK,mBAAmB,MAAM,KAAG,OAAO,CAAC,KAAK,CAAC,qCAKrE,CAAA;AAED;;;;kEAIkE;AAClE,eAAO,MAAM,qBAAqB,UAExB,IAAI,eACG,MAAM,QACb,IAAI,QACJ,gBAAgB,KACrB,OAAO,CAAC,KAAK,CAAC,qCAclB,CAAA;AAID;;wBAEwB;AACxB,eAAO,MAAM,yBAAyB,GAAI,cAAc,KAAK,KAAG,mBACkB,CAAA;AAElF,eAAO,MAAM,mBAAmB,GAAU,cAAc,KAAK,KAAG,OAAO,CAAC,IAAI,CAI3E,CAAA"}

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

@@ -0,0 +1,130 @@
+/**
+ * Target-block primitives for parseReferences + Roam import (spec §7,
+ * §13.1, v4.31).
+ *
+ *   Layer 1 — `createOrRestoreTargetBlock(tx, args)` is the shared
+ *   primitive: SELECT-then-branch via `tx.createOrGet`, restore
+ *   tombstones via `tx.restore`. Same semantics every domain helper
+ *   gets the catch-and-restore boilerplate from. Returns
+ *   `{id, inserted}` where `inserted: true` covers both fresh-insert
+ *   and tombstone-restore (both are "this tx wrote the row").
+ *
+ *   Layer 2 — `ensureAliasTarget` (here) and `ensureDailyNoteTarget`
+ *   (in `@/plugins/daily-notes`) are thin per-domain wrappers. Each
+ *   computes its own deterministic id, picks `freshContent` (the
+ *   alias text — so the freshly-materialised seat renders with a
+ *   non-empty title; steady-state drift after a rename is still
+ *   allowed and healed by the A3 sync rule), and supplies an
+ *   `onInsertedOrRestored` callback that writes the alias list via
+ *   `tx.setProperty`.
+ *   Per-domain also drives the cleanup-eligibility routing in §7.6:
+ *   only ensureAliasTarget results enter the newlyInsertedAliasTargetIds
+ *   list passed to `references.cleanupOrphanAliases` (date-shaped aliases
+ *   never enter the cleanup list — daily notes persist regardless of
+ *   whether a referencing block is removed within 4s).
+ *
+ * Why `tx.createOrGet` doesn't restore on tombstone (v4.26):  Restore
+ * is domain policy. The primitive throws DeletedConflictError loudly
+ * and lets the domain helper decide what fields to refresh. The
+ * shared helper here is the canonical refresh policy for parseReferences
+ * + Roam import.
+ *
+ * Indexed-deterministic seat ids: rather than a single deterministic
+ * id per `(alias, workspaceId)`, alias seats live in a probed sequence
+ * `id₀, id₁, id₂, …` derived from `uuidv5("${ws}:${alias}:${i}",
+ * ALIAS_NS)`. `ensureAliasTarget` walks the sequence until it finds
+ * an empty slot (insert here) or a live row that already claims the
+ * alias (reuse). Live rows that claim a different alias — typical
+ * post-rename case — and tombstones are skipped. Two offline clients
+ * with the same world-state probe the same way and land on the same
+ * slot, preserving the deterministic-id convergence guarantee. The
+ * "claims this alias?" check is what preserves the happy-path
+ * convergence at slot 0; without it the probe would always run past
+ * the existing seat.
+ *
+ * NOTE: `createOrRestoreTargetBlock` is helper-layer, NOT exposed on
+ * the public Tx surface (per v4.31). Plugin authors writing their own
+ * deterministic-id flows can import it from `@/data/targets`.
+ */
+import { type ProcessorReadDb, type Tx, type TypeRegistrySnapshot } from '@/data/api';
+import type { Repo } from '@/data/repo';
+/** Layer 1 args. */
+export interface CreateOrRestoreArgs {
+    id: string;
+    workspaceId: string;
+    parentId: string | null;
+    orderKey: string;
+    /** Applied on both insert and restore. */
+    freshContent: string;
+    /** Optional callback invoked after the row is inserted OR restored
+     *  (NOT on the live-row-hit path). Used by per-domain wrappers to
+     *  write properties (e.g. the alias list via tx.setProperty) that
+     *  need codec encoding. The callback runs synchronously inside the
+     *  outer tx; awaitable. */
+    onInsertedOrRestored?: (tx: Tx, id: string) => Promise<void> | void;
+}
+/** Shared primitive — see file header. Returns `{id, inserted}`;
+ *  `inserted: true` means this tx wrote the row (fresh or restored). */
+export declare const createOrRestoreTargetBlock: (tx: Tx, args: CreateOrRestoreArgs) => Promise<{
+    id: string;
+    inserted: boolean;
+}>;
+/** Deterministic id for the `index`-th alias-seat slot. Slot 0 is the
+ *  happy-path id; higher slots are claimed by probes that skipped a
+ *  live row claiming a different alias (post-rename) or a tombstoned
+ *  prior occupant. Two clients in the same world-state hit the same
+ *  index for a given `(alias, workspaceId)`. */
+export declare const computeAliasSeatId: (alias: string, workspaceId: string, index?: number) => string;
+/** Minimal alias-seat row shape the probe needs. `aliases` is the
+ *  decoded `alias` property; `deleted` is the tombstone flag. */
+export interface AliasSeatRow {
+    deleted: boolean;
+    aliases: readonly string[];
+}
+/** Read function passed to `resolveAliasSeatId`. Returns the row at
+ *  `id` (live or tombstoned) or `null` if no row exists. Concrete
+ *  readers below: `aliasSeatReaderFromTx` (inside ensureAliasTarget,
+ *  honours read-your-own-writes) and `aliasSeatReaderFromDb`
+ *  (read-phase of post-commit processors, hits committed state). */
+export type AliasSeatReader = (id: string) => Promise<AliasSeatRow | null>;
+/** Tx-scoped reader: `tx.get` returns the row including tombstones,
+ *  with codec-encoded properties (we decode the `alias` list here). */
+export declare const aliasSeatReaderFromTx: (tx: Tx) => AliasSeatReader;
+/** Committed-state SQL reader: used by the read phase of post-commit
+ *  processors that don't hold a tx. Reads `deleted` + `properties_json`
+ *  directly. Robust to property-JSON parse errors (returns `[]` so the
+ *  probe treats the slot as "live with different alias" and steps past
+ *  it — same behavior as a normal row that doesn't claim our alias). */
+export declare const aliasSeatReaderFromDb: (db: ProcessorReadDb) => AliasSeatReader;
+/** Walk indexed-deterministic seat slots for `(alias, workspaceId)`
+ *  until one of:
+ *   - empty slot → return that id (caller will insert),
+ *   - live row claiming `alias` → return that id (reuse / convergence).
+ *  Skips tombstones and live rows claiming a different alias.
+ *
+ *  Two clients with the same observed world-state probe the same way
+ *  and land on the same slot — that's the deterministic-id convergence
+ *  guarantee. Clients with divergent state may pick different slots,
+ *  but PowerSync convergence + the alias-lookup query handle this
+ *  case: `block_aliases` is exact-match by alias text, so a second
+ *  parseReferences pass on either client resolves through the lookup
+ *  rather than the probe. */
+export declare const resolveAliasSeatId: (read: AliasSeatReader, alias: string, workspaceId: string) => Promise<string>;
+/** Ensure a stub-block seat exists for `alias` in `workspaceId`. The
+ *  seat is the indexed-deterministic id returned by
+ *  `resolveAliasSeatId` — NOT a canonical id for "the block named
+ *  alias". Callers should always lookup-first (a real block claiming
+ *  the alias has its own id and that's what references should resolve
+ *  to); this helper is only invoked when the lookup misses, to
+ *  materialise the stub the reference will point at. Inserts at
+ *  workspace-root with `content` defaulted to the alias text (so the
+ *  freshly-materialised page renders with the alias as its title
+ *  instead of empty); sets `aliases` property to `[alias]` on
+ *  insert/restore. Steady-state `content !== aliases[0]` is still
+ *  allowed — any rename produces it — this is just the creation-time
+ *  default. Returns `{id, inserted}`. */
+export declare const ensureAliasTarget: (tx: Tx, repo: Repo, alias: string, workspaceId: string, typeSnapshot?: TypeRegistrySnapshot) => Promise<{
+    id: string;
+    inserted: boolean;
+}>;
+//# sourceMappingURL=targets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../../../../../src/data/targets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAGH,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,EAAE,EACP,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAKvC,oBAAoB;AACpB,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAA;IACpB;;;;+BAI2B;IAC3B,oBAAoB,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACpE;AAED;wEACwE;AACxE,eAAO,MAAM,0BAA0B,GACrC,IAAI,EAAE,EACN,MAAM,mBAAmB,KACxB,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAgC3C,CAAA;AAkBD;;;;gDAIgD;AAChD,eAAO,MAAM,kBAAkB,GAC7B,OAAO,MAAM,EACb,aAAa,MAAM,EACnB,QAAO,MAAU,KAChB,MAA8D,CAAA;AAEjE;iEACiE;AACjE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAC3B;AAED;;;;oEAIoE;AACpE,MAAM,MAAM,eAAe,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAA;AAW1E;uEACuE;AACvE,eAAO,MAAM,qBAAqB,GAAI,IAAI,EAAE,KAAG,eAQ5C,CAAA;AAEH;;;;wEAIwE;AACxE,eAAO,MAAM,qBAAqB,GAAI,IAAI,eAAe,KAAG,eAezD,CAAA;AAEH;;;;;;;;;;;;6BAY6B;AAC7B,eAAO,MAAM,kBAAkB,GAC7B,MAAM,eAAe,EACrB,OAAO,MAAM,EACb,aAAa,MAAM,KAClB,OAAO,CAAC,MAAM,CAYhB,CAAA;AAeD;;;;;;;;;;;;yCAYyC;AACzC,eAAO,MAAM,iBAAiB,GAC5B,IAAI,EAAE,EACN,MAAM,IAAI,EACV,OAAO,MAAM,EACb,aAAa,MAAM,EACnB,eAAc,oBAAoD,KACjE,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAa3C,CAAA"}

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

@@ -0,0 +1,136 @@
+/** Extract-type-from-prototype primitives.
+ *
+ *  Three operations user-defined-types Phase 3 composes through:
+ *
+ *  1. `createTypeBlock(repo, args)` — materialize a fresh
+ *     `block-type` block on the workspace's Types page with the
+ *     caller's label + property-schema refList, then wait for
+ *     `UserTypesService` to publish the contribution into the
+ *     `typesFacet` user-data bucket. Returns the new block id, which
+ *     IS the type id (the user-defined-types block-id = type-id rule).
+ *
+ *  2. `retagBlocks(repo, args)` — apply a type to an explicit list of
+ *     block ids inside a single tx. Strict per-row existence checks
+ *     (skips rows that were deleted or moved between caller's query
+ *     and the tx open).
+ *
+ *  3. `findCandidatesByPropertyShape(repo, args)` — query primitive
+ *     for "blocks whose properties bag carries this subset of
+ *     property names, optionally constrained to specific values."
+ *     Built on top of `repo.queryBlocks` — no new index needed.
+ *
+ *  The user-facing "Extract type from this block" flow composes these
+ *  three: the caller (UI) picks the property subset off the prototype,
+ *  calls `createTypeBlock` to materialize a fresh definition, calls
+ *  `findCandidatesByPropertyShape` to surface a candidate list, and
+ *  finally calls `retagBlocks` with the user-confirmed instance ids.
+ *  The orchestration deliberately stays in the UI layer — the
+ *  candidate confirmation step is heuristic and the user is the
+ *  arbiter, so wrapping the three into a single function would force
+ *  every caller through the same confirmation shape. */
+import type { Repo } from '@/data/repo';
+/** Thrown by `createTypeBlock`'s Phase A→bridge handoff when the
+ *  `UserTypesService` subscription doesn't publish the new id into
+ *  `typesFacet`'s user-data bucket within `registrationTimeoutMs`.
+ *  Realistic cause: `tryBuildType` returned null (the block-type
+ *  block failed to parse — e.g. a property-schema ref doesn't
+ *  resolve in the live registry). */
+export declare class TypeRegistrationTimeout extends Error {
+    readonly typeBlockId: string;
+    readonly typeLabel: string;
+    readonly timeoutMs: number;
+    constructor(typeBlockId: string, typeLabel: string, timeoutMs: number);
+}
+export interface CreateTypeBlockArgs {
+    /** Workspace the new type lives in. Determines parent (the
+     *  workspace's Types page) and the registry the new id needs to
+     *  appear in before this function resolves. */
+    workspaceId: string;
+    /** Human label stamped onto `block-type:label`. Required non-empty
+     *  — `UserTypesService.tryBuildType` silently drops a block with
+     *  an empty label, which would surface here as a registration
+     *  timeout instead of a clear pre-tx error. */
+    label: string;
+    /** Property-schema block ids the type's panel section surfaces.
+     *  Each id must resolve to a live property-schema block in the
+     *  same workspace and be published by `UserSchemasService` —
+     *  pre-tx validation enforces both invariants, so a stale ref
+     *  fails fast instead of producing a half-registered type with
+     *  missing slots. */
+    propertySchemaIds: readonly string[];
+    /** Caller cancellation signal. Honored before the tx opens, after
+     *  pre-tx validation reads, and during the bridge wait. */
+    signal?: AbortSignal;
+    /** Bound on the tx-commit → subscription-publish handoff. Default
+     *  10s — long enough to absorb inactive-tab throttling, short
+     *  enough that a genuinely rejected block surfaces within an
+     *  interactive UI window. */
+    registrationTimeoutMs?: number;
+}
+/** Create a fresh `block-type` block on the workspace's Types page.
+ *  Returns the new block id (== type id once registered). The
+ *  returned id is in the live `repo.types` registry by the time the
+ *  promise resolves. */
+export declare function createTypeBlock(repo: Repo, args: CreateTypeBlockArgs): Promise<string>;
+export interface RetagBlocksArgs {
+    /** The type to apply. Must already be registered in `repo.types`. */
+    typeId: string;
+    /** Block ids to tag. Each is re-checked inside the tx — rows that
+     *  were deleted or moved between caller's discovery and tx open
+     *  are silently skipped (no exception). */
+    instanceIds: readonly string[];
+    signal?: AbortSignal;
+}
+/** Apply `typeId` to every block in `instanceIds` in a single tx.
+ *  Idempotent per row: `addTypeInTx` no-ops when the type is already
+ *  present. Throws if `typeId` isn't registered. */
+export declare function retagBlocks(repo: Repo, args: RetagBlocksArgs): Promise<void>;
+export interface PropertyShapeFilter {
+    /** Property name that must be set on the candidate. */
+    name: string;
+    /** Scalar equality filter — the candidate's value at `name` must
+     *  equal `value` (compared via the schema's where-encoder). Mutually
+     *  exclusive with `targetIds`; use for non-ref properties. */
+    value?: unknown;
+    /** Permissive ref / refList match: the candidate's value at `name`
+     *  must reference EVERY id in `targetIds` (i.e. block's refList must
+     *  be a superset). Compiled into one `match` predicate per id, each
+     *  with `referencedBy: {id, sourceField: name}` — multiple ids ANDed.
+     *
+     *  Empty array is treated as no filter (presence-only), same as
+     *  omitting. Mutually exclusive with `value`. */
+    targetIds?: readonly string[];
+}
+export interface FindCandidatesByPropertyShapeArgs {
+    workspaceId: string;
+    /** Property-name set the candidate must carry. ANDed across the
+     *  list — every named property must be set on the candidate. An
+     *  empty array returns every block in the workspace (caller should
+     *  enforce non-empty if that's not desired). */
+    shape: readonly PropertyShapeFilter[];
+    /** Block ids to exclude from the candidate set. Typical use: the
+     *  prototype block the user is extracting FROM (it's already an
+     *  instance-of-itself; surfacing it as a retag candidate is just
+     *  noise). */
+    exclude?: ReadonlyArray<string>;
+    /** Optional candidate cap (defense against pathological matches
+     *  on broad shapes — "every block that has `createdAt` set"
+     *  would otherwise return the entire workspace). Default 1000. */
+    limit?: number;
+}
+/** Find blocks whose property bag carries every name in `shape`,
+ *  optionally constrained by per-property equality / ref-target
+ *  filters. Returns block ids (not full `BlockData`) — callers that
+ *  need the rows can load them via `repo.load`.
+ *
+ *  Filter semantics (per `PropertyShapeFilter`):
+ *   - `value === undefined && (!targetIds || targetIds.length === 0)`:
+ *     presence-only via `where: {[name]: {exists: true}}`.
+ *   - `value` set: scalar equality via `where: {[name]: value}`.
+ *   - `targetIds` non-empty: permissive ref / refList match — compiles
+ *     to one `match` predicate per id with `referencedBy: {id,
+ *     sourceField: name}`. ANDing these means the candidate's ref(List)
+ *     at `name` must be a superset of `targetIds` (block can have
+ *     additional refs). */
+export declare function findCandidatesByPropertyShape(repo: Repo, args: FindCandidatesByPropertyShapeArgs): Promise<readonly string[]>;
+//# sourceMappingURL=typeExtraction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeExtraction.d.ts","sourceRoot":"","sources":["../../../../../../src/data/typeExtraction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDA6BwD;AAcxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAMvC;;;;;qCAKqC;AACrC,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,WAAW,EAAE,MAAM;aACnB,SAAS,EAAE,MAAM;aACjB,SAAS,EAAE,MAAM;gBAFjB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM;CAWpC;AAID,MAAM,WAAW,mBAAmB;IAClC;;mDAE+C;IAC/C,WAAW,EAAE,MAAM,CAAA;IACnB;;;mDAG+C;IAC/C,KAAK,EAAE,MAAM,CAAA;IACb;;;;;yBAKqB;IACrB,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC;+DAC2D;IAC3D,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB;;;iCAG6B;IAC7B,qBAAqB,CAAC,EAAE,MAAM,CAAA;CAC/B;AAED;;;wBAGwB;AACxB,wBAAsB,eAAe,CACnC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,MAAM,CAAC,CAsHjB;AAID,MAAM,WAAW,eAAe;IAC9B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAA;IACd;;+CAE2C;IAC3C,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;oDAEoD;AACpD,wBAAsB,WAAW,CAC/B,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC,CAmDf;AAID,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAA;IACZ;;kEAE8D;IAC9D,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;;;qDAMiD;IACjD,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B;AAED,MAAM,WAAW,iCAAiC;IAChD,WAAW,EAAE,MAAM,CAAA;IACnB;;;oDAGgD;IAChD,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACrC;;;kBAGc;IACd,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC/B;;sEAEkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;;;;;2BAa2B;AAC3B,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,iCAAiC,GACtC,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAmC5B"}

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

@@ -0,0 +1,8 @@
+/** Types-page bootstrap. Thin wrapper around `getOrCreateKernelPage`
+ *  with Types-specific args. Each workspace has one Types page;
+ *  user-defined block-type blocks live as its children. */
+import type { Block } from '@/data/block';
+import type { Repo } from '@/data/repo';
+export declare const typesPageBlockId: (workspaceId: string) => string;
+export declare const getOrCreateTypesPage: (repo: Repo, workspaceId: string) => Promise<Block>;
+//# sourceMappingURL=typesPage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typesPage.d.ts","sourceRoot":"","sources":["../../../../../../src/data/typesPage.ts"],"names":[],"mappings":"AAAA;;2DAE2D;AAE3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAOvC,eAAO,MAAM,gBAAgB,GAAI,aAAa,MAAM,KAAG,MACR,CAAA;AAE/C,eAAO,MAAM,oBAAoB,GAAI,MAAM,IAAI,EAAE,aAAa,MAAM,KAAG,OAAO,CAAC,KAAK,CAKhF,CAAA"}

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

@@ -0,0 +1,7 @@
+/** Stable internal namespace for the deterministic id of the root
+ *  Preferences block. Two clients bootstrapping the same user must
+ *  agree on this so the rows converge on sync. The block's display
+ *  content is set separately to "Preferences" by `ensureUserPrefsChild`;
+ *  the block intentionally carries no type marker. */
+export declare const USER_PREFS_PATH_PART = "user-prefs";
+//# sourceMappingURL=userPrefs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"userPrefs.d.ts","sourceRoot":"","sources":["../../../../../../src/data/userPrefs.ts"],"names":[],"mappings":"AAAA;;;;sDAIsD;AACtD,eAAO,MAAM,oBAAoB,eAAe,CAAA"}

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

@@ -0,0 +1,73 @@
+/** Reactive bridge between user-defined `'property-schema'` blocks and
+ *  the `propertySchemasFacet`'s `'user-data'` runtime contribution
+ *  bucket. See user-defined-properties.md §5 + §7. */
+import { type AnyPropertySchema } from '@/data/api';
+import type { Repo } from '@/data/repo';
+export interface AddSchemaArgs {
+    name: string;
+    presetId: string;
+    /** Caller-supplied config. Runs through `preset.configCodec.decode`
+     *  for validation. Pass `undefined` to fall back to
+     *  `preset.defaultConfig` — `null` is a real (typically invalid)
+     *  value that's passed through to the codec so it can reject. */
+    config?: unknown;
+}
+export declare class UserSchemasService {
+    private readonly repo;
+    /** Single source of truth for the user-data bucket. Both the
+     *  subscription rebuild and `appendUserSchema` assign to this field
+     *  and publish via `setRuntimeContributions`. */
+    private contributions;
+    /** Maps a registered schema's `name` to the property-schema block
+     *  that materialised it. Lets UI surfaces (e.g. the property panel
+     *  glyph button) open the schema block in a panel for in-place
+     *  editing. Built from the same subscription that produces
+     *  `contributions`, so it's always in sync. */
+    private nameToBlockId;
+    /** Reverse of `nameToBlockId`: maps a property-schema block id to
+     *  the schema it resolves to in the runtime bucket. Used by
+     *  `UserTypesService` to resolve `block-type:properties` refList
+     *  entries (which carry block ids) to live schema records without
+     *  peeking the schema block directly — a peek would silently drop
+     *  refs whose row hasn't been hydrated by BlockCache yet. */
+    private blockIdToSchema;
+    /** Active block-subscription disposer, set by `start()`. */
+    private subscriptionDisposer;
+    /** Disposer for the value-preset listener; we re-resolve when
+     *  presets change (a plugin contributing a new preset id makes
+     *  previously-skipped schemas resolvable). */
+    private presetsListenerDisposer;
+    /** Latest blocks list captured by the subscription. Stored so the
+     *  value-preset change path can re-resolve without a fresh DB read. */
+    private latestBlocks;
+    constructor(repo: Repo);
+    /** Look up the property-schema block id for a registered user-data
+     *  schema name. Returns undefined for kernel/plugin schemas (which
+     *  don't have backing blocks) or names that aren't registered. */
+    getSchemaBlockId(name: string): string | undefined;
+    /** Look up the published user-data schema for a property-schema
+     *  block id. Returns undefined for blocks that aren't currently
+     *  materializing a schema — including blocks pending hydration,
+     *  blocks failing `tryBuildSchema` validation (empty name, unknown
+     *  preset, invalid config), and ids that simply don't exist. */
+    getSchemaForBlockId(blockId: string): AnyPropertySchema | undefined;
+    start(): () => void;
+    dispose(): void;
+    /** Validates a schema block against the current presets and returns
+     *  the schema if it parses, or null with a logged diagnostic if not.
+     *  Three skip paths: (1) preset not loaded, (2) name empty,
+     *  (3) configCodec.decode throws. The block stays in the database
+     *  untouched; a fix re-runs this on the next subscription tick. */
+    private tryBuildSchema;
+    /** Synchronously add a user-data schema to the runtime bucket. Used
+     *  by `addSchema` after persisting the schema block — registers
+     *  before any dependent property write so the form's "create-then-
+     *  write-initial-value" flow doesn't race the subscription tick.
+     *  `blockId` is the property-schema block that produced `schema`. */
+    appendUserSchema(schema: AnyPropertySchema, blockId: string): void;
+    /** Create a property-schema block in the workspace's Properties
+     *  page AND register the schema synchronously. Returns the freshly
+     *  registered schema. */
+    addSchema(args: AddSchemaArgs): Promise<AnyPropertySchema>;
+}
+//# sourceMappingURL=userSchemasService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"userSchemasService.d.ts","sourceRoot":"","sources":["../../../../../../src/data/userSchemasService.ts"],"names":[],"mappings":"AAAA;;sDAEsD;AAEtD,OAAO,EAEL,KAAK,iBAAiB,EAGvB,MAAM,YAAY,CAAA;AAEnB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAWvC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB;;;qEAGiE;IACjE,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,qBAAa,kBAAkB;IAiCjB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAhCjC;;qDAEiD;IACjD,OAAO,CAAC,aAAa,CAAmC;IAExD;;;;mDAI+C;IAC/C,OAAO,CAAC,aAAa,CAA4B;IAEjD;;;;;iEAK6D;IAC7D,OAAO,CAAC,eAAe,CAAuC;IAE9D,4DAA4D;IAC5D,OAAO,CAAC,oBAAoB,CAA2B;IAEvD;;kDAE8C;IAC9C,OAAO,CAAC,uBAAuB,CAA4B;IAE3D;2EACuE;IACvE,OAAO,CAAC,YAAY,CAAuB;gBAEd,IAAI,EAAE,IAAI;IAEvC;;sEAEkE;IAClE,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIlD;;;;oEAIgE;IAChE,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAInE,KAAK,IAAI,MAAM,IAAI;IAoDnB,OAAO,IAAI,IAAI;IAOf;;;;uEAImE;IACnE,OAAO,CAAC,cAAc;IA4CtB;;;;yEAIqE;IACrE,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAUlE;;6BAEyB;IACnB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAoEjE"}

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

@@ -0,0 +1,70 @@
+/** Reactive bridge between user-defined `'block-type'` blocks and the
+ *  `typesFacet`'s `'user-data'` runtime contribution bucket
+ *  (user-defined-types Phase 1). Mirrors UserSchemasService in shape:
+ *  subscribe to the meta-type blocks, build TypeContribution[],
+ *  publish through `repo.setRuntimeContributions`. Re-resolves when
+ *  the merged propertySchemas map changes (a newly-published schema
+ *  resolves a previously-dropped block-type:properties ref).
+ *
+ *  Deliberately narrow: NO synchronous-append / withProvisional path.
+ *  See user-defined-types/design.html §Lessons from PR #50 — callers
+ *  that need an in-tx dependent on a freshly-registered type use a
+ *  two-tx flow (commit the type-definition block; wait for the
+ *  subscription rebuild via `repo.onTypesChange`; then open the
+ *  dependent tx). */
+import type { Repo } from '@/data/repo';
+import type { UserSchemasService } from '@/data/userSchemasService';
+export declare class UserTypesService {
+    private readonly repo;
+    private readonly userSchemas;
+    /** Source of truth for the user-data bucket on `typesFacet`. */
+    private contributions;
+    /** Maps a published type id back to the block id that materialised
+     *  it. Phase 1's type-id-IS-block-id decision makes the key and the
+     *  value identical for resolved contributions; the map is kept
+     *  explicit so future UI surfaces (a "navigate to type definition"
+     *  action) read through a stable accessor. */
+    private blockIdByTypeId;
+    /** Active block-subscription disposer, set by `start()`. */
+    private subscriptionDisposer;
+    /** Disposer for the property-schemas listener; we re-resolve when
+     *  the merged schema map changes so a newly-arriving schema makes
+     *  previously-dropped `block-type:properties` refs resolvable. */
+    private schemasListenerDisposer;
+    /** Latest blocks list captured by the subscription. Stored so the
+     *  schema-change re-resolve can run without a fresh DB read. Reset
+     *  on dispose so a stale workspace's blocks don't get republished
+     *  during the cross-workspace handoff. */
+    private latestBlocks;
+    /** True once the workspace-pinned subscription has delivered its
+     *  first tick. Gates the schemas-listener rebuild path: between
+     *  start() and the first subscription emit, `latestBlocks` is
+     *  guaranteed empty (we just reset it in start), but the gate also
+     *  prevents an early onPropertySchemasChange — fired by another
+     *  workspace's userSchemas first publish during the React-effect
+     *  remount sequence — from re-publishing something we don't own
+     *  yet. Reset on dispose. */
+    private subscriptionPrimed;
+    constructor(repo: Repo, userSchemas: UserSchemasService);
+    /** Look up the source block id for a published type id. Returns
+     *  undefined for kernel/plugin types (no backing block) or ids
+     *  that aren't user-data registered. */
+    getTypeBlockId(typeId: string): string | undefined;
+    start(): () => void;
+    dispose(): void;
+    /** Field-wise equality on the contribution list. Element identity
+     *  isn't useful because tryBuildType creates fresh objects per
+     *  rebuild; compare the load-bearing fields and check the properties
+     *  array element-wise (schemas come from UserSchemasService and ARE
+     *  reused across rebuilds, so reference identity is the right check
+     *  there). */
+    private contributionsEqual;
+    /** Build a TypeContribution from a user-authored block-type block.
+     *  Returns null with a logged diagnostic when the label is empty;
+     *  silently drops refList entries that don't resolve through
+     *  `UserSchemasService.getSchemaForBlockId` (those will fill in on
+     *  the next `onPropertySchemasChange` tick when the missing schema
+     *  publishes). */
+    private tryBuildType;
+}
+//# sourceMappingURL=userTypesService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"userTypesService.d.ts","sourceRoot":"","sources":["../../../../../../src/data/userTypesService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;qBAaqB;AAQrB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAWnE,qBAAa,gBAAgB;IAoCzB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,WAAW;IApC9B,gEAAgE;IAChE,OAAO,CAAC,aAAa,CAAkC;IAEvD;;;;kDAI8C;IAC9C,OAAO,CAAC,eAAe,CAA4B;IAEnD,4DAA4D;IAC5D,OAAO,CAAC,oBAAoB,CAA2B;IAEvD;;sEAEkE;IAClE,OAAO,CAAC,uBAAuB,CAA4B;IAE3D;;;8CAG0C;IAC1C,OAAO,CAAC,YAAY,CAAuB;IAE3C;;;;;;;iCAO6B;IAC7B,OAAO,CAAC,kBAAkB,CAAQ;gBAGf,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,kBAAkB;IAGlD;;4CAEwC;IACxC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIlD,KAAK,IAAI,MAAM,IAAI;IAkEnB,OAAO,IAAI,IAAI;IAiBf;;;;;kBAKc;IACd,OAAO,CAAC,kBAAkB;IAmB1B;;;;;sBAKkB;IAClB,OAAO,CAAC,YAAY;CAqBrB"}

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

@@ -0,0 +1,49 @@
+import type { PendingStatementParameter } from '@powersync/web';
+import type { Workspace, WorkspaceMembership } from '@/types';
+type ColumnDef = {
+    readonly name: string;
+    readonly definition: string;
+};
+export interface WorkspaceRow {
+    id: string;
+    name: string;
+    owner_user_id: string;
+    create_time: number;
+    update_time: number;
+}
+export declare const WORKSPACE_COLUMNS: readonly ColumnDef[];
+export declare const CREATE_WORKSPACES_TABLE_SQL: string;
+export declare const WORKSPACES_RAW_TABLE: {
+    put: {
+        sql: string;
+        params: PendingStatementParameter[];
+    };
+    delete: {
+        sql: string;
+        params: "Id"[];
+    };
+};
+export declare const parseWorkspaceRow: (row: WorkspaceRow) => Workspace;
+export interface WorkspaceMemberRow {
+    id: string;
+    workspace_id: string;
+    user_id: string;
+    role: string;
+    create_time: number;
+}
+export declare const WORKSPACE_MEMBER_COLUMNS: readonly ColumnDef[];
+export declare const CREATE_WORKSPACE_MEMBERS_TABLE_SQL: string;
+export declare const CREATE_WORKSPACE_MEMBERS_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_workspace_members_user_id\n  ON workspace_members (user_id)\n";
+export declare const WORKSPACE_MEMBERS_RAW_TABLE: {
+    put: {
+        sql: string;
+        params: PendingStatementParameter[];
+    };
+    delete: {
+        sql: string;
+        params: "Id"[];
+    };
+};
+export declare const parseWorkspaceMemberRow: (row: WorkspaceMemberRow) => WorkspaceMembership;
+export {};
+//# sourceMappingURL=workspaceSchema.d.ts.map