@knowledge-medium/agent-cli 0.1.0

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

@@ -0,0 +1,90 @@
+import type { ComponentType, JSX } from 'react';
+import type { Codec } from './codecs';
+import type { ChangeScope } from './changeScope';
+/** Data-layer schema. Pure data — usable from non-React surfaces (server,
+ *  CLI, headless tests, future non-React UIs). React presentation lives
+ *  separately: most properties pick up an editor from a future
+ *  ValuePreset (codec-type → editor) and never need anything more.
+ *  Per-name *outlier* overrides — type-aware autocompletes, singleton
+ *  config editors, hidden kernel-internal state — go on
+ *  `PropertyEditorOverride<T>` (joined to schemas by `name`). See spec §5.6. */
+export interface PropertySchema<T> {
+    readonly name: string;
+    /** Storage codec; runs at the four boundary call sites only. */
+    readonly codec: Codec<T>;
+    readonly defaultValue: T;
+    readonly changeScope: ChangeScope;
+}
+/** Per-name override for the rare property whose presentation can't be
+ *  derived from its codec type plus a ValuePreset. Joined to a registered
+ *  `PropertySchema` by `name` at render time.
+ *
+ *  Reach for this only when one of:
+ *    - the property needs a type-aware editor that isn't a value-type
+ *      concept (e.g. block-types autocomplete on `types`),
+ *    - the property is a singleton with its own config editor,
+ *    - the property is internal kernel state and should be `hidden`.
+ *
+ *  Most properties don't need an override — leave them alone and the
+ *  codec/preset chain renders them. See spec §5.6 + §6. */
+export interface PropertyEditorOverride<T = unknown> {
+    /** Must match a registered `PropertySchema.name`. Multiple overrides
+     *  for the same name log a warning and last-wins (facet convention). */
+    readonly name: string;
+    /** Display name (defaults to `name` when absent). */
+    readonly label?: string;
+    /** Hide from the normal property panel. Hidden rows can still be
+     *  revealed in the debug/metadata section; this affects placement and
+     *  destructive capabilities, not value editability. */
+    readonly hidden?: boolean;
+    readonly Editor?: PropertyEditor<T>;
+    /** Optional per-name glyph override. Defaults to the matching
+     *  `ValuePreset.Glyph` when absent. Use sparingly — most properties
+     *  pick up the codec-type-keyed glyph from the preset and don't
+     *  need a per-name shape. See user-defined-properties §1-ui. */
+    readonly Glyph?: ComponentType<{
+        className?: string;
+    }>;
+}
+export interface PropertyEditorProps<T> {
+    value: T;
+    onChange: (next: T) => void;
+    /** Schema being edited. Present for schema-backed property panel
+     *  renderers; optional so older UI contributions that only need
+     *  value/onChange/block keep their existing shape. */
+    schema?: PropertySchema<T>;
+    /** The block being edited. Type kept loose here so the data-layer api
+     *  module doesn't need to import the `Block` facade (defined in
+     *  `src/data/block.ts`). UI consumers narrow at the call site. */
+    block: unknown;
+}
+export type PropertyEditor<T> = (props: PropertyEditorProps<T>) => JSX.Element;
+/** Plugin-augmentable type registry for property schemas — mirrors
+ *  `MutatorRegistry` and `QueryRegistry`. Static plugins augment via
+ *  `declare module '@/data/api'`; dynamic plugins use string-keyed access. */
+/** Plugin-augmentable type registry. Empty body is intentional —
+ *  declaration merging requires interface. */
+export interface PropertySchemaRegistry {
+}
+export interface PropertyEditorOverrideRegistry {
+}
+/** Helper for plugin authors to define a schema with full type inference
+ *  on `defaultValue`. */
+export declare const defineProperty: <T>(name: string, schema: Omit<PropertySchema<T>, "name">) => PropertySchema<T>;
+/** Helper for the rare property that needs a per-name editor override.
+ *  Most plugins should NOT reach for this — registering an override is
+ *  the outlier path. The common path is a codec-type-based ValuePreset. */
+export declare const definePropertyEditorOverride: <T>(override: PropertyEditorOverride<T>) => PropertyEditorOverride<T>;
+/** Variance-erased schema type for storage in heterogeneous collections
+ *  (`propertySchemasFacet`'s contributions, etc.). `PropertySchema<T>`
+ *  is invariant in `T` through `defaultValue` and `codec`, so typed
+ *  plugin schemas can't widen to `PropertySchema<unknown>`. The `any`
+ *  escape mirrors `AnyMutator` / `AnyPostCommitProcessor`. */
+export type AnyPropertySchema = PropertySchema<any>;
+/** Variance-erased editor-override type for storage in
+ *  `propertyEditorOverridesFacet`'s contributions. `PropertyEditor<T>` is
+ *  contravariant in `T` (it accepts `value: T`), so typed plugin
+ *  overrides can't widen to `PropertyEditorOverride<unknown>`. Same
+ *  `any`-escape pattern. */
+export type AnyPropertyEditorOverride = PropertyEditorOverride<any>;
+//# sourceMappingURL=propertySchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"propertySchema.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/propertySchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEhD;;;;;;gFAMgF;AAChF,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAClC;AAED;;;;;;;;;;;2DAW2D;AAC3D,MAAM,WAAW,sBAAsB,CAAC,CAAC,GAAG,OAAO;IACjD;4EACwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,qDAAqD;IACrD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB;;2DAEuD;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAA;IACnC;;;oEAGgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CACrD;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,KAAK,EAAE,CAAC,CAAA;IACR,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAA;IAC3B;;0DAEsD;IACtD,MAAM,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAA;IAC1B;;sEAEkE;IAClE,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,OAAO,CAAA;AAE9E;;8EAE8E;AAC9E;8CAC8C;AAE9C,MAAM,WAAW,sBAAsB;CAA+B;AAGtE,MAAM,WAAW,8BAA8B;CAA+B;AAE9E;yBACyB;AACzB,eAAO,MAAM,cAAc,GAAI,CAAC,EAC9B,MAAM,MAAM,EACZ,QAAQ,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,KACtC,cAAc,CAAC,CAAC,CAA0B,CAAA;AAE7C;;2EAE2E;AAC3E,eAAO,MAAM,4BAA4B,GAAI,CAAC,EAC5C,UAAU,sBAAsB,CAAC,CAAC,CAAC,KAClC,sBAAsB,CAAC,CAAC,CAAa,CAAA;AAExC;;;;8DAI8D;AAE9D,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,GAAG,CAAC,CAAA;AAEnD;;;;4BAI4B;AAE5B,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC,GAAG,CAAC,CAAA"}

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

@@ -0,0 +1,81 @@
+import type { Schema } from './schema';
+import type { BlockData } from './blockData';
+import type { Repo } from '../repo';
+/** A dependency a query declares while resolving. Drives invalidation
+ *  matching (§9.2). Built-in queries declare these from their `resolve`
+ *  bodies (e.g. `parent-edge` for tree handles, `row` for everything
+ *  visited). Plugin queries do the same.
+ *
+ *  Plugin queries can declare channel/key dependencies through
+ *  `{kind:'plugin', channel, key}`. Plugin-owned invalidation rules emit
+ *  matching channel/key changes after tx commits and sync-applied row
+ *  events, keeping feature-specific invalidation logic out of core.
+ */
+export type Dependency = {
+    kind: 'row';
+    id: string;
+} | {
+    kind: 'parent-edge';
+    parentId: string;
+} | {
+    kind: 'workspace';
+    workspaceId: string;
+} | {
+    kind: 'table';
+    table: string;
+} | {
+    kind: 'plugin';
+    channel: string;
+    key: string;
+};
+/** Read-only SQL surface available to a query resolver. Sees committed
+ *  state at resolve time. Intentionally narrower than `PowerSyncDatabase`
+ *  — no `execute`, no `writeTransaction` — so the type prevents
+ *  accidental writes through this handle. */
+export interface QueryReadDb {
+    getOptional<T>(sql: string, params?: unknown[]): Promise<T | null>;
+    getAll<T>(sql: string, params?: unknown[]): Promise<T[]>;
+    get<T>(sql: string, params?: unknown[]): Promise<T>;
+}
+/** Resolver context. `db` is the committed-state read surface; writes
+ *  through `db` are unsupported. `repo` is the owning Repo instance for
+ *  composing existing query/read surfaces when a resolver needs them. */
+export interface QueryCtx {
+    /** Raw SQL reads against committed state. The narrow shape is
+     *  deliberate: `.execute()` / `.writeTransaction()` are absent. */
+    db: QueryReadDb;
+    repo: Repo;
+    /** Hydrate full block rows into the cache and declare row deps on
+     *  them. Use when the query result contains those row bodies. */
+    hydrateBlocks(rows: ReadonlyArray<Record<string, unknown>>): BlockData[];
+    /** Prime block rows into the cache without declaring row deps. Use
+     *  when rows are fetched only as a cache-warming side effect, such as
+     *  id-list queries whose result depends only on parent edges. */
+    primeBlocks(rows: ReadonlyArray<Record<string, unknown>>): BlockData[];
+    /** Declare a dependency; engine uses these to invalidate this handle. */
+    depend(dep: Dependency): void;
+}
+export interface Query<Args, Result> {
+    readonly name: string;
+    readonly argsSchema: Schema<Args>;
+    readonly resultSchema: Schema<Result>;
+    readonly resolve: (args: Args, ctx: QueryCtx) => Promise<Result>;
+}
+/** Plugin-augmentable type registry. Empty by design so plugin authors
+ *  can layer in members from their own module via declaration merging. */
+export interface QueryRegistry {
+}
+/** Variance-erased query type for storage in heterogeneous collections
+ *  (the engine's query registry, `queriesFacet`'s contributions, etc).
+ *
+ *  Same rationale as `AnyMutator`: `Query<Args, Result>` is contravariant
+ *  in `Args` (the resolver's args parameter) and so a typed plugin
+ *  query can't be assigned to `Query<unknown, unknown>` under
+ *  `strictFunctionTypes`. The conventional escape is `any`, which opts
+ *  out of variance for the registry slot while keeping per-query types
+ *  intact at definition sites. Concrete callers (`repo.query.X`,
+ *  `repo.runQuery('name', ...)`) recover precise types via the
+ *  `QueryRegistry` augmentation. */
+export type AnyQuery = Query<any, any>;
+export declare const defineQuery: <Args, Result>(query: Query<Args, Result>) => Query<Args, Result>;
+//# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAI5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpD;;;6CAG6C;AAC7C,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;IAClE,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAA;IACxD,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CACpD;AAED;;yEAEyE;AACzE,MAAM,WAAW,QAAQ;IACvB;uEACmE;IACnE,EAAE,EAAE,WAAW,CAAA;IACf,IAAI,EAAE,IAAI,CAAA;IACV;qEACiE;IACjE,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,CAAA;IACxE;;qEAEiE;IACjE,WAAW,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,CAAA;IACtE,yEAAyE;IACzE,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAC9B;AAED,MAAM,WAAW,KAAK,CAAC,IAAI,EAAE,MAAM;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CACjE;AAED;0EAC0E;AAE1E,MAAM,WAAW,aAAa;CAA+B;AAE7D;;;;;;;;;;oCAUoC;AAEpC,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAEtC,eAAO,MAAM,WAAW,GAAI,IAAI,EAAE,MAAM,EACtC,OAAO,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,KACzB,KAAK,CAAC,IAAI,EAAE,MAAM,CAAU,CAAA"}

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

@@ -0,0 +1,112 @@
+/**
+ * Same-tx processor framework (reintroduces the mode that v4.20 of
+ * the data-layer redesign dropped — see `docs/data-layer-redesign.md`
+ * §16.2 and §7.1).
+ *
+ * Same-tx vs post-commit, in one line: same-tx fires INSIDE the
+ * user's `writeTransaction` after `fn` returns but before commit;
+ * post-commit fires AFTER `repo.tx` resolves, in its own tx.
+ *
+ * What same-tx is for: cheap, correctness-critical, single-row work
+ * that must commit atomically with the originating tx — e.g.
+ * reference-array normalization (currently inline in `txEngine.ts`)
+ * and alias sync (content↔aliases reconciliation + alias-collision
+ * rejection). Latency added here is paid by the user-commit path, so
+ * it has to stay cheap.
+ *
+ * What same-tx is NOT for: expensive enrichment (parseReferences),
+ * cross-row writes (rename rewriting backlinks across many sources),
+ * delayed cleanup. Those stay post-commit per §7.1.
+ *
+ * Capabilities of `apply`:
+ *   - Reads via `ctx.tx` — sees the live staged state of the user's
+ *     tx, including writes by the user fn and writes from any
+ *     same-tx processor that ran earlier in this pipeline pass.
+ *   - Writes via `ctx.tx.update/setProperty/etc` — amends the user's
+ *     tx; snapshot.after updates in place; the undo entry recorded
+ *     for the user's tx captures these amendments alongside the
+ *     user's own writes (one user undo step covers everything).
+ *   - Rejects via `throw new ProcessorRejection(...)` — the user's
+ *     `writeTransaction` rolls back atomically; no rows committed,
+ *     no snapshots recorded, no undo entry created.
+ *
+ * Ordering: registration order (the facet preserves insertion
+ * order). Single pass — same-tx processors do NOT re-fire on
+ * amendments by other same-tx processors in the same pipeline pass.
+ * Each processor's `changedRows` is recomputed from the live
+ * snapshots before its `apply` runs, so a later processor sees an
+ * earlier processor's writes; this is one-way, not fixpoint.
+ *
+ * Re-fire on post-commit: same as today — when a same-tx amendment
+ * touches a watched field, the field-watch dispatch at the
+ * post-commit stage sees the amended `after` and fires post-commit
+ * processors accordingly.
+ */
+import type { BlockData } from './blockData';
+import type { AnyPropertySchema } from './propertySchema';
+import type { ChangeScope } from './changeScope';
+import type { ChangedRow } from './processor';
+import type { Tx } from './tx';
+import type { User } from './user';
+/** Plugin-augmentable registry for same-tx processor names → typed
+ *  metadata. Mirrors `PostCommitProcessorRegistry` for parity even
+ *  though same-tx has no `scheduledArgs` channel today. */
+export interface SameTxProcessorRegistry {
+}
+export type SameTxProcessor = {
+    readonly name: string;
+    /** Same-tx processors only support `kind: 'field'` (there is no
+     *  explicit / afterCommit channel — that's a post-commit-only
+     *  concept since the user fn can't schedule into its own
+     *  pre-commit phase). */
+    readonly watches: {
+        kind: 'field';
+        table: 'blocks';
+        fields: ReadonlyArray<keyof BlockData>;
+    };
+    readonly apply: (event: SameTxEvent, ctx: SameTxCtx) => Promise<void>;
+};
+export interface SameTxEvent {
+    txId: string;
+    scope: ChangeScope;
+    user: User;
+    /** Always a string for same-tx processors — they only fire after
+     *  the user fn made at least one write (otherwise the watch can't
+     *  have matched), so workspace pinning is already settled. */
+    workspaceId: string;
+    /** Rows whose staged writes touched a watched field. `before` is
+     *  the pre-tx state (or null for inserts); `after` is the live
+     *  staged value at the moment this processor fires (includes
+     *  amendments by earlier same-tx processors in this pass). */
+    changedRows: ChangedRow[];
+}
+export interface SameTxCtx {
+    /** Active `Tx` — same handle the user fn used. Reads see staged
+     *  state; writes amend the same tx. Throws here roll back the
+     *  whole user tx via SQLite's `writeTransaction` abort. */
+    tx: Tx;
+    /** Merged property-schema registry snapshotted at tx start. */
+    propertySchemas: ReadonlyMap<string, AnyPropertySchema>;
+}
+/** Thrown by a same-tx processor to reject the user's tx. The
+ *  SQLite `writeTransaction` aborts; the error bubbles out of
+ *  `repo.tx` to the caller. Top-level handlers (editor save, chip
+ *  edit, command palette) catch this and surface the error via the
+ *  toast layer using `code` + `meta` to format the message.
+ *
+ *  Distinct error class so callers can `if (err instanceof
+ *  ProcessorRejection)` without parsing messages. `code` is a
+ *  stable string like `'alias.collision'` for routing to the right
+ *  UI affordance. `meta` carries structured detail the toast can
+ *  use for action buttons / formatted messages. */
+export declare class ProcessorRejection extends Error {
+    readonly code: string;
+    readonly meta?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, meta?: Record<string, unknown> | undefined);
+}
+export declare const defineSameTxProcessor: (processor: SameTxProcessor) => SameTxProcessor;
+/** Variance-erased same-tx processor type for heterogeneous
+ *  collections (the engine's facet registry). Parallel to
+ *  `AnyPostCommitProcessor`. */
+export type AnySameTxProcessor = SameTxProcessor;
+//# sourceMappingURL=sameTxProcessor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sameTxProcessor.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/sameTxProcessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,MAAM,CAAA;AAC9B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC;;2DAE2D;AAE3D,MAAM,WAAW,uBAAuB;CAAkC;AAE1E,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;6BAGyB;IACzB,QAAQ,CAAC,OAAO,EAAE;QAChB,IAAI,EAAE,OAAO,CAAA;QACb,KAAK,EAAE,QAAQ,CAAA;QACf,MAAM,EAAE,aAAa,CAAC,MAAM,SAAS,CAAC,CAAA;KACvC,CAAA;IACD,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACtE,CAAA;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,WAAW,CAAA;IAClB,IAAI,EAAE,IAAI,CAAA;IACV;;kEAE8D;IAC9D,WAAW,EAAE,MAAM,CAAA;IACnB;;;kEAG8D;IAC9D,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,SAAS;IACxB;;+DAE2D;IAC3D,EAAE,EAAE,EAAE,CAAA;IACN,+DAA+D;IAC/D,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;CACxD;AAED;;;;;;;;;;mDAUmD;AACnD,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,IAAI,EAAE,MAAM;aACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAF9C,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAKjD;AAED,eAAO,MAAM,qBAAqB,GAChC,WAAW,eAAe,KACzB,eAA4B,CAAA;AAE/B;;gCAEgC;AAChC,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAA"}

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

@@ -0,0 +1,8 @@
+/** Boundary-validation schema. zod schemas conform to this structurally
+ *  (`{ parse(input: unknown): T }`); plugins pick zod or any compatible
+ *  validator (Valibot, Effect Schema). The data layer never needs zod's
+ *  full surface — it only ever calls `.parse()`. */
+export interface Schema<T> {
+    parse(input: unknown): T;
+}
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/schema.ts"],"names":[],"mappings":"AAAA;;;oDAGoD;AACpD,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAA;CACzB"}

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

@@ -0,0 +1,142 @@
+import type { BlockData, BlockDataPatch, NewBlockData } from './blockData';
+import type { ChangeScope, TxSource } from './changeScope';
+import type { PropertySchema } from './propertySchema';
+import type { User } from './user';
+/** Per-write opt: skip the engine's automatic `updatedAt`/`updatedBy` bump
+ *  (and `createdAt`/`createdBy` on `tx.create`). Used by bookkeeping writes
+ *  whose state isn't user intent — e.g. parseReferences updating
+ *  `references`. User-facing mutators should not set this. */
+export interface TxWriteOpts {
+    skipMetadata?: boolean;
+}
+/** Tx metadata exposed to mutators / processor `apply` bodies.
+ *  - `txId` — uuid for this tx; written into `command_events.tx_id` and
+ *    every `row_events.tx_id` for this tx.
+ *  - `workspaceId` — pinned by the first write in the tx (see the
+ *    single-workspace invariant in §5.3); `null` until the first write
+ *    lands. `tx.afterCommit` throws `WorkspaceNotPinnedError` if called
+ *    before that. */
+export interface TxMeta {
+    description?: string;
+    scope: ChangeScope;
+    user: User;
+    txId: string;
+    source: TxSource;
+    workspaceId: string | null;
+}
+/** Forward declarations — these come from `mutator.ts` / `processor.ts`
+ *  but are referenced by the Tx interface. */
+import type { Mutator } from './mutator';
+import type { ScheduledArgsFor } from './processor';
+/** Transactional session. Async reads, no arbitrary queries. Spec §5.3. */
+export interface Tx {
+    /** Read with read-your-own-writes. Runs inside `db.writeTransaction`,
+     *  so SQL natively sees writes already issued by this tx. Returns null
+     *  for missing rows. */
+    get(id: string): Promise<BlockData | null>;
+    /** Sync read: tx-private snapshots map first (own writes in this tx),
+     *  then the shared (pre-tx) cache. Returns null if neither has it.
+     *  The shared cache is mutated only on commit walk (v4.24), so
+     *  outside-tx readers never observe in-flight tx state. */
+    peek(id: string): BlockData | null;
+    /** Insert a new block. Throws `DuplicateIdError` on PK conflict.
+     *  The engine preflights non-null parents and throws
+     *  `ParentNotFoundError` / `ParentWorkspaceMismatchError` before the
+     *  storage trigger's collapsed parent/workspace constraint can surface.
+     *  Soft-deleted-parent is a kernel-mutator UX rule and does NOT fire on
+     *  raw `tx.create` — see §4.7 Layer 1 (v4.30). */
+    create(data: NewBlockData, opts?: TxWriteOpts): Promise<string>;
+    /** Insert OR fetch the live row at a deterministic id. **No tombstone
+     *  resurrection in the primitive** — see §10.4. Throws
+     *  `DeterministicIdCrossWorkspaceError` if the existing row is in a
+     *  different workspace; throws `DeletedConflictError` if the existing
+     *  row is soft-deleted. The shared `createOrRestoreTargetBlock` helper
+     *  (§7, §13.1) catches `DeletedConflictError` and runs `tx.restore`.
+     *  The insert path uses the same parent preflight as `tx.create`. */
+    createOrGet(data: NewBlockData & {
+        id: string;
+    }, opts?: TxWriteOpts): Promise<{
+        id: string;
+        inserted: boolean;
+    }>;
+    /** Soft-delete: sets `deleted = 1`. Fires the UPDATE trigger; row_events
+     *  is emitted with `kind = 'soft-delete'` (see §4.3). */
+    delete(id: string): Promise<void>;
+    /** Un-soft-delete a tombstoned row, optionally with a fresh data-field
+     *  patch in the same UPDATE. Throws `BlockNotFoundError` if missing or
+     *  `NotDeletedError` if already live. Used by
+     *  `createOrRestoreTargetBlock` to recover from `DeletedConflictError`. */
+    restore(id: string, patch?: BlockDataPatch, opts?: TxWriteOpts): Promise<void>;
+    /** Update non-structural data fields only (`content` / `references` /
+     *  `properties`). Structural mutations have their own primitives. The
+     *  patch type excludes `parentId`, `orderKey`, `workspaceId`, `deleted`,
+     *  and metadata fields at the type level. */
+    update(id: string, patch: BlockDataPatch, opts?: TxWriteOpts): Promise<void>;
+    /** Move a row to a new `(parentId, orderKey)`. For non-null parents the
+     *  engine first throws `ParentNotFoundError` /
+     *  `ParentWorkspaceMismatchError` when the target parent is invalid, then
+     *  runs `isDescendantOf(target.parentId, id)` and throws `CycleError` if
+     *  the new parent would be a descendant of `id` — load-bearing because FK
+     *  and triggers can't structurally catch cycles. `target.parentId = null`
+     *  re-roots the row (workspace root). */
+    move(id: string, target: {
+        parentId: string | null;
+        orderKey: string;
+    }, opts?: TxWriteOpts): Promise<void>;
+    /** `setProperty`: applies `codec.encode`, merges into the row's
+     *  `properties` map, and writes through immediately. Bypassing codecs
+     *  (raw `properties` writes) goes through `tx.update`. */
+    setProperty<T>(id: string, schema: PropertySchema<T>, value: T, opts?: TxWriteOpts): Promise<void>;
+    /** `getProperty`: reads SQL/cache and applies `codec.decode`. Returns
+     *  the schema's `defaultValue` if the property is absent. */
+    getProperty<T>(id: string, schema: PropertySchema<T>): Promise<T>;
+    /** Compose another mutator. Sub-mutator's writes go through immediately;
+     *  the parent's subsequent reads see them via SQL (read-your-own-writes
+     *  inside the writeTransaction). No overlay arithmetic. */
+    run<Args, R>(mutator: Mutator<Args, R>, args: Args): Promise<R>;
+    /** Children of `parentId`, ordered `(order_key, id)`, filtered
+     *  `deleted = 0`. Reads SQL via the writeTransaction.
+     *  Pass `null` to enumerate workspace-root rows (rows with
+     *  `parent_id IS NULL`); the result is scoped to a workspace by
+     *  one of three sources, in priority order:
+     *    1. explicit `workspaceId` argument (use this when the tx
+     *       hasn't pinned a workspace yet and you know the right one
+     *       from a sibling/parent row you already read);
+     *    2. the tx's pinned workspace (`tx.meta.workspaceId`) when set;
+     *    3. throws `WorkspaceNotPinnedError` otherwise — returning
+     *       cross-workspace rows is never safe for sibling-position
+     *       computation.
+     *  When `parentId !== null`, `workspaceId` is ignored — the parent
+     *  row already constrains the query. */
+    childrenOf(parentId: string | null, workspaceId?: string): Promise<BlockData[]>;
+    /** Parent of `childId`, or null if `childId` has no parent or doesn't
+     *  exist. Reads SQL via the writeTransaction. */
+    parentOf(childId: string): Promise<BlockData | null>;
+    /** Look up the live block in `workspaceId` whose `aliases` property
+     *  contains the exact `alias` text. Returns null when no such block
+     *  exists. Tx-aware version of the kernel `core.aliasLookup` query;
+     *  sees this tx's own writes via the writeTransaction.
+     *
+     *  Reads through the trigger-maintained `block_aliases` side index
+     *  (clientSchema.ts) — exact match via `idx_block_aliases_ws_alias`.
+     *  V1 enforces `(workspace_id, alias)` uniqueness for local writes
+     *  via the `block_aliases_workspace_alias_unique` trigger, so this
+     *  lookup typically resolves to a single row; the SQL's
+     *  `ORDER BY created_at LIMIT 1` is a defense-in-depth tie-break
+     *  for the sync-apply path that can still race-land duplicates
+     *  from other clients. */
+    aliasLookup(alias: string, workspaceId: string): Promise<BlockData | null>;
+    /** Schedule a follow-up post-commit job. Runs in its own
+     *  writeTransaction after this tx commits; does NOT run if the tx
+     *  rolls back. Throws `WorkspaceNotPinnedError` if no write has
+     *  happened yet in this tx (so `meta.workspaceId` is still null). */
+    afterCommit<P extends string>(processorName: P, args: ScheduledArgsFor<P>, options?: {
+        delayMs?: number;
+    }): void;
+    readonly meta: TxMeta;
+}
+export interface RepoTxOptions {
+    scope: ChangeScope;
+    description?: string;
+}
+//# sourceMappingURL=tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,YAAY,EACb,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC;;;8DAG8D;AAC9D,MAAM,WAAW,WAAW;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED;;;;;;qBAMqB;AACrB,MAAM,WAAW,MAAM;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,WAAW,CAAA;IAClB,IAAI,EAAE,IAAI,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,QAAQ,CAAA;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B;AAED;8CAC8C;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,2EAA2E;AAC3E,MAAM,WAAW,EAAE;IAGjB;;4BAEwB;IACxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;IAE1C;;;+DAG2D;IAC3D,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;IAIlC;;;;;sDAKkD;IAClD,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAE/D;;;;;;yEAMqE;IACrE,WAAW,CACT,IAAI,EAAE,YAAY,GAAG;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EACnC,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;IAE7C;6DACyD;IACzD,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEjC;;;+EAG2E;IAC3E,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAI9E;;;iDAG6C;IAC7C,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAI5E;;;;;;6CAMyC;IACzC,IAAI,CACF,EAAE,EAAE,MAAM,EACV,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EACrD,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CAAA;IAIhB;;8DAE0D;IAC1D,WAAW,CAAC,CAAC,EACX,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,KAAK,EAAE,CAAC,EACR,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhB;iEAC6D;IAC7D,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAIjE;;+DAE2D;IAC3D,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAI/D;;;;;;;;;;;;;4CAawC;IACxC,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAA;IAE/E;qDACiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;IAEpD;;;;;;;;;;;;8BAY0B;IAC1B,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;IAI1E;;;yEAGqE;IACrE,WAAW,CAAC,CAAC,SAAS,MAAM,EAC1B,aAAa,EAAE,CAAC,EAChB,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,EACzB,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAC7B,IAAI,CAAA;IAEP,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB"}

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

@@ -0,0 +1,115 @@
+export interface TypedBlockQueryReferenceFilter {
+    readonly id: string;
+    readonly sourceField?: string;
+}
+/** Operator object accepted inside `BlockPredicate.where[name]`. The
+ *  scalar/null shorthand still works: a bare value compiles as
+ *  equality, `null` compiles as `IS NULL`. The object form is needed
+ *  for everything else.
+ *
+ *  Exactly one operator key per object — multiple keys would force an
+ *  AND-vs-OR interpretation that's better expressed by combining
+ *  predicates in `match` / `exclude`. The runtime parser rejects
+ *  multi-key objects to keep the surface unambiguous.
+ *
+ *  Operand types: each scalar operand goes through `codec.where.encode`
+ *  the same way scalar shorthand does, so `{ lt: new Date('2026-01-01') }`
+ *  on a date-codec property and `{ gt: 5 }` on a number-codec property
+ *  validate identically to their equality-form counterparts. `between`
+ *  is inclusive on both ends. `exists` takes a boolean — `true` for
+ *  "property is set" (`IS NOT NULL`), `false` for "unset" (`IS NULL`,
+ *  same as the `null` shorthand).
+ *
+ *  `target` is the ref-traversal operator. Valid only on `ref`-typed
+ *  (and `refList`-typed) properties; the operand is an inner where-map
+ *  compiled against the referenced block's `properties_json`. Lets
+ *  callers ask "this ref points to a block whose <inner where> holds"
+ *  without bouncing through `referencedBy`, which only knows equality
+ *  on the target id. Example — find blocks whose `next-review-date`
+ *  ref points to a daily note whose `daily-note:date` is in the past:
+ *
+ *    where: {
+ *      'next-review-date': {
+ *        target: { 'daily-note:date': { lt: new Date() } }
+ *      }
+ *    }
+ *
+ *  The compiler stays plugin-agnostic — it doesn't know about
+ *  daily-notes; the caller (typically UI) spells the target property
+ *  name. */
+export type WhereOperator = {
+    readonly eq: unknown;
+} | {
+    readonly lt: unknown;
+} | {
+    readonly lte: unknown;
+} | {
+    readonly gt: unknown;
+} | {
+    readonly gte: unknown;
+} | {
+    readonly between: readonly [unknown, unknown];
+} | {
+    readonly exists: boolean;
+} | {
+    readonly target: Readonly<Record<string, unknown>>;
+};
+/** A single block predicate. Compiled against either the block itself
+ *  (`scope: 'self'`, default) or the block-or-any-of-its-ancestors
+ *  (`scope: 'ancestor'`). All sub-fields within one predicate AND
+ *  together. Multiple predicates AND across in `match`, NOR across in
+ *  `exclude`.
+ *
+ *  The `id` field is the "block has this id" primitive. Useful with
+ *  ancestor scope to filter for "block is contained in page X" without
+ *  requiring X to be referenced — e.g. backlinks-on-a-daily-note
+ *  filtering by which page their context lives in.
+ *
+ *  `where[name]` values: scalar (equality), `null` (unset), or a
+ *  `WhereOperator` object (`{ lt: v }`, `{ exists: true }`, etc.). See
+ *  the `WhereOperator` doc for the operand contract. */
+export interface BlockPredicate {
+    readonly scope?: 'self' | 'ancestor';
+    readonly id?: string;
+    readonly where?: Readonly<Record<string, unknown>>;
+    readonly referencedBy?: TypedBlockQueryReferenceFilter;
+}
+export interface TypedBlockQuery {
+    /** Required. Callers that want the user's currently-active workspace
+     *  use `repo.queryActiveWorkspace` / `repo.subscribeActiveWorkspace`
+     *  (or pass `repo.activeWorkspaceId` explicitly). Making this field
+     *  required at the type level prevents background flows, import runs,
+     *  and any code that operates on a workspace other than the
+     *  currently-active one from silently mis-scoping when the user
+     *  switches workspaces mid-flight (see PR #47 review). */
+    readonly workspaceId: string;
+    /** Contains any of these type ids. Empty/omitted means no type filter. */
+    readonly types?: readonly string[];
+    /** Self-scope shorthand: equivalent to a `match` entry with
+     *  `scope: 'self'` carrying these `where` filters. Kept as a
+     *  top-level field so the common typed-block-query call sites stay
+     *  terse. */
+    readonly where?: Readonly<Record<string, unknown>>;
+    /** Self-scope shorthand: equivalent to a `match` entry with
+     *  `scope: 'self'` carrying this `referencedBy`. Drives the
+     *  candidate-set selection in the compiler — when present, the
+     *  scan starts from `block_references` and the ancestor walk (if
+     *  any) is seeded from that narrow set. */
+    readonly referencedBy?: TypedBlockQueryReferenceFilter;
+    /** Additional ANDed predicates. Each predicate carries its own
+     *  scope, so the same query can mix block-itself and block-or-any-
+     *  ancestor filters. */
+    readonly match?: readonly BlockPredicate[];
+    /** NORed predicates: a block matches iff none of these match. Same
+     *  predicate shape as `match`. */
+    readonly exclude?: readonly BlockPredicate[];
+    /** Result ordering. Default `created-asc`. Backlinks panels use
+     *  `created-desc` to put newest sources first. */
+    readonly order?: 'created-asc' | 'created-desc';
+}
+/** Historically the "post-default-resolution" shape used internally;
+ *  now that `TypedBlockQuery.workspaceId` is required at the type level
+ *  the two shapes are identical. Kept as an alias for back-compat with
+ *  internal call sites that name the resolved form explicitly. */
+export type ResolvedTypedBlockQuery = TypedBlockQuery;
+//# sourceMappingURL=typedBlockQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typedBlockQuery.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/typedBlockQuery.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCY;AACZ,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAAE,CAAA;AAE1D;;;;;;;;;;;;;wDAawD;AACxD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACpC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAClD,QAAQ,CAAC,YAAY,CAAC,EAAE,8BAA8B,CAAA;CACvD;AAED,MAAM,WAAW,eAAe;IAC9B;;;;;;8DAM0D;IAC1D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC;;;iBAGa;IACb,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAClD;;;;+CAI2C;IAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,8BAA8B,CAAA;IACtD;;4BAEwB;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAA;IAC1C;sCACkC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,cAAc,EAAE,CAAA;IAC5C;sDACkD;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,cAAc,CAAA;CAChD;AAED;;;kEAGkE;AAClE,MAAM,MAAM,uBAAuB,GAAG,eAAe,CAAA"}

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

@@ -0,0 +1,9 @@
+/** Tx-context user. Kept minimal — engine writes `user.id` into
+ *  `tx_context.user_id` and into the per-row `created_by` / `updated_by`
+ *  columns. Display-side User shape lives in `src/types.ts`; the data
+ *  layer doesn't depend on it. */
+export interface User {
+    id: string;
+    name?: string;
+}
+//# sourceMappingURL=user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/user.ts"],"names":[],"mappings":"AAAA;;;kCAGkC;AAClC,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;CACd"}