@coldsmirk/abacus-core 0.9.0 → 0.11.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

@@ -361,7 +361,7 @@ function isZenConsistentNumber(value) {
 const SUBJECT_PATTERN = /^[A-Z_$][\w$]*(?:\.[A-Z_$][\w$]*|\[\d+\])*$/i;
 const SUBJECT_IDENTIFIER_PATTERN = /[A-Z_$][\w$]*/gi;
 const SUBJECT_INDEX_PATTERN = /\[(?<index>\d+)\]/g;
-const ZEN_ROOT_RESERVED_WORDS = new Set([
+const ZEN_RESERVED_WORDS = new Set([
 	"and",
 	"or",
 	"not",
@@ -371,10 +371,13 @@ const ZEN_ROOT_RESERVED_WORDS = new Set([
 	"null"
 ]);
 const ZEN_MEMBER_RESERVED_WORDS = new Set(["true", "false"]);
+function isZenReservedWord(word) {
+	return ZEN_RESERVED_WORDS.has(word);
+}
 function isIdentifierPath(subject) {
 	if (!SUBJECT_PATTERN.test(subject)) return false;
 	const [root, ...members] = subject.match(SUBJECT_IDENTIFIER_PATTERN) ?? [];
-	if (root === void 0 || ZEN_ROOT_RESERVED_WORDS.has(root) || members.some((member) => ZEN_MEMBER_RESERVED_WORDS.has(member))) return false;
+	if (root === void 0 || isZenReservedWord(root) || members.some((member) => ZEN_MEMBER_RESERVED_WORDS.has(member))) return false;
 	for (const match of subject.matchAll(SUBJECT_INDEX_PATTERN)) if (match.groups?.index === void 0 || !isZenUnsignedIntegerText(match.groups.index)) return false;
 	return true;
 }
@@ -640,14 +643,14 @@ function compileRule(rule) {
 function matchesOperatorArity(rule) {
 	switch (conditionOperatorArity(rule.operator)) {
 		case "scalar": return isConditionScalar(rule.right);
-		case "array": return isScalarArray(rule.right);
+		case "array": return isConditionScalarArray(rule.right);
 		case "none": return rule.right === void 0;
 	}
 }
 function isConditionScalar(value) {
 	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
-function isScalarArray(value) {
+function isConditionScalarArray(value) {
 	return isArray(value) && value.every((item) => isConditionScalar(item));
 }
 const TWO_CHAR_PUNCTUATION = new Set([
@@ -672,7 +675,7 @@ const IDENT_PART = /[\w$]/;
 const DIGIT = /\d/;
 const NUMBER_PATTERN = /^\d+(?:\.\d+)?(?:e[+-]?\d+)?/i;
 const INTEGER_PATTERN = /^\d+$/;
-function parseCanonicalNumber(text) {
+function parseCanonicalZenNumber(text) {
 	const value = Number(text);
 	return String(value) === text && isZenRepresentableNumber(value) ? value : null;
 }
@@ -734,7 +737,7 @@ function liftConditionTree(expression) {
 			return token.value;
 		}
 		if (token.kind === "number") {
-			const value = parseCanonicalNumber(token.value);
+			const value = parseCanonicalZenNumber(token.value);
 			if (value === null) return null;
 			pos += 1;
 			return value;
@@ -753,7 +756,7 @@ function liftConditionTree(expression) {
 		if (token.kind === "punct" && token.value === "-") {
 			const digits = peek(1);
 			if (digits === void 0 || digits.kind !== "number") return null;
-			const value = parseCanonicalNumber(digits.value);
+			const value = parseCanonicalZenNumber(digits.value);
 			if (value === null || value === 0 || !isZenRepresentableNumber(-value)) return null;
 			pos += 2;
 			return -value;
@@ -1258,6 +1261,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 +1338,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 +1370,14 @@ exports.getEngineSync = getEngineSync;
 exports.getExpressionMessages = getExpressionMessages;
 exports.getTemplateDiagnostics = getTemplateDiagnostics;
 exports.getTemplateDiagnosticsSync = getTemplateDiagnosticsSync;
-exports.inferSchema = inferSchema;
+exports.isConditionScalarArray = isConditionScalarArray;
 exports.isEngineReady = isEngineReady;
 exports.isZenRepresentableNumber = isZenRepresentableNumber;
+exports.isZenReservedWord = isZenReservedWord;
 exports.liftConditionTree = liftConditionTree;
 exports.loadEngine = loadEngine;
 exports.newConditionNodeId = newConditionNodeId;
-exports.newSchemaTreeField = newSchemaTreeField;
-exports.parseSchemaTree = parseSchemaTree;
+exports.parseCanonicalZenNumber = parseCanonicalZenNumber;
 exports.parseTemplateHoles = parseTemplateHoles;
 exports.registerExpressionLocale = registerExpressionLocale;
 exports.resetEngine = resetEngine;
@@ -1656,7 +1386,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;