@coldsmirk/abacus-core 0.9.0 → 0.10.0

package/README.md

@@ -9,7 +9,7 @@ Part of [abacus](https://github.com/coldsmirk/abacus). To edit expressions in an
 - **Evaluate** ZEN expressions against a data context, sync or async.
 - **Compile** a structured, UI-authored condition tree into a single ZEN boolean expression — and **lift** the canonical form back into a tree for round-trip editing — plus **select** a matching branch by priority.
 - **Type-analyze** an expression against a variable-context type tree — the inferred type of every span, autocomplete metadata, and positioned diagnostics that power an editor.
-- **Project and infer JSON Schema** through a lossless field-tree subset, then turn that tree into an expression variable type.
+- **Project a JSON Schema field tree** — a [caliper](https://github.com/coldsmirk/caliper) `SchemaTree` — onto an expression variable type.
 - **Localize** all editor-produced text through a typed, extensible message catalog.
 - **Strong typing** end to end, dual ESM / CJS, and a single lazily-loaded WebAssembly engine instance.
 
@@ -19,7 +19,7 @@ Part of [abacus](https://github.com/coldsmirk/abacus). To edit expressions in an
 pnpm add @coldsmirk/abacus-core
 ```
 
-The ZEN WebAssembly engine (`@gorules/zen-engine-wasm`) is a regular dependency and installs automatically. Node.js >= 24; browsers need ES2023 support (Chrome/Edge 111+, Safari 16.2+, Firefox 115+) — the bundles ship untranspiled.
+The ZEN WebAssembly engine (`@gorules/zen-engine-wasm`) and the schema-tree model (`@coldsmirk/caliper-core`, whose `SchemaTree` appears in this package's public surface) are regular dependencies and install automatically. Node.js >= 24; browsers need ES2023 support (Chrome/Edge 111+, Safari 16.2+, Firefox 115+) — the bundles ship untranspiled.
 
 ## Quick start
 
@@ -216,46 +216,30 @@ interface ExpressionCompletion {
 
 ## JSON Schema field trees
 
-The schema helpers provide the data model behind a visual JSON Schema builder without depending on a UI framework. The tree hosts an object-oriented draft 2020-12 subset: `type`, `properties`, `items`, `required`, and `description`, plus the optional root `$schema` declaration. Parsing refuses every unsupported construct with a structured `SchemaTreeIssue`; it never accepts a keyword and then silently removes it on serialization.
+The field-tree model itself lives in [`@coldsmirk/caliper-core`](https://www.npmjs.com/package/@coldsmirk/caliper-core) — `parseSchemaTree`, `serializeSchemaTree`, `inferSchema`, `newSchemaTreeField`, and the `SchemaTree*` types (with `<SchemaBuilder>` / `<JsonBuilder>` in `@coldsmirk/caliper-mantine`). This package owns only the bridge to ZEN: `schemaTreeToExpressionType` turns a `SchemaTree` into the variable type an expression is analyzed against.
 
 ```ts
-import {
-  inferSchema,
-  parseSchemaTree,
-  schemaTreeToExpressionType,
-  serializeSchemaTree
-} from "@coldsmirk/abacus-core";
-
-const inferred = inferSchema({
+import { schemaTreeToExpressionType } from "@coldsmirk/abacus-core";
+import { inferSchema, parseSchemaTree } from "@coldsmirk/caliper-core";
+
+const parsed = parseSchemaTree(JSON.stringify(inferSchema({
   amount: 120,
   customer: { name: "Ada" },
   tags: ["priority"]
-});
-
-const parsed = parseSchemaTree(JSON.stringify(inferred));
+})));
 
 if (parsed.ok) {
-  serializeSchemaTree(parsed.tree);               // pretty-printed schema JSON
   schemaTreeToExpressionType(parsed.tree);        // { Object: { amount: "Number", ... } }
-} else {
-  parsed.issue;                                   // a localizable SchemaTreeIssue
 }
 ```
 
 ```ts
-function inferSchema(sample: Json): Record<string, Json>;
-function parseSchemaTree(text: string): SchemaTreeParseResult;
-function serializeSchemaTree(tree: SchemaTree): string;
 function schemaTreeToExpressionType(tree: SchemaTree): ExpressionType;
-function newSchemaTreeField(overrides?: Partial<Omit<SchemaTreeField, "id">>): SchemaTreeField;
-const SCHEMA_DIALECT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
 ```
 
-`inferSchema` is intentionally conservative: integer samples infer `number`, no property becomes `required` from one observation, `null` says nothing (`{}`), and heterogeneous arrays merge to the loosest schema the field-tree subset can express.
-
-The parser preserves JSON Schema applicability, not merely its visible fields. A schema with `properties` or `items` but no `type` still permits instances of other types, so `SchemaTree.explicitType` and an object/array field's `explicitType` remember that omission and serialization does not add an object/array type. Hand-built trees that omit the optional metadata keep the original builder default and emit an explicit type.
+`SchemaTree` is imported from `@coldsmirk/caliper-core` — a regular dependency of this package, so the emitted types resolve on install — and is deliberately **not** re-exported here: a caller holding a tree already imports the module that produced it.
 
-Property names are arbitrary JSON strings. Empty, whitespace-only, and prototype-like names such as `__proto__` round-trip and enter the generated `ExpressionType`. A parsed blank name carries `preserveBlankName: true`; a blank row from `newSchemaTreeField()` has no marker and remains an unfinished UI draft that is omitted from serialization and expression types. Hosts editing a parsed tree should update nodes immutably (for example, with object spread) so these optional source-preservation fields survive.
+Every named field becomes a typed variable: `string` → `String`, `number` / `integer` → `Number`, `boolean` → `Bool`, `object` → a nested `Object`, `array` → `Array` (elements `Any` when the source declared no `items`), and an untyped field → `Any`. Blank draft rows from `newSchemaTreeField()` are skipped, while blank and prototype-like property names that came from real `properties` keys (carrying caliper's `preserveBlankName`) stay in the scope.
 
 ## Compiling conditions
 
@@ -483,10 +467,10 @@ class ExpressionNotReadyError extends ExpressionError {  // a *Sync helper calle
 - **Templates** — `analyzeTemplate` / `analyzeTemplateSync`, `getTemplateDiagnostics` / `getTemplateDiagnosticsSync`, `parseTemplateHoles`, `templateHoleAt`
 - **Conditions** — `compileCondition`, `compileGroup`, `compileBranch`, `selectBranch`, `selectBranchWith`, `toZenLiteral`, `isZenRepresentableNumber`, `CONDITION_OPERATORS`, `conditionOperatorArity`
 - **Condition trees** — `compileConditionTree`, `liftConditionTree`, `emptyConditionGroup`, `newConditionNodeId`, `ensureConditionNodeIds`, `MAX_CONDITION_TREE_DEPTH`, `CONDITION_TREE_OPERATORS`
-- **JSON Schema** — `inferSchema`, `parseSchemaTree`, `serializeSchemaTree`, `schemaTreeToExpressionType`, `newSchemaTreeField`, `SCHEMA_DIALECT_2020_12`
+- **JSON Schema** — `schemaTreeToExpressionType` (the model itself is `@coldsmirk/caliper-core`)
 - **Localization** — `configureExpressionMessages`, `registerExpressionLocale`, `getExpressionMessages`, `subscribeExpressionMessages`, `enMessages`, `zhCNMessages`
 - **Errors** — `ExpressionError`, `ExpressionNotReadyError`
-- **Types** — `ExpressionType`, `ExpressionMode`, `TemplateHole`, `ExpressionContext`, `ExpressionEngine`, `LoadEngineOptions`, `ExpressionAnalysis`, `ExpressionTypeSpan`, `ExpressionCompletion`, `ExpressionDiagnostic`, `ExpressionMessages`, `ExpressionMessagesListener`, `ExpressionLocale`, `BuiltInExpressionLocale`, `ConfigureMessagesOptions`, `ConditionInput`, `FieldConditionInput`, `ExpressionConditionInput`, `ConditionGroupInput`, `ConditionBranchInput`, `ConditionOperator`, `ConditionOperatorArity`, `BranchSelection`, `ConditionTreeGroup`, `ConditionTreeNode`, `ConditionTreeRule`, `ConditionTreeOperator`, `ConditionTreeValue`, `ConditionScalar`, `Json`, `SchemaTree`, `SchemaTreeField`, `SchemaTreeFieldType`, `SchemaTreeIssue`, `SchemaTreeParseResult`
+- **Types** — `ExpressionType`, `ExpressionMode`, `TemplateHole`, `ExpressionContext`, `ExpressionEngine`, `LoadEngineOptions`, `ExpressionAnalysis`, `ExpressionTypeSpan`, `ExpressionCompletion`, `ExpressionDiagnostic`, `ExpressionMessages`, `ExpressionMessagesListener`, `ExpressionLocale`, `BuiltInExpressionLocale`, `ConfigureMessagesOptions`, `ConditionInput`, `FieldConditionInput`, `ExpressionConditionInput`, `ConditionGroupInput`, `ConditionBranchInput`, `ConditionOperator`, `ConditionOperatorArity`, `BranchSelection`, `ConditionTreeGroup`, `ConditionTreeNode`, `ConditionTreeRule`, `ConditionTreeOperator`, `ConditionTreeValue`, `ConditionScalar`
 
 ## License
 

package/dist/index.cjs

@@ -1258,6 +1258,23 @@ async function satisfiesType(actual, expected) {
 function satisfiesTypeSync(actual, expected) {
 	return getEngineSync().satisfies(actual, expected);
 }
+function fieldType(field) {
+	switch (field.type) {
+		case "string": return "String";
+		case "number": return "Number";
+		case "integer": return "Number";
+		case "boolean": return "Bool";
+		case "object": return { Object: fieldRecord(field.children) };
+		case "array": return { Array: field.items === null ? "Any" : fieldType(field.items) };
+		case "any": return "Any";
+	}
+}
+function fieldRecord(fields) {
+	return Object.fromEntries(fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true).map((field) => [field.name, fieldType(field)]));
+}
+function schemaTreeToExpressionType(tree) {
+	return { Object: fieldRecord(tree.fields) };
+}
 const HOLE_PATTERN = /\{\{(?<expression>[^{}]*)\}\}/g;
 function parseTemplateHoles(source) {
 	const holes = [];
@@ -1318,301 +1335,11 @@ async function getTemplateDiagnostics(source) {
 	await loadEngine();
 	return getTemplateDiagnosticsSync(source);
 }
-function fieldType(field) {
-	switch (field.type) {
-		case "string": return "String";
-		case "number": return "Number";
-		case "integer": return "Number";
-		case "boolean": return "Bool";
-		case "object": return { Object: fieldRecord(field.children) };
-		case "array": return { Array: field.items === null ? "Any" : fieldType(field.items) };
-		case "any": return "Any";
-	}
-}
-function fieldRecord(fields) {
-	return Object.fromEntries(fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true).map((field) => [field.name, fieldType(field)]));
-}
-function schemaTreeToExpressionType(tree) {
-	return { Object: fieldRecord(tree.fields) };
-}
-function mergeSchemas(a, b) {
-	if (a.type === "object" && b.type === "object") {
-		const left = a.properties ?? {};
-		const right = b.properties ?? {};
-		const entries = [];
-		const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
-		for (const key of keys) {
-			const hasLeft = Object.hasOwn(left, key);
-			const hasRight = Object.hasOwn(right, key);
-			entries.push([key, hasLeft && hasRight ? mergeSchemas(left[key], right[key]) : hasLeft ? left[key] : right[key]]);
-		}
-		const properties = Object.fromEntries(entries);
-		return Object.keys(properties).length > 0 ? {
-			type: "object",
-			properties
-		} : { type: "object" };
-	}
-	if (a.type === "array" && b.type === "array") return a.items !== void 0 && b.items !== void 0 ? {
-		type: "array",
-		items: mergeSchemas(a.items, b.items)
-	} : { type: "array" };
-	return JSON.stringify(a) === JSON.stringify(b) ? a : {};
-}
-function inferSchema(sample) {
-	if (sample === null) return {};
-	if (Array.isArray(sample)) {
-		if (sample.length === 0) return { type: "array" };
-		return {
-			type: "array",
-			items: sample.map((element) => inferSchema(element)).reduce((left, right) => mergeSchemas(left, right))
-		};
-	}
-	if (typeof sample === "string") return { type: "string" };
-	if (typeof sample === "number") return { type: "number" };
-	if (typeof sample === "boolean") return { type: "boolean" };
-	const properties = Object.fromEntries(Object.entries(sample).map(([key, value]) => [key, inferSchema(value)]));
-	return Object.keys(properties).length > 0 ? {
-		type: "object",
-		properties
-	} : { type: "object" };
-}
-const SCHEMA_DIALECT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
-const fieldIdRealm = Math.random().toString(36).slice(2, 7);
-let fieldIdCounter = 0;
-function newSchemaTreeField(overrides = {}) {
-	fieldIdCounter += 1;
-	return {
-		id: `sf-${fieldIdRealm}-${fieldIdCounter}`,
-		name: "",
-		type: "string",
-		required: false,
-		description: "",
-		children: [],
-		items: null,
-		...overrides
-	};
-}
-const SCALAR_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"boolean"
-]);
-const ROOT_KEYS = new Set([
-	"$schema",
-	"type",
-	"properties",
-	"required",
-	"description"
-]);
-const SUBSCHEMA_KEYS = new Set([
-	"type",
-	"properties",
-	"required",
-	"items",
-	"description"
-]);
-var Unsupported = class extends Error {
-	issue;
-	constructor(issue) {
-		super(issue.code);
-		this.issue = issue;
-	}
-};
-function asPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-}
-function checkKeys(schema, allowed) {
-	for (const key of Object.keys(schema)) if (!allowed.has(key)) throw new Unsupported({
-		code: "unsupported-keyword",
-		keyword: key
-	});
-}
-function parseObjectFields(schema) {
-	const properties = schema.properties === void 0 ? null : asPlainObject(schema.properties);
-	if (schema.properties !== void 0 && properties === null) throw new Unsupported({ code: "invalid-properties" });
-	const fields = [];
-	const entries = Object.entries(properties ?? {});
-	for (const [name, subschema] of entries) fields.push({
-		...parseSubschema(subschema, name),
-		name,
-		...name.trim() === "" && { preserveBlankName: true }
-	});
-	if (schema.required !== void 0) {
-		if (!Array.isArray(schema.required)) throw new Unsupported({ code: "invalid-required" });
-		for (const entry of schema.required) {
-			if (typeof entry !== "string") throw new Unsupported({ code: "invalid-required" });
-			const field = fields.find((candidate) => candidate.name === entry);
-			if (field === void 0) throw new Unsupported({
-				code: "unknown-required-field",
-				field: entry
-			});
-			field.required = true;
-		}
-	}
-	return fields;
-}
-function parseDescription(schema) {
-	if (schema.description === void 0) return "";
-	if (typeof schema.description !== "string") throw new Unsupported({ code: "invalid-description" });
-	return schema.description;
-}
-function ensureAbsent(schema, key, holder) {
-	if (schema[key] !== void 0) throw new Unsupported({
-		code: "misplaced-keyword",
-		keyword: key,
-		holder
-	});
-}
-function parseSubschema(value, name) {
-	const schema = asPlainObject(value);
-	if (schema === null) throw new Unsupported({
-		code: "invalid-field-definition",
-		field: name
-	});
-	checkKeys(schema, SUBSCHEMA_KEYS);
-	const { type } = schema;
-	if (type !== void 0 && typeof type !== "string") throw new Unsupported({
-		code: "invalid-field-type",
-		field: name
-	});
-	const description = parseDescription(schema);
-	if (type === "object" || type === void 0 && (schema.properties !== void 0 || schema.required !== void 0)) {
-		ensureAbsent(schema, "items", "array");
-		return newSchemaTreeField({
-			type: "object",
-			description,
-			children: parseObjectFields(schema),
-			explicitType: type === "object"
-		});
-	}
-	if (type === "array" || type === void 0 && schema.items !== void 0) {
-		ensureAbsent(schema, "properties", "object");
-		ensureAbsent(schema, "required", "object");
-		return newSchemaTreeField({
-			type: "array",
-			description,
-			items: schema.items === void 0 ? null : parseSubschema(schema.items, name),
-			explicitType: type === "array"
-		});
-	}
-	if (type === void 0) {
-		ensureAbsent(schema, "items", "array");
-		return newSchemaTreeField({
-			type: "any",
-			description
-		});
-	}
-	if (!SCALAR_TYPES.has(type)) throw new Unsupported({
-		code: "unsupported-field-type",
-		field: name,
-		type
-	});
-	ensureAbsent(schema, "properties", "object");
-	ensureAbsent(schema, "required", "object");
-	ensureAbsent(schema, "items", "array");
-	return newSchemaTreeField({
-		type,
-		description
-	});
-}
-function parseSchemaTree(text) {
-	if (text.trim() === "") return {
-		ok: true,
-		tree: {
-			fields: [],
-			dialect: false,
-			description: ""
-		}
-	};
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch {
-		return {
-			ok: false,
-			issue: { code: "invalid-json" }
-		};
-	}
-	try {
-		const root = asPlainObject(parsed);
-		if (root === null) throw new Unsupported({ code: "root-not-object" });
-		checkKeys(root, ROOT_KEYS);
-		const dialect = root.$schema !== void 0;
-		if (dialect && root.$schema !== "https://json-schema.org/draft/2020-12/schema") throw new Unsupported({ code: "unsupported-dialect" });
-		if (root.type !== void 0 && root.type !== "object") throw new Unsupported({ code: "root-not-object" });
-		return {
-			ok: true,
-			tree: {
-				fields: parseObjectFields(root),
-				dialect,
-				description: parseDescription(root),
-				explicitType: root.type === "object"
-			}
-		};
-	} catch (error) {
-		if (error instanceof Unsupported) return {
-			ok: false,
-			issue: error.issue
-		};
-		throw error;
-	}
-}
-function serializeObjectBody(fields) {
-	const named = fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true);
-	const finalByName = /* @__PURE__ */ new Map();
-	const finalFields = [];
-	const body = {};
-	for (const field of named) finalByName.set(field.name, field);
-	finalByName.forEach((field) => {
-		finalFields.push(field);
-	});
-	if (finalFields.length > 0) body.properties = Object.fromEntries(finalFields.map((field) => [field.name, serializeField(field)]));
-	const required = finalFields.filter((field) => field.required).map((field) => field.name);
-	if (required.length > 0) body.required = required;
-	return body;
-}
-function serializeField(field) {
-	const description = field.description === "" ? {} : { description: field.description };
-	switch (field.type) {
-		case "any": return { ...description };
-		case "object": return {
-			...field.explicitType !== false && { type: "object" },
-			...description,
-			...serializeObjectBody(field.children)
-		};
-		case "array": {
-			const type = field.explicitType === false ? {} : { type: "array" };
-			return field.items === null || field.items.type === "any" && field.items.description === "" ? {
-				...type,
-				...description
-			} : {
-				...type,
-				...description,
-				items: serializeField(field.items)
-			};
-		}
-		default: return {
-			type: field.type,
-			...description
-		};
-	}
-}
-function serializeSchemaTree(tree) {
-	const root = {
-		...tree.dialect && { $schema: "https://json-schema.org/draft/2020-12/schema" },
-		...tree.explicitType !== false && { type: "object" },
-		...tree.description !== "" && { description: tree.description },
-		...serializeObjectBody(tree.fields)
-	};
-	return `${JSON.stringify(root, null, 2)}\n`;
-}
 exports.CONDITION_OPERATORS = CONDITION_OPERATORS;
 exports.CONDITION_TREE_OPERATORS = CONDITION_TREE_OPERATORS;
 exports.ExpressionError = ExpressionError;
 exports.ExpressionNotReadyError = ExpressionNotReadyError;
 exports.MAX_CONDITION_TREE_DEPTH = MAX_CONDITION_TREE_DEPTH;
-exports.SCHEMA_DIALECT_2020_12 = SCHEMA_DIALECT_2020_12;
 exports.analyzeTemplate = analyzeTemplate;
 exports.analyzeTemplateSync = analyzeTemplateSync;
 exports.analyzeTypes = analyzeTypes;
@@ -1640,14 +1367,11 @@ exports.getEngineSync = getEngineSync;
 exports.getExpressionMessages = getExpressionMessages;
 exports.getTemplateDiagnostics = getTemplateDiagnostics;
 exports.getTemplateDiagnosticsSync = getTemplateDiagnosticsSync;
-exports.inferSchema = inferSchema;
 exports.isEngineReady = isEngineReady;
 exports.isZenRepresentableNumber = isZenRepresentableNumber;
 exports.liftConditionTree = liftConditionTree;
 exports.loadEngine = loadEngine;
 exports.newConditionNodeId = newConditionNodeId;
-exports.newSchemaTreeField = newSchemaTreeField;
-exports.parseSchemaTree = parseSchemaTree;
 exports.parseTemplateHoles = parseTemplateHoles;
 exports.registerExpressionLocale = registerExpressionLocale;
 exports.resetEngine = resetEngine;
@@ -1656,7 +1380,6 @@ exports.satisfiesTypeSync = satisfiesTypeSync;
 exports.schemaTreeToExpressionType = schemaTreeToExpressionType;
 exports.selectBranch = selectBranch;
 exports.selectBranchWith = selectBranchWith;
-exports.serializeSchemaTree = serializeSchemaTree;
 exports.subscribeExpressionMessages = subscribeExpressionMessages;
 exports.templateHoleAt = templateHoleAt;
 exports.toZenLiteral = toZenLiteral;

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 import { InitInput } from "@gorules/zen-engine-wasm";
+import { SchemaTree } from "@coldsmirk/caliper-core";
 
 /**
  * How an expression editor interprets its document:
@@ -669,6 +670,13 @@ declare function getExpressionMessages(): ExpressionMessages;
  * function; listeners run synchronously after the new catalog becomes active.
  */
 declare function subscribeExpressionMessages(listener: ExpressionMessagesListener): () => void;
+/**
+ * The expression scope a schema tree declares: each named field becomes a typed variable, so a
+ * host can hand the result straight to `<ExpressionInput variables={…}>` (or `analyzeTypes`)
+ * and complete against the declared shape. Blank draft rows are skipped, while blank property
+ * names preserved by `@coldsmirk/caliper-core`'s `parseSchemaTree` remain part of the scope.
+ */
+declare function schemaTreeToExpressionType(tree: SchemaTree): ExpressionType;
 /**
  * One `{{ expression }}` hole located in a template document. `from` / `to` are
  * the character offsets of the inner expression itself — the text between the
@@ -735,158 +743,4 @@ declare function getTemplateDiagnosticsSync(source: string): ExpressionDiagnosti
  * Async {@link getTemplateDiagnosticsSync}, loading the engine on first use.
  */
 declare function getTemplateDiagnostics(source: string): Promise<ExpressionDiagnostic[]>;
-/**
- * The field-tree model behind the visual JSON Schema builder: a lossless projection of the
- * JSON Schema subset the tree can host (`type` / `properties` / `items`, plus `required`).
- * The schema JSON stays the single source of truth: {@link parseSchemaTree} REFUSES anything
- * outside the subset (never a lossy rewrite), so a hand-written `oneOf` or `format` keeps its
- * document JSON-only instead of silently vanishing on the first visual edit.
- */
-/**
- * The one dialect the tree round-trips: a document may omit `$schema` or declare exactly this.
- */
-declare const SCHEMA_DIALECT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
-type SchemaTreeFieldType = "any" | "array" | "boolean" | "integer" | "number" | "object" | "string";
-interface SchemaTreeField {
-  /**
-   * Stable row identity for React keys and targeted edits — a UI concern, never serialized.
-   */
-  id: string;
-  /**
-   * The property name under its parent object; unused on an array-element node.
-   */
-  name: string;
-  type: SchemaTreeFieldType;
-  /**
-   * Listed in the parent object's `required`; unused on an array-element node.
-   */
-  required: boolean;
-  /**
-   * The schema's `description` annotation; blank means none (not serialized).
-   */
-  description: string;
-  /**
-   * Sub-fields, meaningful when `type` is `object`.
-   */
-  children: SchemaTreeField[];
-  /**
-   * The element node, meaningful when `type` is `array`; `null` means untyped elements.
-   */
-  items: SchemaTreeField | null;
-  /**
-   * For an object or array node parsed from JSON, whether its source explicitly
-   * declared that type. `false` preserves a type-less applicator; omitted keeps the
-   * historical hand-built-tree default of emitting the type.
-   */
-  explicitType?: boolean;
-  /**
-   * Whether a blank / whitespace-only name came from a real `properties` key and must be
-   * persisted. Omitted blank names are unfinished UI rows and do not serialize.
-   */
-  preserveBlankName?: boolean;
-}
-interface SchemaTree {
-  fields: SchemaTreeField[];
-  /**
-   * Whether the source declared `$schema` (re-emitted verbatim on serialize).
-   */
-  dialect: boolean;
-  /**
-   * The root schema's `description` annotation, preserved verbatim across the round trip
-   * (the field view offers no root-level editor); blank means none.
-   */
-  description: string;
-  /**
-   * For a tree parsed from JSON, whether the root explicitly declared `type: "object"`.
-   * `false` preserves a type-less root; omitted keeps the historical hand-built-tree default
-   * of emitting the type.
-   */
-  explicitType?: boolean;
-}
-/**
- * Why a document cannot be projected onto the field tree — structured so a UI can localize
- * the explanation. Every code names the offending part where one exists.
- */
-type SchemaTreeIssue = {
-  code: "invalid-description";
-} | {
-  code: "invalid-field-definition";
-  field: string;
-} | {
-  code: "invalid-field-type";
-  field: string;
-} | {
-  code: "invalid-json";
-} | {
-  code: "invalid-properties";
-} | {
-  code: "invalid-required";
-} | {
-  code: "misplaced-keyword";
-  keyword: string;
-  holder: "array" | "object";
-} | {
-  code: "root-not-object";
-} | {
-  code: "unknown-required-field";
-  field: string;
-} | {
-  code: "unsupported-dialect";
-} | {
-  code: "unsupported-field-type";
-  field: string;
-  type: string;
-} | {
-  code: "unsupported-keyword";
-  keyword: string;
-};
-type SchemaTreeParseResult = {
-  ok: true;
-  tree: SchemaTree;
-} | {
-  ok: false;
-  issue: SchemaTreeIssue;
-};
-/**
- * A fresh {@link SchemaTreeField}, defaulting to an optional unnamed string field. The id is a
- * tagged counter, not a UUID: field identity is a UI concern with no persistence or
- * cross-process meaning — exactly the guarantee a React key needs.
- */
-declare function newSchemaTreeField(overrides?: Partial<Omit<SchemaTreeField, "id">>): SchemaTreeField;
-/**
- * The expression scope a schema tree declares: each named field becomes a typed variable, so a
- * host can hand the result straight to `<ExpressionInput variables={…}>` (or `analyzeTypes`)
- * and complete against the declared shape. Blank draft rows are skipped, while blank property
- * names preserved by {@link parseSchemaTree} remain part of the scope.
- */
-declare function schemaTreeToExpressionType(tree: SchemaTree): ExpressionType;
-/**
- * Infer a draft 2020-12 JSON Schema from a sample payload — the "generate from example" path of
- * the visual schema builder. Deliberately emits only the subset {@link parseSchemaTree} hosts
- * (`type` / `properties` / `items`): integers stay `number` (a sample's `5` rarely promises
- * integers forever) and nothing is marked `required` (validation strictness is an authoring
- * decision, not something a single sample can attest).
- */
-interface JsonObject {
-  [key: string]: Json;
-}
-type Json = null | boolean | number | string | Json[] | JsonObject;
-/**
- * The schema a sample value attests: scalars map to their type, objects carry every observed
- * property, arrays take the merged schema of their elements (an empty or mixed array leaves the
- * items open). `null` says nothing about the real type, so it infers `{}` (any).
- */
-declare function inferSchema(sample: Json): JsonObject;
-/**
- * Project a schema document onto the field tree, or refuse with a structured
- * {@link SchemaTreeIssue} when it uses anything beyond the subset. A blank document parses as
- * an empty tree.
- */
-declare function parseSchemaTree(text: string): SchemaTreeParseResult;
-/**
- * The field tree back as pretty-printed schema JSON. A parsed type-less object root stays
- * type-less; a hand-built tree still emits an object root by default. Clearing the contract
- * entirely (an empty document) stays a source-mode action.
- */
-declare function serializeSchemaTree(tree: SchemaTree): string;
-export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConditionOperatorArity, type ConditionScalar, type ConditionTreeGroup, type ConditionTreeNode, type ConditionTreeOperator, type ConditionTreeRule, type ConditionTreeValue, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMessagesListener, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type Json, type LoadEngineOptions, MAX_CONDITION_TREE_DEPTH, SCHEMA_DIALECT_2020_12, type SchemaTree, type SchemaTreeField, type SchemaTreeFieldType, type SchemaTreeIssue, type SchemaTreeParseResult, type TemplateHole, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, emptyConditionGroup, enMessages, ensureConditionNodeIds, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, inferSchema, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, newSchemaTreeField, parseSchemaTree, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, schemaTreeToExpressionType, selectBranch, selectBranchWith, serializeSchemaTree, subscribeExpressionMessages, templateHoleAt, toZenLiteral, zhCNMessages };
+export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConditionOperatorArity, type ConditionScalar, type ConditionTreeGroup, type ConditionTreeNode, type ConditionTreeOperator, type ConditionTreeRule, type ConditionTreeValue, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMessagesListener, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type LoadEngineOptions, MAX_CONDITION_TREE_DEPTH, type TemplateHole, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, emptyConditionGroup, enMessages, ensureConditionNodeIds, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, schemaTreeToExpressionType, selectBranch, selectBranchWith, subscribeExpressionMessages, templateHoleAt, toZenLiteral, zhCNMessages };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { InitInput } from "@gorules/zen-engine-wasm";
+import { SchemaTree } from "@coldsmirk/caliper-core";
 
 /**
  * How an expression editor interprets its document:
@@ -669,6 +670,13 @@ declare function getExpressionMessages(): ExpressionMessages;
  * function; listeners run synchronously after the new catalog becomes active.
  */
 declare function subscribeExpressionMessages(listener: ExpressionMessagesListener): () => void;
+/**
+ * The expression scope a schema tree declares: each named field becomes a typed variable, so a
+ * host can hand the result straight to `<ExpressionInput variables={…}>` (or `analyzeTypes`)
+ * and complete against the declared shape. Blank draft rows are skipped, while blank property
+ * names preserved by `@coldsmirk/caliper-core`'s `parseSchemaTree` remain part of the scope.
+ */
+declare function schemaTreeToExpressionType(tree: SchemaTree): ExpressionType;
 /**
  * One `{{ expression }}` hole located in a template document. `from` / `to` are
  * the character offsets of the inner expression itself — the text between the
@@ -735,158 +743,4 @@ declare function getTemplateDiagnosticsSync(source: string): ExpressionDiagnosti
  * Async {@link getTemplateDiagnosticsSync}, loading the engine on first use.
  */
 declare function getTemplateDiagnostics(source: string): Promise<ExpressionDiagnostic[]>;
-/**
- * The field-tree model behind the visual JSON Schema builder: a lossless projection of the
- * JSON Schema subset the tree can host (`type` / `properties` / `items`, plus `required`).
- * The schema JSON stays the single source of truth: {@link parseSchemaTree} REFUSES anything
- * outside the subset (never a lossy rewrite), so a hand-written `oneOf` or `format` keeps its
- * document JSON-only instead of silently vanishing on the first visual edit.
- */
-/**
- * The one dialect the tree round-trips: a document may omit `$schema` or declare exactly this.
- */
-declare const SCHEMA_DIALECT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
-type SchemaTreeFieldType = "any" | "array" | "boolean" | "integer" | "number" | "object" | "string";
-interface SchemaTreeField {
-  /**
-   * Stable row identity for React keys and targeted edits — a UI concern, never serialized.
-   */
-  id: string;
-  /**
-   * The property name under its parent object; unused on an array-element node.
-   */
-  name: string;
-  type: SchemaTreeFieldType;
-  /**
-   * Listed in the parent object's `required`; unused on an array-element node.
-   */
-  required: boolean;
-  /**
-   * The schema's `description` annotation; blank means none (not serialized).
-   */
-  description: string;
-  /**
-   * Sub-fields, meaningful when `type` is `object`.
-   */
-  children: SchemaTreeField[];
-  /**
-   * The element node, meaningful when `type` is `array`; `null` means untyped elements.
-   */
-  items: SchemaTreeField | null;
-  /**
-   * For an object or array node parsed from JSON, whether its source explicitly
-   * declared that type. `false` preserves a type-less applicator; omitted keeps the
-   * historical hand-built-tree default of emitting the type.
-   */
-  explicitType?: boolean;
-  /**
-   * Whether a blank / whitespace-only name came from a real `properties` key and must be
-   * persisted. Omitted blank names are unfinished UI rows and do not serialize.
-   */
-  preserveBlankName?: boolean;
-}
-interface SchemaTree {
-  fields: SchemaTreeField[];
-  /**
-   * Whether the source declared `$schema` (re-emitted verbatim on serialize).
-   */
-  dialect: boolean;
-  /**
-   * The root schema's `description` annotation, preserved verbatim across the round trip
-   * (the field view offers no root-level editor); blank means none.
-   */
-  description: string;
-  /**
-   * For a tree parsed from JSON, whether the root explicitly declared `type: "object"`.
-   * `false` preserves a type-less root; omitted keeps the historical hand-built-tree default
-   * of emitting the type.
-   */
-  explicitType?: boolean;
-}
-/**
- * Why a document cannot be projected onto the field tree — structured so a UI can localize
- * the explanation. Every code names the offending part where one exists.
- */
-type SchemaTreeIssue = {
-  code: "invalid-description";
-} | {
-  code: "invalid-field-definition";
-  field: string;
-} | {
-  code: "invalid-field-type";
-  field: string;
-} | {
-  code: "invalid-json";
-} | {
-  code: "invalid-properties";
-} | {
-  code: "invalid-required";
-} | {
-  code: "misplaced-keyword";
-  keyword: string;
-  holder: "array" | "object";
-} | {
-  code: "root-not-object";
-} | {
-  code: "unknown-required-field";
-  field: string;
-} | {
-  code: "unsupported-dialect";
-} | {
-  code: "unsupported-field-type";
-  field: string;
-  type: string;
-} | {
-  code: "unsupported-keyword";
-  keyword: string;
-};
-type SchemaTreeParseResult = {
-  ok: true;
-  tree: SchemaTree;
-} | {
-  ok: false;
-  issue: SchemaTreeIssue;
-};
-/**
- * A fresh {@link SchemaTreeField}, defaulting to an optional unnamed string field. The id is a
- * tagged counter, not a UUID: field identity is a UI concern with no persistence or
- * cross-process meaning — exactly the guarantee a React key needs.
- */
-declare function newSchemaTreeField(overrides?: Partial<Omit<SchemaTreeField, "id">>): SchemaTreeField;
-/**
- * The expression scope a schema tree declares: each named field becomes a typed variable, so a
- * host can hand the result straight to `<ExpressionInput variables={…}>` (or `analyzeTypes`)
- * and complete against the declared shape. Blank draft rows are skipped, while blank property
- * names preserved by {@link parseSchemaTree} remain part of the scope.
- */
-declare function schemaTreeToExpressionType(tree: SchemaTree): ExpressionType;
-/**
- * Infer a draft 2020-12 JSON Schema from a sample payload — the "generate from example" path of
- * the visual schema builder. Deliberately emits only the subset {@link parseSchemaTree} hosts
- * (`type` / `properties` / `items`): integers stay `number` (a sample's `5` rarely promises
- * integers forever) and nothing is marked `required` (validation strictness is an authoring
- * decision, not something a single sample can attest).
- */
-interface JsonObject {
-  [key: string]: Json;
-}
-type Json = null | boolean | number | string | Json[] | JsonObject;
-/**
- * The schema a sample value attests: scalars map to their type, objects carry every observed
- * property, arrays take the merged schema of their elements (an empty or mixed array leaves the
- * items open). `null` says nothing about the real type, so it infers `{}` (any).
- */
-declare function inferSchema(sample: Json): JsonObject;
-/**
- * Project a schema document onto the field tree, or refuse with a structured
- * {@link SchemaTreeIssue} when it uses anything beyond the subset. A blank document parses as
- * an empty tree.
- */
-declare function parseSchemaTree(text: string): SchemaTreeParseResult;
-/**
- * The field tree back as pretty-printed schema JSON. A parsed type-less object root stays
- * type-less; a hand-built tree still emits an object root by default. Clearing the contract
- * entirely (an empty document) stays a source-mode action.
- */
-declare function serializeSchemaTree(tree: SchemaTree): string;
-export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConditionOperatorArity, type ConditionScalar, type ConditionTreeGroup, type ConditionTreeNode, type ConditionTreeOperator, type ConditionTreeRule, type ConditionTreeValue, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMessagesListener, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type Json, type LoadEngineOptions, MAX_CONDITION_TREE_DEPTH, SCHEMA_DIALECT_2020_12, type SchemaTree, type SchemaTreeField, type SchemaTreeFieldType, type SchemaTreeIssue, type SchemaTreeParseResult, type TemplateHole, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, emptyConditionGroup, enMessages, ensureConditionNodeIds, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, inferSchema, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, newSchemaTreeField, parseSchemaTree, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, schemaTreeToExpressionType, selectBranch, selectBranchWith, serializeSchemaTree, subscribeExpressionMessages, templateHoleAt, toZenLiteral, zhCNMessages };
+export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConditionOperatorArity, type ConditionScalar, type ConditionTreeGroup, type ConditionTreeNode, type ConditionTreeOperator, type ConditionTreeRule, type ConditionTreeValue, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMessagesListener, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type LoadEngineOptions, MAX_CONDITION_TREE_DEPTH, type TemplateHole, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, emptyConditionGroup, enMessages, ensureConditionNodeIds, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, schemaTreeToExpressionType, selectBranch, selectBranchWith, subscribeExpressionMessages, templateHoleAt, toZenLiteral, zhCNMessages };

package/dist/index.js

@@ -1257,6 +1257,23 @@ async function satisfiesType(actual, expected) {
 function satisfiesTypeSync(actual, expected) {
 	return getEngineSync().satisfies(actual, expected);
 }
+function fieldType(field) {
+	switch (field.type) {
+		case "string": return "String";
+		case "number": return "Number";
+		case "integer": return "Number";
+		case "boolean": return "Bool";
+		case "object": return { Object: fieldRecord(field.children) };
+		case "array": return { Array: field.items === null ? "Any" : fieldType(field.items) };
+		case "any": return "Any";
+	}
+}
+function fieldRecord(fields) {
+	return Object.fromEntries(fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true).map((field) => [field.name, fieldType(field)]));
+}
+function schemaTreeToExpressionType(tree) {
+	return { Object: fieldRecord(tree.fields) };
+}
 const HOLE_PATTERN = /\{\{(?<expression>[^{}]*)\}\}/g;
 function parseTemplateHoles(source) {
 	const holes = [];
@@ -1317,293 +1334,4 @@ async function getTemplateDiagnostics(source) {
 	await loadEngine();
 	return getTemplateDiagnosticsSync(source);
 }
-function fieldType(field) {
-	switch (field.type) {
-		case "string": return "String";
-		case "number": return "Number";
-		case "integer": return "Number";
-		case "boolean": return "Bool";
-		case "object": return { Object: fieldRecord(field.children) };
-		case "array": return { Array: field.items === null ? "Any" : fieldType(field.items) };
-		case "any": return "Any";
-	}
-}
-function fieldRecord(fields) {
-	return Object.fromEntries(fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true).map((field) => [field.name, fieldType(field)]));
-}
-function schemaTreeToExpressionType(tree) {
-	return { Object: fieldRecord(tree.fields) };
-}
-function mergeSchemas(a, b) {
-	if (a.type === "object" && b.type === "object") {
-		const left = a.properties ?? {};
-		const right = b.properties ?? {};
-		const entries = [];
-		const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
-		for (const key of keys) {
-			const hasLeft = Object.hasOwn(left, key);
-			const hasRight = Object.hasOwn(right, key);
-			entries.push([key, hasLeft && hasRight ? mergeSchemas(left[key], right[key]) : hasLeft ? left[key] : right[key]]);
-		}
-		const properties = Object.fromEntries(entries);
-		return Object.keys(properties).length > 0 ? {
-			type: "object",
-			properties
-		} : { type: "object" };
-	}
-	if (a.type === "array" && b.type === "array") return a.items !== void 0 && b.items !== void 0 ? {
-		type: "array",
-		items: mergeSchemas(a.items, b.items)
-	} : { type: "array" };
-	return JSON.stringify(a) === JSON.stringify(b) ? a : {};
-}
-function inferSchema(sample) {
-	if (sample === null) return {};
-	if (Array.isArray(sample)) {
-		if (sample.length === 0) return { type: "array" };
-		return {
-			type: "array",
-			items: sample.map((element) => inferSchema(element)).reduce((left, right) => mergeSchemas(left, right))
-		};
-	}
-	if (typeof sample === "string") return { type: "string" };
-	if (typeof sample === "number") return { type: "number" };
-	if (typeof sample === "boolean") return { type: "boolean" };
-	const properties = Object.fromEntries(Object.entries(sample).map(([key, value]) => [key, inferSchema(value)]));
-	return Object.keys(properties).length > 0 ? {
-		type: "object",
-		properties
-	} : { type: "object" };
-}
-const SCHEMA_DIALECT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
-const fieldIdRealm = Math.random().toString(36).slice(2, 7);
-let fieldIdCounter = 0;
-function newSchemaTreeField(overrides = {}) {
-	fieldIdCounter += 1;
-	return {
-		id: `sf-${fieldIdRealm}-${fieldIdCounter}`,
-		name: "",
-		type: "string",
-		required: false,
-		description: "",
-		children: [],
-		items: null,
-		...overrides
-	};
-}
-const SCALAR_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"boolean"
-]);
-const ROOT_KEYS = new Set([
-	"$schema",
-	"type",
-	"properties",
-	"required",
-	"description"
-]);
-const SUBSCHEMA_KEYS = new Set([
-	"type",
-	"properties",
-	"required",
-	"items",
-	"description"
-]);
-var Unsupported = class extends Error {
-	issue;
-	constructor(issue) {
-		super(issue.code);
-		this.issue = issue;
-	}
-};
-function asPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-}
-function checkKeys(schema, allowed) {
-	for (const key of Object.keys(schema)) if (!allowed.has(key)) throw new Unsupported({
-		code: "unsupported-keyword",
-		keyword: key
-	});
-}
-function parseObjectFields(schema) {
-	const properties = schema.properties === void 0 ? null : asPlainObject(schema.properties);
-	if (schema.properties !== void 0 && properties === null) throw new Unsupported({ code: "invalid-properties" });
-	const fields = [];
-	const entries = Object.entries(properties ?? {});
-	for (const [name, subschema] of entries) fields.push({
-		...parseSubschema(subschema, name),
-		name,
-		...name.trim() === "" && { preserveBlankName: true }
-	});
-	if (schema.required !== void 0) {
-		if (!Array.isArray(schema.required)) throw new Unsupported({ code: "invalid-required" });
-		for (const entry of schema.required) {
-			if (typeof entry !== "string") throw new Unsupported({ code: "invalid-required" });
-			const field = fields.find((candidate) => candidate.name === entry);
-			if (field === void 0) throw new Unsupported({
-				code: "unknown-required-field",
-				field: entry
-			});
-			field.required = true;
-		}
-	}
-	return fields;
-}
-function parseDescription(schema) {
-	if (schema.description === void 0) return "";
-	if (typeof schema.description !== "string") throw new Unsupported({ code: "invalid-description" });
-	return schema.description;
-}
-function ensureAbsent(schema, key, holder) {
-	if (schema[key] !== void 0) throw new Unsupported({
-		code: "misplaced-keyword",
-		keyword: key,
-		holder
-	});
-}
-function parseSubschema(value, name) {
-	const schema = asPlainObject(value);
-	if (schema === null) throw new Unsupported({
-		code: "invalid-field-definition",
-		field: name
-	});
-	checkKeys(schema, SUBSCHEMA_KEYS);
-	const { type } = schema;
-	if (type !== void 0 && typeof type !== "string") throw new Unsupported({
-		code: "invalid-field-type",
-		field: name
-	});
-	const description = parseDescription(schema);
-	if (type === "object" || type === void 0 && (schema.properties !== void 0 || schema.required !== void 0)) {
-		ensureAbsent(schema, "items", "array");
-		return newSchemaTreeField({
-			type: "object",
-			description,
-			children: parseObjectFields(schema),
-			explicitType: type === "object"
-		});
-	}
-	if (type === "array" || type === void 0 && schema.items !== void 0) {
-		ensureAbsent(schema, "properties", "object");
-		ensureAbsent(schema, "required", "object");
-		return newSchemaTreeField({
-			type: "array",
-			description,
-			items: schema.items === void 0 ? null : parseSubschema(schema.items, name),
-			explicitType: type === "array"
-		});
-	}
-	if (type === void 0) {
-		ensureAbsent(schema, "items", "array");
-		return newSchemaTreeField({
-			type: "any",
-			description
-		});
-	}
-	if (!SCALAR_TYPES.has(type)) throw new Unsupported({
-		code: "unsupported-field-type",
-		field: name,
-		type
-	});
-	ensureAbsent(schema, "properties", "object");
-	ensureAbsent(schema, "required", "object");
-	ensureAbsent(schema, "items", "array");
-	return newSchemaTreeField({
-		type,
-		description
-	});
-}
-function parseSchemaTree(text) {
-	if (text.trim() === "") return {
-		ok: true,
-		tree: {
-			fields: [],
-			dialect: false,
-			description: ""
-		}
-	};
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch {
-		return {
-			ok: false,
-			issue: { code: "invalid-json" }
-		};
-	}
-	try {
-		const root = asPlainObject(parsed);
-		if (root === null) throw new Unsupported({ code: "root-not-object" });
-		checkKeys(root, ROOT_KEYS);
-		const dialect = root.$schema !== void 0;
-		if (dialect && root.$schema !== "https://json-schema.org/draft/2020-12/schema") throw new Unsupported({ code: "unsupported-dialect" });
-		if (root.type !== void 0 && root.type !== "object") throw new Unsupported({ code: "root-not-object" });
-		return {
-			ok: true,
-			tree: {
-				fields: parseObjectFields(root),
-				dialect,
-				description: parseDescription(root),
-				explicitType: root.type === "object"
-			}
-		};
-	} catch (error) {
-		if (error instanceof Unsupported) return {
-			ok: false,
-			issue: error.issue
-		};
-		throw error;
-	}
-}
-function serializeObjectBody(fields) {
-	const named = fields.filter((field) => field.name.trim() !== "" || field.preserveBlankName === true);
-	const finalByName = /* @__PURE__ */ new Map();
-	const finalFields = [];
-	const body = {};
-	for (const field of named) finalByName.set(field.name, field);
-	finalByName.forEach((field) => {
-		finalFields.push(field);
-	});
-	if (finalFields.length > 0) body.properties = Object.fromEntries(finalFields.map((field) => [field.name, serializeField(field)]));
-	const required = finalFields.filter((field) => field.required).map((field) => field.name);
-	if (required.length > 0) body.required = required;
-	return body;
-}
-function serializeField(field) {
-	const description = field.description === "" ? {} : { description: field.description };
-	switch (field.type) {
-		case "any": return { ...description };
-		case "object": return {
-			...field.explicitType !== false && { type: "object" },
-			...description,
-			...serializeObjectBody(field.children)
-		};
-		case "array": {
-			const type = field.explicitType === false ? {} : { type: "array" };
-			return field.items === null || field.items.type === "any" && field.items.description === "" ? {
-				...type,
-				...description
-			} : {
-				...type,
-				...description,
-				items: serializeField(field.items)
-			};
-		}
-		default: return {
-			type: field.type,
-			...description
-		};
-	}
-}
-function serializeSchemaTree(tree) {
-	const root = {
-		...tree.dialect && { $schema: "https://json-schema.org/draft/2020-12/schema" },
-		...tree.explicitType !== false && { type: "object" },
-		...tree.description !== "" && { description: tree.description },
-		...serializeObjectBody(tree.fields)
-	};
-	return `${JSON.stringify(root, null, 2)}\n`;
-}
-export { CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, ExpressionError, ExpressionNotReadyError, MAX_CONDITION_TREE_DEPTH, SCHEMA_DIALECT_2020_12, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, emptyConditionGroup, enMessages, ensureConditionNodeIds, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, inferSchema, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, newSchemaTreeField, parseSchemaTree, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, schemaTreeToExpressionType, selectBranch, selectBranchWith, serializeSchemaTree, subscribeExpressionMessages, templateHoleAt, toZenLiteral, zhCNMessages };
+export { CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, ExpressionError, ExpressionNotReadyError, MAX_CONDITION_TREE_DEPTH, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, emptyConditionGroup, enMessages, ensureConditionNodeIds, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, isEngineReady, isZenRepresentableNumber, liftConditionTree, loadEngine, newConditionNodeId, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, schemaTreeToExpressionType, selectBranch, selectBranchWith, subscribeExpressionMessages, templateHoleAt, toZenLiteral, zhCNMessages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/abacus-core",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Framework-agnostic ZEN expression engine: compile, evaluate, and type-analyze expressions over the GoRules ZEN WASM engine.",
   "keywords": [
     "zen",
@@ -43,6 +43,7 @@
     "dist"
   ],
   "dependencies": {
+    "@coldsmirk/caliper-core": "^0.1.0",
     "@gorules/zen-engine-wasm": "^0.23.1"
   },
   "engines": {