@algomotion/spec 0.0.0-stage → 1.0.0-alpha.1

package/dist/kinds/array.d.ts

@@ -0,0 +1,171 @@
+/**
+ * The `array` structure kind: a sequence of elements with stable ids.
+ *
+ * Mark semantics (implemented by the core reducer, documented here because
+ * they are part of the protocol):
+ * - `compare`, `highlight` and the swap mark set by `swap` are transient:
+ *   they last for one step.
+ * - `pointer` and `settle` persist until changed.
+ *
+ * An array may carry a pattern (ADR 0037): a second row under the text,
+ * shifted so that its first element sits under text position `shift`.
+ * `align` moves it and `check` compares one of its elements with the text
+ * above; the reducer decides whether they match. The text is fixed while
+ * a pattern is aligned under it.
+ */
+import { z } from 'zod';
+import { Element } from '../common.ts';
+import { type DeclIssue, type KindSpec } from './kind.ts';
+/** @deprecated Use `Element`; kept as the array-specific name. */
+export declare const ArrayElement: z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>;
+export type ArrayElement = Element;
+/** Most elements a pattern holds. */
+export declare const MAX_PATTERN = 64;
+/** Canonical declaration: every element has an explicit id. */
+export declare const ArrayDecl: z.ZodObject<{
+    kind: z.ZodLiteral<"array">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    view: z.ZodOptional<z.ZodEnum<{
+        row: "row";
+        tree: "tree";
+        heap: "heap";
+    }>>;
+    initial: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>;
+    pattern: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>>;
+    shift: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type ArrayDecl = z.infer<typeof ArrayDecl>;
+/**
+ * Authoring declaration: `initial` may also be a list of bare values, which
+ * are given ids e0, e1, …
+ */
+export declare const ArrayDeclInput: z.ZodObject<{
+    kind: z.ZodLiteral<"array">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    view: z.ZodOptional<z.ZodEnum<{
+        row: "row";
+        tree: "tree";
+        heap: "heap";
+    }>>;
+    shift: z.ZodOptional<z.ZodInt>;
+    initial: z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>]>;
+    pattern: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>]>>;
+}, z.core.$strict>;
+export type ArrayDeclInput = z.infer<typeof ArrayDeclInput>;
+/** Expands the bare-value shorthand into explicit elements (ADR 0007). */
+export declare function normalizeArrayDecl(input: ArrayDeclInput): ArrayDecl;
+/** A pattern needs the row view, and its shift is within the text. */
+export declare function validateArrayDecl(decl: ArrayDecl): DeclIssue[];
+export declare const ArrayAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"set">;
+    index: z.ZodInt;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"swap">;
+    i: z.ZodInt;
+    j: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"insert">;
+    index: z.ZodInt;
+    element: z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"remove">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"compare">;
+    i: z.ZodInt;
+    j: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    indices: z.ZodArray<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    index: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"align">;
+    shift: z.ZodInt;
+    matched: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"check">;
+    j: z.ZodInt;
+}, z.core.$strict>], "type">;
+export type ArrayAction = z.infer<typeof ArrayAction>;
+/** Authoring actions: `insert` also accepts a bare value. */
+export declare const ArrayActionInput: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"set">;
+    index: z.ZodInt;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"swap">;
+    i: z.ZodInt;
+    j: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"insert">;
+    index: z.ZodInt;
+    element: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"remove">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"compare">;
+    i: z.ZodInt;
+    j: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    indices: z.ZodArray<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    index: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"align">;
+    shift: z.ZodInt;
+    matched: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"check">;
+    j: z.ZodInt;
+}, z.core.$strict>], "type">;
+export type ArrayActionInput = z.infer<typeof ArrayActionInput>;
+export declare const arraySpec: KindSpec<{
+    decl: ArrayDecl;
+    declInput: ArrayDeclInput;
+    action: ArrayAction;
+    actionInput: ArrayActionInput;
+}>;
+//# sourceMappingURL=array.d.ts.map

package/dist/kinds/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/kinds/array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,OAAO,EAQR,MAAM,cAAc,CAAC;AACtB,OAAO,EAAW,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEnE,kEAAkE;AAClE,eAAO,MAAM,YAAY;;;kBAAU,CAAC;AACpC,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC;AASnC,qCAAqC;AACrC,eAAO,MAAM,WAAW,KAAK,CAAC;AAW9B,+DAA+D;AAC/D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;kBAUY,CAAC;AACnC,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;kBAkBzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAoBnE;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,EAAE,CAoB9D;AA6DD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAmB,CAAC;AAC5C,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,6DAA6D;AAC7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAwB,CAAC;AACtD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,gBAAgB,CAAC;CAC/B,CA2BA,CAAC"}

package/dist/kinds/array.js

@@ -0,0 +1,179 @@
+/**
+ * The `array` structure kind: a sequence of elements with stable ids.
+ *
+ * Mark semantics (implemented by the core reducer, documented here because
+ * they are part of the protocol):
+ * - `compare`, `highlight` and the swap mark set by `swap` are transient:
+ *   they last for one step.
+ * - `pointer` and `settle` persist until changed.
+ *
+ * An array may carry a pattern (ADR 0037): a second row under the text,
+ * shifted so that its first element sits under text position `shift`.
+ * `align` moves it and `check` compares one of its elements with the text
+ * above; the reducer decides whether they match. The text is fixed while
+ * a pattern is aligned under it.
+ */
+import { z } from 'zod';
+import { Element, ElementInput, Index, isElement, LIMITS, Place, PointerName, Scalar, } from "../common.js";
+import { typesOf } from "./kind.js";
+/** @deprecated Use `Element`; kept as the array-specific name. */
+export const ArrayElement = Element;
+const View = z
+    .enum(['row', 'tree', 'heap'])
+    .optional()
+    .describe('How to draw the array: "row" (default); "tree", a complete binary tree where index i has children 2i+1 and 2i+2; or "heap", that tree with the row under it, both drawn from the one array, as textbooks draw heaps.');
+/** Most elements a pattern holds. */
+export const MAX_PATTERN = 64;
+const Shift = z
+    .int()
+    .min(0)
+    .max(LIMITS.elementsPerStructure)
+    .optional()
+    .describe('Text position under which the pattern starts, from 0 to the text length (default 0).');
+/** Canonical declaration: every element has an explicit id. */
+export const ArrayDecl = z
+    .strictObject({
+    kind: z.literal('array'),
+    label: z.string().max(LIMITS.textLength).optional(),
+    place: Place.optional(),
+    view: View,
+    initial: z.array(Element).max(LIMITS.elementsPerStructure),
+    pattern: z.array(Element).min(1).max(MAX_PATTERN).optional(),
+    shift: Shift,
+})
+    .describe('An array structure.');
+/**
+ * Authoring declaration: `initial` may also be a list of bare values, which
+ * are given ids e0, e1, …
+ */
+export const ArrayDeclInput = ArrayDecl.extend({
+    initial: z
+        .union([
+        z.array(Element).max(LIMITS.elementsPerStructure),
+        z.array(Scalar).max(LIMITS.elementsPerStructure),
+    ])
+        .describe('Initial contents: either bare values like [5, 3, 8] (ids "e0", "e1", … are generated) or elements like [{ "id": "a", "value": 5 }].'),
+    pattern: z
+        .union([
+        z.array(Element).min(1).max(MAX_PATTERN),
+        z.array(Scalar).min(1).max(MAX_PATTERN),
+    ])
+        .optional()
+        .describe('A pattern drawn under the text at `shift`, for string matching: values (ids "p0", "p1", … are generated) or elements.'),
+});
+/** Expands the bare-value shorthand into explicit elements (ADR 0007). */
+export function normalizeArrayDecl(input) {
+    const initial = input.initial.map((x, k) => isElement(x) ? x : { id: `e${k}`, value: x });
+    const { pattern: given, ...rest } = input;
+    if (given === undefined)
+        return { ...rest, initial };
+    // Generated pattern ids skip the ids already written.
+    const taken = new Set([
+        ...initial.map((e) => e.id),
+        ...given.filter(isElement).map((e) => e.id),
+    ]);
+    let next = 0;
+    const fresh = () => {
+        while (taken.has(`p${next}`))
+            next++;
+        return `p${next++}`;
+    };
+    const pattern = given.map((x) => isElement(x) ? x : { id: fresh(), value: x });
+    return { ...rest, initial, pattern };
+}
+/** A pattern needs the row view, and its shift is within the text. */
+export function validateArrayDecl(decl) {
+    const issues = [];
+    if (decl.pattern !== undefined && (decl.view ?? 'row') !== 'row')
+        issues.push({
+            path: ['pattern'],
+            message: `A pattern is drawn under a row; the "${decl.view}" view has none`,
+            hint: 'Leave out `view`, or set it to "row".',
+        });
+    if (decl.shift !== undefined && decl.pattern === undefined)
+        issues.push({
+            path: ['shift'],
+            message: 'A shift places a pattern, and this array has none',
+        });
+    if ((decl.shift ?? 0) > decl.initial.length)
+        issues.push({
+            path: ['shift'],
+            message: `The shift is ${decl.shift}, past the text of ${decl.initial.length} elements`,
+            hint: `Valid shifts are 0 to ${decl.initial.length}.`,
+        });
+    return issues;
+}
+const Indices = z.array(Index).min(1).max(LIMITS.elementsPerStructure);
+const actions = (element) => z.discriminatedUnion('type', [
+    // Actions that change data.
+    z
+        .strictObject({ type: z.literal('set'), index: Index, value: Scalar })
+        .describe('Replace the value at `index`; the element keeps its id.'),
+    z
+        .strictObject({ type: z.literal('swap'), i: Index, j: Index })
+        .describe('Swap the elements at positions `i` and `j`, marking both as swapped for this step.'),
+    z
+        .strictObject({ type: z.literal('insert'), index: Index, element })
+        .describe('Insert `element` before position `index`; `index` equal to the length appends.'),
+    z
+        .strictObject({ type: z.literal('remove'), index: Index })
+        .describe('Remove the element at `index`.'),
+    // Actions that only change marks.
+    z
+        .strictObject({ type: z.literal('compare'), i: Index, j: Index })
+        .describe('Mark positions `i` and `j` as being compared (this step only).'),
+    z
+        .strictObject({ type: z.literal('highlight'), indices: Indices })
+        .describe('Highlight the given positions (this step only).'),
+    z
+        .strictObject({
+        type: z.literal('pointer'),
+        name: PointerName,
+        index: Index.nullable(),
+    })
+        .describe('Point the named pointer (e.g. "i", "lo") at `index`; null removes it.'),
+    z
+        .strictObject({ type: z.literal('settle'), index: Index })
+        .describe('Mark the element at `index` as in its final position.'),
+    // Actions on the pattern (ADR 0037).
+    z
+        .strictObject({
+        type: z.literal('align'),
+        shift: z.int().min(0).max(LIMITS.elementsPerStructure),
+        matched: z.int().min(0).max(MAX_PATTERN).optional(),
+    })
+        .describe('Move the pattern so that its first element is under text position `shift`; its first `matched` elements (default 0) are marked as matched, and must equal the text above them.'),
+    z
+        .strictObject({ type: z.literal('check'), j: Index })
+        .describe('Compare pattern element `j` with the text element above it (position shift + j): both are marked as compared in this step, and if they are equal, `j` is marked as matched until the next `align`.'),
+]);
+export const ArrayAction = actions(Element);
+/** Authoring actions: `insert` also accepts a bare value. */
+export const ArrayActionInput = actions(ElementInput);
+export const arraySpec = {
+    kind: 'array',
+    decl: ArrayDecl,
+    declInput: ArrayDeclInput,
+    action: ArrayAction,
+    actionInput: ArrayActionInput,
+    actionTypes: typesOf(ArrayAction),
+    normalizeDecl: normalizeArrayDecl,
+    declIds: (decl) => [
+        ...decl.initial.map((e, k) => ({ id: e.id, path: ['initial', k, 'id'] })),
+        ...(decl.pattern ?? []).map((e, k) => ({
+            id: e.id,
+            path: ['pattern', k, 'id'],
+        })),
+    ],
+    validateDecl: validateArrayDecl,
+    normalizeAction: (action, ctx) => action.type === 'insert' && !isElement(action.element)
+        ? {
+            ...action,
+            element: { id: ctx.allocateId('e'), value: action.element },
+        }
+        : action,
+    introducedIds: (action) => action.type === 'insert'
+        ? [{ id: action.element.id, path: ['element', 'id'] }]
+        : [],
+};
+//# sourceMappingURL=array.js.map

package/dist/kinds/array.js.map

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

package/dist/kinds/btree.d.ts

@@ -0,0 +1,190 @@
+/**
+ * The `btree` kind (ADR 0035): multiway search trees whose nodes hold
+ * several keys in order, such as B-trees and 2-3-4 trees. A node has no
+ * children (a leaf) or one more than its keys; child `i` hangs from the
+ * gap left of key `i`. Keys are elements: they keep their ids when they
+ * move between nodes, so a drawing can follow them.
+ *
+ * A tree always has a root: an empty tree is a root leaf with no keys, as
+ * CLRS's B-TREE-CREATE makes it. The kind enforces no minimum degree, no
+ * key order and no level leaves: recipes keep those rules. Every action
+ * keeps the shape valid.
+ *
+ * Marks: `highlight` lasts one step; `settle`, `pointer` and `annotate`
+ * persist.
+ */
+import { z } from 'zod';
+import { type DeclIssue, type KindSpec } from './kind.ts';
+/** Most keys one node holds. */
+export declare const MAX_NODE_KEYS = 32;
+export declare const BTreeNode: z.ZodObject<{
+    id: z.ZodString;
+    keys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type BTreeNode = z.infer<typeof BTreeNode>;
+/** Canonical declaration. */
+export declare const BTreeDecl: z.ZodObject<{
+    kind: z.ZodLiteral<"btree">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        keys: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strict>>;
+        children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    root: z.ZodString;
+}, z.core.$strict>;
+export type BTreeDecl = z.infer<typeof BTreeDecl>;
+export declare const BTreeDeclInput: z.ZodObject<{
+    kind: z.ZodLiteral<"btree">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        keys: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strict>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>]>>;
+        children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    root: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BTreeDeclInput = z.infer<typeof BTreeDeclInput>;
+/** Shape rules: size, child counts, one parent each, one root, no cycles. */
+export declare function validateBTreeDecl(decl: BTreeDecl): DeclIssue[];
+export declare const BTreeAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"insertKey">;
+    node: z.ZodString;
+    index: z.ZodInt;
+    key: z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removeKey">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"setKey">;
+    key: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"lift">;
+    key: z.ZodString;
+    over: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"split">;
+    node: z.ZodString;
+    index: z.ZodInt;
+    newNode: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"grow">;
+    newRoot: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"merge">;
+    node: z.ZodString;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"shrink">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"borrow">;
+    node: z.ZodString;
+    child: z.ZodInt;
+    from: z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    node: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"annotate">;
+    node: z.ZodString;
+    text: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>], "type">;
+export type BTreeAction = z.infer<typeof BTreeAction>;
+export declare const BTreeActionInput: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"insertKey">;
+    node: z.ZodString;
+    index: z.ZodInt;
+    key: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removeKey">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"setKey">;
+    key: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"lift">;
+    key: z.ZodString;
+    over: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"split">;
+    node: z.ZodString;
+    index: z.ZodInt;
+    newNode: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"grow">;
+    newRoot: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"merge">;
+    node: z.ZodString;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"shrink">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"borrow">;
+    node: z.ZodString;
+    child: z.ZodInt;
+    from: z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    node: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"annotate">;
+    node: z.ZodString;
+    text: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>], "type">;
+export type BTreeActionInput = z.infer<typeof BTreeActionInput>;
+export declare const btreeSpec: KindSpec<{
+    decl: BTreeDecl;
+    declInput: BTreeDeclInput;
+    action: BTreeAction;
+    actionInput: BTreeActionInput;
+}>;
+//# sourceMappingURL=btree.d.ts.map

package/dist/kinds/btree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"btree.d.ts","sourceRoot":"","sources":["../../src/kinds/btree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,OAAO,EAAW,KAAK,SAAS,EAAc,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE/E,gCAAgC;AAChC,eAAO,MAAM,aAAa,KAAK,CAAC;AAOhC,eAAO,MAAM,SAAS;;;;;;;kBAMoC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAiBlD,6BAA6B;AAC7B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;kBAQkC,CAAC;AACzD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;kBAe6B,CAAC;AACzD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAgC5D,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,EAAE,CAyE9D;AA4FD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAmB,CAAC;AAC5C,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAwB,CAAC;AACtD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,gBAAgB,CAAC;CAC/B,CA6BA,CAAC"}