@knowledge-medium/agent-cli 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../../../src/context/block.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAgD,SAAS,EAAE,MAAM,OAAO,CAAA;AAC/E,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,YAAY,2CAAsC,CAAA;AAkC/D,eAAO,MAAM,oBAAoB,GAAI,4BAA2B;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,gBAAgB,CAAA;CAAE,4CAOtH,CAAA;AAED,eAAO,MAAM,0BAA0B,GACrC,yBAAuB;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAAE,4CAerF,CAAA;AAED,eAAO,MAAM,eAAe,wBAM3B,CAAA"}

package/dist/kernel-types/src/context/repo.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+import { Repo } from '../data/repo';
+export declare function RepoProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useRepo(): Repo;
+//# sourceMappingURL=repo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repo.d.ts","sourceRoot":"","sources":["../../../../../../src/context/repo.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAAmB,MAAM,OAAO,CAAA;AAGjE,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAuCnC,wBAAgB,YAAY,CAAC,EAAC,QAAQ,EAAC,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAgB/D;AAED,wBAAgB,OAAO,IAAI,IAAI,CAM9B"}

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

@@ -0,0 +1,73 @@
+/** Outgoing reference parsed from content or a ref-typed property. For
+ *  wikilinks `[[Inbox]]`, `alias` is the user-typed text and `id` is the
+ *  resolved target. For block refs `((uuid))` and property refs,
+ *  `alias === id` so content wikilink rendering doesn't accidentally
+ *  resolve through non-wikilink edges. */
+export interface BlockReference {
+    /** Resolved target block id. */
+    id: string;
+    /** Original alias text from the source content (preserved so wikilink
+     *  rendering can show the alias the user typed, which may differ from
+     *  the target's current name/aliases). */
+    alias: string;
+    /** Empty/omitted for content refs; set to `PropertySchema.name` for
+     *  refs projected from typed properties. */
+    sourceField?: string;
+}
+/** Domain shape — public, camelCase. SQL columns are snake_case
+ *  (`BlockRow`) and JSON-encoded; `parseBlockRow` / `blockToRow` are the
+ *  only places either shape leaks into the other. See spec §4.1.1. */
+export interface BlockData {
+    id: string;
+    workspaceId: string;
+    parentId: string | null;
+    orderKey: string;
+    content: string;
+    /** Codec-encoded property values keyed by `PropertySchema.name`.
+     *  Decoded on read at the four boundary sites only; storage and cache
+     *  always hold this encoded shape. */
+    properties: Record<string, unknown>;
+    references: BlockReference[];
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+    updatedBy: string;
+    deleted: boolean;
+}
+/** Patch shape for `tx.update` — non-structural data fields only.
+ *  Structural (`parentId`, `orderKey` → `tx.move`), lifecycle (`deleted`
+ *  → `tx.delete` / `tx.restore`), and metadata fields (`updatedAt` /
+ *  `updatedBy` are engine-managed; `createdAt` / `createdBy` are
+ *  immutable; `workspaceId` is fixed at creation) all have their own
+ *  primitives. The undo machinery does NOT use `tx.update` — it has
+ *  its own raw-row applier driven by snapshots. See spec §4.1.1. */
+export type BlockDataPatch = Partial<Pick<BlockData, 'content' | 'properties' | 'references'>>;
+/** Canonical form for a `BlockReference[]`. Sorted by
+ *  `(sourceField, id, alias)` with `sourceField` defaulted to `''`, and
+ *  exact duplicates collapsed. Every write of `references_json` runs
+ *  through this so on-disk shape is independent of writer-side iteration
+ *  order (Roam import's content-position order, the post-commit parser's
+ *  alias-then-date-then-block-ref order, reprojection's
+ *  retained-then-added order all converge), and downstream equality
+ *  checks reduce to text compare. Consumers
+ *  (`json_each`-driven backlinks index, `BACKLINKS_FOR_BLOCK_QUERY`,
+ *  Map-keyed invalidation) treat references as a set, so the loss of
+ *  insertion order is correctness-preserving. */
+export declare const normalizeReferences: (refs: ReadonlyArray<BlockReference>) => BlockReference[];
+/** Allowed shape for `tx.create`.
+ *  - `id` optional (engine UUIDs when absent; deterministic-id helpers pass
+ *    one in verbatim).
+ *  - `createdAt` / `createdBy` / `updatedAt` / `updatedBy` not accepted —
+ *    engine sets all four from `tx_context` at the write site.
+ *  - `deleted` not accepted — fresh rows are live; soft-delete goes through
+ *    `tx.delete`. */
+export interface NewBlockData {
+    id?: string;
+    workspaceId: string;
+    parentId: string | null;
+    orderKey: string;
+    content?: string;
+    properties?: Record<string, unknown>;
+    references?: BlockReference[];
+}
+//# sourceMappingURL=blockData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blockData.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/blockData.ts"],"names":[],"mappings":"AAAA;;;;0CAI0C;AAC1C,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAA;IACV;;8CAE0C;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb;gDAC4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;sEAEsE;AACtE,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf;;0CAEsC;IACtC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,UAAU,EAAE,cAAc,EAAE,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;;oEAMoE;AACpE,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CACvC,SAAS,EACT,SAAS,GAAG,YAAY,GAAG,YAAY,CACxC,CAAC,CAAA;AAEF;;;;;;;;;;iDAUiD;AACjD,eAAO,MAAM,mBAAmB,GAC9B,MAAM,aAAa,CAAC,cAAc,CAAC,KAClC,cAAc,EAwBhB,CAAA;AAED;;;;;;qBAMqB;AACrB,MAAM,WAAW,YAAY;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACpC,UAAU,CAAC,EAAE,cAAc,EAAE,CAAA;CAC9B"}

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

@@ -0,0 +1,19 @@
+import type { AnyPropertySchema } from './propertySchema';
+export interface TypeContribution {
+    /** Stable id; matches the string written into `typesProp`. */
+    readonly id: string;
+    /** Property schemas that apply to blocks of this type. */
+    readonly properties?: ReadonlyArray<AnyPropertySchema>;
+    /** Optional human label for type pickers / property sections. */
+    readonly label?: string;
+    /** Optional longer description for tooltips / section headers. */
+    readonly description?: string;
+}
+export interface TypeRegistrySnapshot {
+    readonly types: ReadonlyMap<string, TypeContribution>;
+    readonly propertySchemas: ReadonlyMap<string, AnyPropertySchema>;
+}
+/** Identity helper for definition-site inference. Registration still
+ *  happens through `typesFacet.of(...)`. */
+export declare const defineBlockType: (def: TypeContribution) => TypeContribution;
+//# sourceMappingURL=blockType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blockType.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/blockType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEzD,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;IACtD,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IACrD,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;CACjE;AAED;4CAC4C;AAC5C,eAAO,MAAM,eAAe,GAAI,KAAK,gBAAgB,KAAG,gBAAuB,CAAA"}

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

@@ -0,0 +1,62 @@
+/** ChangeScope drives undo behavior, upload routing, and read-only gating
+ *  for every write made through `repo.tx`. Plugins pick the one whose
+ *  engine semantics match their need (no plugin-extensible scope registry —
+ *  see §5.8 of the data-layer spec). */
+export declare const ChangeScope: {
+    /** User document edits. Undoable; uploads to server. */
+    readonly BlockDefault: "block-default";
+    /** Selection / focus / chrome state. Not undoable; uploads like any
+     *  other write — server-side RLS or FK errors land in the rejection
+     *  quarantine rather than blocking the queue. The scope identity is
+     *  still load-bearing for undo bucketing and schema validation
+     *  (`requireSchemaScope`). */
+    readonly UiState: "local-ui";
+    /** User-owned preferences. Not undoable; uploads. */
+    readonly UserPrefs: "user-prefs";
+    /** parseReferences bookkeeping. Separate undo bucket; uploads. */
+    readonly References: "block-default:references";
+};
+export type ChangeScope = (typeof ChangeScope)[keyof typeof ChangeScope];
+/** `tx_context.source` values written by `repo.tx`. Sync-applied writes leave
+ *  `source = NULL`; row_events triggers `COALESCE` it to `'sync'`. The string
+ *  `'sync'` is therefore reserved for the trigger output and is not assignable
+ *  from any caller. Every `repo.tx` invocation is `'user'` — there is no
+ *  longer a routing-time downgrade. */
+export type TxSource = 'user';
+/** Read-only behavior per scope: either reject the write outright or let
+ *  it proceed (the upload will still be attempted; server-side RLS or FK
+ *  errors land in the rejection quarantine). */
+export type ReadOnlyScopeBehavior = 'reject' | 'allow';
+export interface ChangeScopePolicy {
+    readonly undoable: boolean;
+    readonly source: TxSource;
+    readonly readOnly: ReadOnlyScopeBehavior;
+}
+export declare const CHANGE_SCOPE_POLICIES: {
+    "block-default": {
+        undoable: true;
+        source: "user";
+        readOnly: "reject";
+    };
+    "local-ui": {
+        undoable: false;
+        source: "user";
+        readOnly: "allow";
+    };
+    "user-prefs": {
+        undoable: false;
+        source: "user";
+        readOnly: "allow";
+    };
+    "block-default:references": {
+        undoable: true;
+        source: "user";
+        readOnly: "reject";
+    };
+};
+export declare const policyForScope: (scope: ChangeScope) => ChangeScopePolicy;
+export declare const scopeAllowedInReadOnly: (scope: ChangeScope) => boolean;
+export declare const scopeIsUndoable: (scope: ChangeScope) => boolean;
+export declare const sourceForScope: (scope: ChangeScope) => TxSource;
+export declare const scopeUploadsToServer: (scope: ChangeScope) => boolean;
+//# sourceMappingURL=changeScope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"changeScope.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/changeScope.ts"],"names":[],"mappings":"AAAA;;;wCAGwC;AACxC,eAAO,MAAM,WAAW;IACtB,wDAAwD;;IAExD;;;;kCAI8B;;IAE9B,qDAAqD;;IAErD,kEAAkE;;CAE1D,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAA;AAExE;;;;uCAIuC;AACvC,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAA;AAE7B;;gDAEgD;AAChD,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEtD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAA;CACzC;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;CAqB0B,CAAA;AAE5D,eAAO,MAAM,cAAc,GAAI,OAAO,WAAW,KAAG,iBACtB,CAAA;AAE9B,eAAO,MAAM,sBAAsB,GAAI,OAAO,WAAW,KAAG,OACf,CAAA;AAE7C,eAAO,MAAM,eAAe,GAAI,OAAO,WAAW,KAAG,OACrB,CAAA;AAEhC,eAAO,MAAM,cAAc,GAAI,OAAO,WAAW,KAAG,QACtB,CAAA;AAE9B,eAAO,MAAM,oBAAoB,GAAI,OAAO,WAAW,KAAG,OACxB,CAAA"}

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

@@ -0,0 +1,72 @@
+import { CodecError } from './errors';
+/** Bidirectional encode/decode for typed values stored in the JSON-shaped
+ *  `properties_json` column. Codecs run at exactly four boundary call sites
+ *  (`block.set`, `block.get`, `tx.setProperty`, `tx.getProperty`); storage
+ *  and cache always hold the encoded shape. See spec §5.6 and the
+ *  user-defined-properties §1a doc for the open-string `type` discriminator. */
+/** Scalar value compatible with `json_extract(...) = ?` parameter binding.
+ *  Excludes null deliberately — typed-query callers use `null` to mean
+ *  "match unset" and the compiler short-circuits that to `IS NULL` *before*
+ *  calling `where.encode`. A codec returning null from `where.encode` would
+ *  compare-equal to SQL NULL and match no rows; narrowing the return type
+ *  here makes that mistake unrepresentable. */
+export type WhereValue = string | number;
+export interface WhereCapability<T> {
+    /** Encode a decoded value to its scalar SQLite-comparable form. The
+     *  caller can pass any runtime value, so this MUST validate that the
+     *  input is actually a value of type T and throw `CodecError`
+     *  otherwise — the same shape as `decode` validating its JSON input. */
+    encode(value: T): WhereValue;
+}
+export interface Codec<T> {
+    /** Open-string discriminator. Stable preset id for codecs built by a
+     *  ValuePreset (`'string'`, `'number'`, `'ref'`, `'url'`, …); plugin
+     *  codecs MUST pick a unique value so the preset/editor lookup is
+     *  unambiguous. */
+    readonly type: string;
+    /** Encode to a JSON-serializable value. Called only on validated `T`
+     *  from the type system at the four boundary call sites — does not
+     *  validate input. */
+    encode(value: T): unknown;
+    /** Decode from a JSON-decoded value. Throws CodecError on shape mismatch. */
+    decode(json: unknown): T;
+    /** Optional capability: this codec can produce a scalar SQLite value
+     *  for `json_extract(properties_json, ?) = ?` comparison. Codecs that
+     *  cannot — refs (route via referencedBy), lists, objects — omit it.
+     *  Presence of `where` is the authoritative signal that the property
+     *  is queryable. */
+    readonly where?: WhereCapability<T>;
+}
+export type AnyCodec = Codec<any>;
+export interface RefCodecOptions {
+    readonly targetTypes?: readonly string[];
+}
+export interface RefCodec extends Codec<string> {
+    readonly type: 'ref';
+    readonly targetTypes: readonly string[];
+}
+export interface RefListCodec extends Codec<readonly string[]> {
+    readonly type: 'refList';
+    readonly targetTypes: readonly string[];
+}
+export declare const isRefCodec: (codec: unknown) => codec is RefCodec;
+export declare const isRefListCodec: (codec: unknown) => codec is RefListCodec;
+export declare const codecs: {
+    string: Codec<string>;
+    number: Codec<number>;
+    boolean: Codec<boolean>;
+    /** Date codec is natively absence-aware (`Codec<Date | undefined>`).
+     *  No generic `codecs.optional` wrapper exists — see the
+     *  user-defined-properties.md "Why no codecs.optional" section. */
+    date: Codec<Date | undefined>;
+    url: Codec<string>;
+    list: <T>(inner: Codec<T>) => Codec<T[]>;
+    ref: (options?: RefCodecOptions) => RefCodec;
+    refList: (options?: RefCodecOptions) => RefListCodec;
+    unsafeIdentity: <T>(type?: string) => Codec<T>;
+    optionalString: Codec<string | undefined>;
+    optionalNumber: Codec<number | undefined>;
+    optionalIdentity: <T>(type?: string) => Codec<T | undefined>;
+};
+export { CodecError };
+//# sourceMappingURL=codecs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/codecs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAErC;;;;gFAIgF;AAEhF;;;;;+CAK+C;AAC/C,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAA;AAExC,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC;;;4EAGwE;IACxE,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,UAAU,CAAA;CAC7B;AAED,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB;;;uBAGmB;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;0BAEsB;IACtB,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAA;IACzB,6EAA6E;IAC7E,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,CAAC,CAAA;IACxB;;;;wBAIoB;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAA;CACpC;AAGD,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;AAEjC,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACzC;AAED,MAAM,WAAW,QAAS,SAAQ,KAAK,CAAC,MAAM,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC;AAED,MAAM,WAAW,YAAa,SAAQ,KAAK,CAAC,SAAS,MAAM,EAAE,CAAC;IAC5D,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC;AAqHD,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QACoC,CAAA;AAEzF,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,YACoC,CAAA;AA6E7F,eAAO,MAAM,MAAM;;;;IAIjB;;uEAEmE;;;WAtHvD,CAAC,SAAS,KAAK,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC;oBAYtB,eAAe,KAAG,QAAQ;wBAOtB,eAAe,KAAG,YAAY;qBAsCjC,CAAC,oBAAoB,KAAK,CAAC,CAAC,CAAC;;;uBAiD3B,CAAC,oBAAoB,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC;CAsBlE,CAAA;AAED,OAAO,EAAE,UAAU,EAAE,CAAA"}

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

@@ -0,0 +1,108 @@
+/** Typed errors thrown by the data layer. Callers can `instanceof`-check
+ *  any of these; they all subclass `Error`. Names align with the data-layer
+ *  spec (`tasks/data-layer-redesign.md` §5.3, §10.4, §4.7, §13.1). */
+export declare class DataLayerError extends Error {
+    constructor(message: string);
+}
+export declare class BlockNotLoadedError extends DataLayerError {
+    readonly id: string;
+    constructor(id: string);
+}
+export declare class BlockNotFoundError extends DataLayerError {
+    readonly id: string;
+    constructor(id: string);
+}
+/** Thrown by `repo.addType` / `repo.addTypeInTx` when the target block is
+ *  missing or tombstoned at write time. Orchestration code that's about
+ *  to fan out work based on the assumption the tag was applied wants this
+ *  to throw rather than silently no-op. Callers that legitimately race
+ *  against a concurrent delete (sync-apply / processor paths) can opt
+ *  into the lenient `addTypeInTxLenient` entry point. */
+export declare class BlockNotFoundForTypeError extends DataLayerError {
+    readonly blockId: string;
+    readonly typeId: string;
+    readonly reason: 'missing' | 'tombstoned';
+    constructor(blockId: string, typeId: string, reason: 'missing' | 'tombstoned');
+}
+export declare class DuplicateIdError extends DataLayerError {
+    readonly id: string;
+    constructor(id: string);
+}
+export declare class DeletedConflictError extends DataLayerError {
+    readonly id: string;
+    constructor(id: string);
+}
+export declare class DeterministicIdCrossWorkspaceError extends DataLayerError {
+    readonly id: string;
+    readonly existingWorkspaceId: string;
+    readonly requestedWorkspaceId: string;
+    constructor(id: string, existingWorkspaceId: string, requestedWorkspaceId: string);
+}
+export declare class NotDeletedError extends DataLayerError {
+    readonly id: string;
+    constructor(id: string);
+}
+export declare class CycleError extends DataLayerError {
+    readonly movedId: string;
+    readonly targetParentId: string;
+    constructor(movedId: string, targetParentId: string);
+}
+/** Thrown by the tx engine's parent preflight when a write references a
+ *  non-existent parent_id. The storage layer still backs this invariant, but
+ *  its local trigger collapses missing-parent and cross-workspace failures
+ *  into one SQLITE constraint message. */
+export declare class ParentNotFoundError extends DataLayerError {
+    readonly parentId: string;
+    constructor(parentId: string);
+}
+/** Thrown by the tx engine's parent preflight when a write places a child
+ *  under a parent in a different workspace. */
+export declare class ParentWorkspaceMismatchError extends DataLayerError {
+    readonly parentId: string;
+    readonly parentWorkspaceId: string;
+    readonly childWorkspaceId: string;
+    constructor(parentId: string, parentWorkspaceId: string, childWorkspaceId: string);
+}
+/** Kernel-mutator UX rule (not a storage invariant): a kernel mutator
+ *  preflighted the parent's `deleted` flag and refused to create or move
+ *  a child under a soft-deleted parent. Plugin mutators and direct
+ *  `repo.tx` callers that skip the kernel layer do not get this check. */
+export declare class ParentDeletedError extends DataLayerError {
+    readonly parentId: string;
+    constructor(parentId: string);
+}
+/** A second write inside a single repo.tx targeted a different workspace
+ *  than the first write (which pinned `tx.meta.workspaceId`). */
+export declare class WorkspaceMismatchError extends DataLayerError {
+    readonly pinnedWorkspaceId: string;
+    readonly attemptedWorkspaceId: string;
+    constructor(pinnedWorkspaceId: string, attemptedWorkspaceId: string);
+}
+/** `tx.afterCommit` was called before any write happened in the tx, so
+ *  no workspace has been pinned. CommittedEvent.workspaceId would be
+ *  null, which the type contract forbids. */
+export declare class WorkspaceNotPinnedError extends DataLayerError {
+    constructor();
+}
+export declare class ReadOnlyError extends DataLayerError {
+    readonly scope: string;
+    constructor(scope: string);
+}
+export declare class MutatorNotRegisteredError extends DataLayerError {
+    readonly mutatorName: string;
+    constructor(mutatorName: string);
+}
+export declare class QueryNotRegisteredError extends DataLayerError {
+    readonly queryName: string;
+    constructor(queryName: string);
+}
+export declare class ProcessorNotRegisteredError extends DataLayerError {
+    readonly processorName: string;
+    constructor(processorName: string);
+}
+export declare class CodecError extends DataLayerError {
+    readonly expected: string;
+    readonly got: unknown;
+    constructor(expected: string, got: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/errors.ts"],"names":[],"mappings":"AAAA;;sEAEsE;AAEtE,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM;CAI5B;AAID,qBAAa,mBAAoB,SAAQ,cAAc;aACzB,EAAE,EAAE,MAAM;gBAAV,EAAE,EAAE,MAAM;CAGvC;AAED,qBAAa,kBAAmB,SAAQ,cAAc;aACxB,EAAE,EAAE,MAAM;gBAAV,EAAE,EAAE,MAAM;CAGvC;AAED;;;;;yDAKyD;AACzD,qBAAa,yBAA0B,SAAQ,cAAc;aAEzC,OAAO,EAAE,MAAM;aACf,MAAM,EAAE,MAAM;aACd,MAAM,EAAE,SAAS,GAAG,YAAY;gBAFhC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,GAAG,YAAY;CAOnD;AAID,qBAAa,gBAAiB,SAAQ,cAAc;aACtB,EAAE,EAAE,MAAM;gBAAV,EAAE,EAAE,MAAM;CAGvC;AAED,qBAAa,oBAAqB,SAAQ,cAAc;aAC1B,EAAE,EAAE,MAAM;gBAAV,EAAE,EAAE,MAAM;CAGvC;AAED,qBAAa,kCAAmC,SAAQ,cAAc;aAElD,EAAE,EAAE,MAAM;aACV,mBAAmB,EAAE,MAAM;aAC3B,oBAAoB,EAAE,MAAM;gBAF5B,EAAE,EAAE,MAAM,EACV,mBAAmB,EAAE,MAAM,EAC3B,oBAAoB,EAAE,MAAM;CAO/C;AAED,qBAAa,eAAgB,SAAQ,cAAc;aACrB,EAAE,EAAE,MAAM;gBAAV,EAAE,EAAE,MAAM;CAGvC;AAID,qBAAa,UAAW,SAAQ,cAAc;aAE1B,OAAO,EAAE,MAAM;aACf,cAAc,EAAE,MAAM;gBADtB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM;CAIzC;AAED;;;0CAG0C;AAC1C,qBAAa,mBAAoB,SAAQ,cAAc;aACzB,QAAQ,EAAE,MAAM;gBAAhB,QAAQ,EAAE,MAAM;CAG7C;AAED;+CAC+C;AAC/C,qBAAa,4BAA6B,SAAQ,cAAc;aAE5C,QAAQ,EAAE,MAAM;aAChB,iBAAiB,EAAE,MAAM;aACzB,gBAAgB,EAAE,MAAM;gBAFxB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,MAAM;CAO3C;AAED;;;0EAG0E;AAC1E,qBAAa,kBAAmB,SAAQ,cAAc;aACxB,QAAQ,EAAE,MAAM;gBAAhB,QAAQ,EAAE,MAAM;CAG7C;AAID;iEACiE;AACjE,qBAAa,sBAAuB,SAAQ,cAAc;aAEtC,iBAAiB,EAAE,MAAM;aACzB,oBAAoB,EAAE,MAAM;gBAD5B,iBAAiB,EAAE,MAAM,EACzB,oBAAoB,EAAE,MAAM;CAM/C;AAED;;6CAE6C;AAC7C,qBAAa,uBAAwB,SAAQ,cAAc;;CAI1D;AAID,qBAAa,aAAc,SAAQ,cAAc;aACnB,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;CAG1C;AAED,qBAAa,yBAA0B,SAAQ,cAAc;aAC/B,WAAW,EAAE,MAAM;gBAAnB,WAAW,EAAE,MAAM;CAGhD;AAED,qBAAa,uBAAwB,SAAQ,cAAc;aAC7B,SAAS,EAAE,MAAM;gBAAjB,SAAS,EAAE,MAAM;CAG9C;AAED,qBAAa,2BAA4B,SAAQ,cAAc;aACjC,aAAa,EAAE,MAAM;gBAArB,aAAa,EAAE,MAAM;CAGlD;AAID,qBAAa,UAAW,SAAQ,cAAc;aAE1B,QAAQ,EAAE,MAAM;aAChB,GAAG,EAAE,OAAO;gBADZ,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,OAAO;CAY/B"}

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

@@ -0,0 +1,19 @@
+/** Engine-emitted event shapes. v1 only emits `cycleDetected` from the
+ *  row_events tail when sync-applied parent_id mutations close a loop;
+ *  it surfaces as a `console.warn` (operators grep logs) plus an
+ *  optional `onCycleDetected` callback on `RowEventsTailOptions` for
+ *  tests / future telemetry hooks. No pub/sub plumbing lives on `Repo`
+ *  itself in v1 — there are no in-product subscribers and the alpha
+ *  policy is "operator runs the §4.7 SQL runbook to fix manually". */
+export interface CycleDetectedEvent {
+    workspaceId: string;
+    /** Affected ids that participate in cycles (each row that closes back
+     *  on itself; full cycle members enumerated via the runbook in §4.7). */
+    startIds: string[];
+    /** tx_ids of the row_events that triggered detection. Empty for the
+     *  pure-sync case (the row_events trigger writes tx_id = NULL when
+     *  source IS NULL, which is always true for PowerSync's CRUD-apply
+     *  path); the field exists for completeness. */
+    txIdsInvolved: string[];
+}
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/events.ts"],"names":[],"mappings":"AAAA;;;;;;sEAMsE;AAEtE,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAA;IACnB;6EACyE;IACzE,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB;;;oDAGgD;IAChD,aAAa,EAAE,MAAM,EAAE,CAAA;CACxB"}

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

@@ -0,0 +1,17 @@
+export type HandleStatus = 'idle' | 'loading' | 'ready' | 'error';
+export type Unsubscribe = () => void;
+/** Single read primitive. Identity-stable per `(name, JSON.stringify(args))`.
+ *  GC after `gcTime` of zero subscribers + zero in-flight loads. See §5.1. */
+export interface Handle<T> {
+    readonly key: string;
+    /** Sync read. `undefined` = not yet loaded; never throws. */
+    peek(): T | undefined;
+    /** Ensure loaded; idempotent + deduped. */
+    load(): Promise<T>;
+    /** Reactive subscription. Listener fires on structural change only. */
+    subscribe(listener: (value: T) => void): Unsubscribe;
+    /** Suspense path: returns T or throws a Promise if not loaded. */
+    read(): T;
+    status(): HandleStatus;
+}
+//# sourceMappingURL=handle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/handle.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAA;AAEjE,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAA;AAEpC;8EAC8E;AAC9E,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IAEpB,6DAA6D;IAC7D,IAAI,IAAI,CAAC,GAAG,SAAS,CAAA;IAErB,2CAA2C;IAC3C,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,CAAA;IAElB,uEAAuE;IACvE,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,WAAW,CAAA;IAEpD,kEAAkE;IAClE,IAAI,IAAI,CAAC,CAAA;IAET,MAAM,IAAI,YAAY,CAAA;CACvB"}

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

@@ -0,0 +1,20 @@
+/** Public data-layer API. Stable across plugin authors and call sites.
+ *  Internals live under `src/data/internals/`. */
+export * from './blockData';
+export * from './blockType';
+export * from './changeScope';
+export * from './codecs';
+export * from './errors';
+export * from './events';
+export * from './handle';
+export * from './mutator';
+export * from './processor';
+export * from './sameTxProcessor';
+export * from './propertySchema';
+export * from './query';
+export * from './schema';
+export * from './typedBlockQuery';
+export * from './tx';
+export * from './user';
+export * from './valuePresets';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/index.ts"],"names":[],"mappings":"AAAA;kDACkD;AAElD,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,mBAAmB,CAAA;AACjC,cAAc,MAAM,CAAA;AACpB,cAAc,QAAQ,CAAA;AACtB,cAAc,gBAAgB,CAAA"}

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

@@ -0,0 +1,42 @@
+import type { ChangeScope } from './changeScope';
+import type { Schema } from './schema';
+import type { Tx } from './tx';
+export interface Mutator<Args = unknown, Result = void> {
+    readonly name: string;
+    readonly argsSchema: Schema<Args>;
+    readonly resultSchema?: Schema<Result>;
+    readonly apply: (tx: Tx, args: Args) => Promise<Result>;
+    /** Optional: human-readable description of this call (used as the
+     *  default `description` for the wrapping tx in `repo.mutate.X`). */
+    readonly describe?: (args: Args) => string;
+    /** Static or arg-derived scope. The wrapper resolves to a concrete
+     *  scope before opening the tx (engine needs it for `tx_context.source`
+     *  + read-only gating, both pre-user-fn). */
+    readonly scope: ChangeScope | ((args: Args) => ChangeScope);
+}
+/** Plugin-augmentable type registry. Static plugins augment via
+ *  `declare module '@/data/api'`; dynamic plugins use string-keyed
+ *  access via `repo.run('name', args)`. See §12.
+ *  The empty body is the whole point — `interface` lets plugins layer
+ *  in members from outside this module via declaration merging, which
+ *  `type` and `Record<string, ...>` can't. */
+export interface MutatorRegistry {
+}
+/** Variance-erased mutator type for storage in heterogeneous collections
+ *  (the engine's mutator registry, `mutatorsFacet`'s contributions, etc).
+ *
+ *  `Mutator<unknown, unknown>` doesn't work because `Args` is contravariant:
+ *  a `Mutator<{x: number}, void>` can NOT be safely stored as a
+ *  `Mutator<unknown, unknown>` (the latter could be called with any
+ *  unknown, but the former only accepts `{x: number}`). The conventional
+ *  TypeScript escape for this case is `any` — it opts out of variance
+ *  checking for the registry slot while keeping the per-mutator types
+ *  intact at definition sites. Concrete callers (`repo.mutate.X`,
+ *  `tx.run(mutator, args)`) work against the precise types via the
+ *  `MutatorRegistry` augmentation channel. */
+export type AnyMutator = Mutator<any, any>;
+/** Helper for plugin authors. Returns the mutator unchanged but
+ *  type-narrows `Args` / `Result` from `argsSchema` / `resultSchema`
+ *  inferred types. */
+export declare const defineMutator: <Args, Result = void>(mutator: Mutator<Args, Result>) => Mutator<Args, Result>;
+//# sourceMappingURL=mutator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mutator.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/mutator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,MAAM,CAAA;AAE9B,MAAM,WAAW,OAAO,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,GAAG,IAAI;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACtC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IACvD;yEACqE;IACrE,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAA;IAC1C;;iDAE6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,WAAW,CAAC,CAAA;CAC5D;AAED;;;;;8CAK8C;AAE9C,MAAM,WAAW,eAAe;CAA+B;AAE/D;;;;;;;;;;;8CAW8C;AAE9C,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAE1C;;sBAEsB;AACtB,eAAO,MAAM,aAAa,GAAI,IAAI,EAAE,MAAM,GAAG,IAAI,EAC/C,SAAS,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,KAC7B,OAAO,CAAC,IAAI,EAAE,MAAM,CAAY,CAAA"}

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

@@ -0,0 +1,115 @@
+import type { BlockData } from './blockData';
+import type { AnyPropertySchema } from './propertySchema';
+import type { Repo } from '../repo';
+import type { Schema } from './schema';
+import type { User } from './user';
+/** Plugin-augmentable type registry for processor scheduled args.
+ *  Static processors augment via `declare module '@/data/api'`; dynamic
+ *  processors fall back to `unknown` and rely on runtime
+ *  `scheduledArgsSchema.parse(args)` validation at enqueue.
+ *  Empty body is intentional — declaration merging requires interface. */
+export interface PostCommitProcessorRegistry {
+}
+export type ScheduledArgsFor<P extends string> = P extends keyof PostCommitProcessorRegistry ? PostCommitProcessorRegistry[P] : unknown;
+/** Discriminated on `watches.kind`:
+ *  - `'field'`: fires when the originating tx wrote any of the named
+ *    fields on `blocks`. Robust correctness path — catches every
+ *    code path that touches the field. `scheduledArgs` is undefined.
+ *  - `'explicit'`: fires only when a previous tx called
+ *    `tx.afterCommit(name, args)`. `scheduledArgsSchema` is REQUIRED;
+ *    engine validates at enqueue time. */
+export type ProcessorWatches<ScheduledArgs> = {
+    watches: {
+        kind: 'field';
+        table: 'blocks';
+        fields: ReadonlyArray<keyof BlockData>;
+    };
+    scheduledArgsSchema?: never;
+} | {
+    watches: {
+        kind: 'explicit';
+    };
+    scheduledArgsSchema: Schema<ScheduledArgs>;
+};
+/** A processor is a plain async function that reacts to a committed tx
+ *  and decides for itself whether to read, write, or do neither. The
+ *  framework does NOT auto-open a writeTransaction (v4.32 — see §5.7);
+ *  if the processor wants to write, it calls `ctx.repo.tx(...)` itself.
+ *
+ *  This shape supports three legitimate processor modes uniformly:
+ *    - pure side-effects (UI invalidation, analytics) → no tx, no cost
+ *    - read-derive-cache → reads via `ctx.db`, no tx
+ *    - conditional or always writes → opens its own `ctx.repo.tx(...)`
+ *      with the scope it wants
+ *
+ *  Why no `scope` field on the processor itself: scope is a tx property,
+ *  not a processor property. A processor that opens multiple txs may
+ *  legitimately want different scopes per tx; one that never writes
+ *  should not have to declare a scope it won't use. The processor names
+ *  the scope at the `repo.tx` call site, where it's actually needed. */
+export type PostCommitProcessor<ScheduledArgs = unknown> = {
+    readonly name: string;
+    readonly apply: (event: CommittedEvent<ScheduledArgs>, ctx: ProcessorCtx) => Promise<void>;
+} & ProcessorWatches<ScheduledArgs>;
+/** A row that changed in the originating tx. Both before/after are domain
+ *  shape (camelCase), populated for `kind: 'field'` processors only. */
+export interface ChangedRow {
+    id: string;
+    before: BlockData | null;
+    after: BlockData | null;
+}
+/** Event passed to `processor.apply`. `workspaceId` is `string` (never
+ *  null) — see the contract in §5.7. */
+export interface CommittedEvent<ScheduledArgs = unknown> {
+    txId: string;
+    changedRows: ChangedRow[];
+    user: User;
+    workspaceId: string;
+    /** Populated for `kind: 'explicit'` processors. */
+    scheduledArgs?: ScheduledArgs;
+}
+/** Read-only SQL surface available to a processor outside any tx.
+ *  Sees committed state at processor-fire time (the originating user
+ *  tx is committed by the time `apply` fires). Intentionally narrower
+ *  than `PowerSyncDatabase` — no `execute`, no `writeTransaction` — so
+ *  the type prevents accidental writes through this handle. Writes
+ *  must go through a `repo.tx(...)` opened by the processor. */
+export interface ProcessorReadDb {
+    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>;
+}
+/** Processor context (v4.32). The framework no longer auto-opens a tx;
+ *  the processor decides.
+ *
+ *  - `db`: raw SQL for committed-state reads. The originating user tx
+ *    is committed before `apply` fires, so reads see committed state.
+ *    No writer is open at this surface unless the processor opens one
+ *    itself via `repo.tx`, so reads don't queue behind a writer.
+ *  - `repo`: full `Repo` — open a write tx (`repo.tx(fn, {scope})`)
+ *    when/if the processor decides to write, invoke other mutators via
+ *    `repo.mutate.*`, run registered queries.
+ *    Imported here as a type-only reference; type cycles via `import
+ *    type` are erased at compile time so there's no runtime cycle. */
+export interface ProcessorCtx {
+    /** Raw SQL for committed-state reads. The narrow shape is deliberate:
+     *  `.execute()` / `.writeTransaction()` are absent so accidental writes
+     *  through this handle are compile-time errors. Writes go through
+     *  `ctx.repo.tx(...)`. */
+    db: ProcessorReadDb;
+    /** Full `Repo` — open a write tx when needed, invoke mutators, run
+     *  kernel queries. */
+    repo: Repo;
+    /** Merged property-schema registry snapshotted with the processor
+     *  registry at tx start. Processors use this for codec lookups
+     *  without racing runtime swaps. */
+    propertySchemas: ReadonlyMap<string, AnyPropertySchema>;
+}
+export declare const definePostCommitProcessor: <ScheduledArgs = undefined>(processor: PostCommitProcessor<ScheduledArgs>) => PostCommitProcessor<ScheduledArgs>;
+/** Variance-erased processor type for storage in heterogeneous
+ *  collections (the engine's processor registry, the
+ *  postCommitProcessorsFacet's contributions). Same rationale as
+ *  AnyMutator — `unknown` doesn't compose cleanly under
+ *  contravariance, `any` is the conventional escape. */
+export type AnyPostCommitProcessor = PostCommitProcessor<any>;
+//# sourceMappingURL=processor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../../../../../../src/data/api/processor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAIzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC;;;;0EAI0E;AAE1E,MAAM,WAAW,2BAA2B;CAAkC;AAE9E,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,IAC3C,CAAC,SAAS,MAAM,2BAA2B,GACvC,2BAA2B,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAA;AAEb;;;;;;0CAM0C;AAC1C,MAAM,MAAM,gBAAgB,CAAC,aAAa,IACtC;IACE,OAAO,EAAE;QACP,IAAI,EAAE,OAAO,CAAA;QACb,KAAK,EAAE,QAAQ,CAAA;QACf,MAAM,EAAE,aAAa,CAAC,MAAM,SAAS,CAAC,CAAA;KACvC,CAAA;IACD,mBAAmB,CAAC,EAAE,KAAK,CAAA;CAC5B,GACD;IACE,OAAO,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAA;IAC7B,mBAAmB,EAAE,MAAM,CAAC,aAAa,CAAC,CAAA;CAC3C,CAAA;AAEL;;;;;;;;;;;;;;;wEAewE;AACxE,MAAM,MAAM,mBAAmB,CAAC,aAAa,GAAG,OAAO,IAAI;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,CACd,KAAK,EAAE,cAAc,CAAC,aAAa,CAAC,EACpC,GAAG,EAAE,YAAY,KACd,OAAO,CAAC,IAAI,CAAC,CAAA;CACnB,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAA;AAEnC;wEACwE;AACxE,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,SAAS,GAAG,IAAI,CAAA;IACxB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;CACxB;AAED;wCACwC;AACxC,MAAM,WAAW,cAAc,CAAC,aAAa,GAAG,OAAO;IACrD,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,IAAI,EAAE,IAAI,CAAA;IACV,WAAW,EAAE,MAAM,CAAA;IACnB,mDAAmD;IACnD,aAAa,CAAC,EAAE,aAAa,CAAA;CAC9B;AAED;;;;;gEAKgE;AAChE,MAAM,WAAW,eAAe;IAC9B,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;;;;;;;;;;;sEAWsE;AACtE,MAAM,WAAW,YAAY;IAC3B;;;8BAG0B;IAC1B,EAAE,EAAE,eAAe,CAAA;IACnB;0BACsB;IACtB,IAAI,EAAE,IAAI,CAAA;IACV;;wCAEoC;IACpC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;CACxD;AAED,eAAO,MAAM,yBAAyB,GAAI,aAAa,GAAG,SAAS,EACjE,WAAW,mBAAmB,CAAC,aAAa,CAAC,KAC5C,mBAAmB,CAAC,aAAa,CAAc,CAAA;AAElD;;;;wDAIwD;AAExD,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAA"}