@coldsmirk/abacus-core 0.5.0 → 0.6.0

package/README.md

@@ -9,6 +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.
 - **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.
 
@@ -213,6 +214,49 @@ interface ExpressionCompletion {
 
 > Building an editor? You usually do not call these directly — `@coldsmirk/abacus-codemirror` and `@coldsmirk/abacus-react` wire them into CodeMirror for you.
 
+## 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.
+
+```ts
+import {
+  inferSchema,
+  parseSchemaTree,
+  schemaTreeToExpressionType,
+  serializeSchemaTree
+} from "@coldsmirk/abacus-core";
+
+const inferred = 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.
+
+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.
+
 ## Compiling conditions
 
 A common need is to let users author conditions in a UI (field / operator / value rows, AND/OR groups, prioritized branches) and turn that structure into a ZEN expression. This package models that structure and compiles it — without depending on any editor.
@@ -254,7 +298,7 @@ interface ConditionBranchInput {                // a branch guarded by groups co
 | `contains` / `not_contains` | `contains(subject, value)` / `not contains(subject, value)`                                    |
 | `starts_with` / `ends_with` | `startsWith(subject, value)` / `endsWith(subject, value)`                                      |
 | `in` / `not_in`             | `subject in [..]` / `not (subject in [..])` (a scalar value is wrapped to a one-element array) |
-| `is_empty` / `is_not_empty` | a typed emptiness test (null / blank string / empty array) and its negation                    |
+| `is_empty` / `is_not_empty` | a typed emptiness test (null / blank string / empty array / empty object) and its negation     |
 
 ### Compiling and selecting
 
@@ -354,14 +398,15 @@ All tree consumers share `MAX_CONDITION_TREE_DEPTH`: the root is depth 0 and up
 
 The compiler is designed not to become an expression-injection sink:
 
-- A **subject** is emitted verbatim, so it must be a plain identifier path (`amount`, `user.age`, `items[0]`) whose segments are not ZEN reserved words (`and`, `or`, `not`, `in`, `true`, `false`, `null`). Every array index token must also be inside ZEN's unsigned 96-bit decimal domain (`0` through `2^96 - 1`); the next value is a parser error, so the compiler rejects it instead of poisoning a larger expression. Anything else (`len(secret)`, `a or b`, a bare `true`, …) makes the condition compile to `null` and be dropped.
-- A **value** is serialized to a ZEN literal via `toZenLiteral`, never interpolated as code. Strings are quoted _raw_ (ZEN honours no backslash escapes) by picking a delimiter the value does not contain; a value that cannot be represented faithfully makes the condition degrade to `null`. For numbers that means passing `isZenRepresentableNumber`: inside ZEN's 96-bit decimal domain (finite, magnitude below ~7.9e28, no finer than 1e-28) **and** held identically by the engine's own context conversion — the engine converts context JS numbers lossily (roughly: integers whose text fits u64 are exact; other f64s are trimmed to ~16 significant digits), so a value like `0.1 + 0.2` or `1.2345678901234567` would compile into a literal that silently compares **unequal to itself** in a context. Such values are rejected instead.
+- A **subject** is emitted verbatim, so it must be a plain identifier path (`amount`, `user.age`, `items[0]`). ZEN keywords cannot start the path; in dotted member positions the parser accepts `and` / `or` / `not` / `in` / `null` as object keys (`metadata.in` is valid), while `true` / `false` remain literal tokens and are rejected there too. Every array index token must also be inside ZEN's unsigned 96-bit decimal domain (`0` through `2^96 - 1`); the next value is a parser error, so the compiler rejects it instead of poisoning a larger expression. Anything else (`len(secret)`, `a or b`, a bare `true`, …) makes the condition compile to `null` and be dropped.
+- A **value** is serialized to a ZEN literal via `toZenLiteral`, never interpolated as code. Strings are quoted _raw_ (ZEN honours no backslash escapes) by picking a single-quote, double-quote, or backtick delimiter the value does not contain; only a string containing all three delimiters is unrepresentable. For numbers, faithful representation means passing `isZenRepresentableNumber`: inside ZEN's 96-bit decimal domain (finite, magnitude below ~7.9e28, no finer than 1e-28) **and** held identically by the engine's own context conversion — the engine converts context JS numbers lossily (roughly: integers whose text fits u64 are exact; other f64s are trimmed to ~16 significant digits), so a value like `0.1 + 0.2` or `1.2345678901234567` would compile into a literal that silently compares **unequal to itself** in a context. Such values are rejected instead.
 
 ```ts
 function toZenLiteral(value: unknown): string;          // throws if the value has no faithful ZEN representation
 
 toZenLiteral("active");          // "'active'"
 toZenLiteral("it's");            // "\"it's\""   (switches delimiter)
+toZenLiteral(`He said "it's"`);  // "`He said \"it's\"`"
 toZenLiteral(1500);              // "1500"
 toZenLiteral(["BJ", "SH"]);      // "['BJ', 'SH']"
 toZenLiteral(null);              // "null"
@@ -390,7 +435,19 @@ configureExpressionMessages({ locale: "zh-CN" });                       // switc
 configureExpressionMessages({ messages: { typeCheckSource: "Validation" } });  // override individual strings
 ```
 
-The catalog is **process-global and last-write-wins** — there is one active catalog per runtime, so configure it once at startup. Built-in catalogs `enMessages` (the default) and `zhCNMessages` are exported. `getExpressionMessages()` returns the active one.
+The catalog is **process-global and last-write-wins** — there is one active catalog per runtime, so configure it once at startup. Built-in catalogs `enMessages` (the default) and `zhCNMessages` are exported. `getExpressionMessages()` returns the active one. Each `messages` object replaces the previous override set over the current locale base; omitting it removes earlier overrides instead of accumulating them.
+
+Framework integrations that keep already-rendered diagnostics can subscribe to catalog changes. The listener runs synchronously after the new catalog becomes active; the returned cleanup is idempotent:
+
+```ts
+import { subscribeExpressionMessages } from "@coldsmirk/abacus-core";
+
+const unsubscribe = subscribeExpressionMessages(messages => {
+  refreshDiagnostics(messages);
+});
+
+unsubscribe();
+```
 
 To add a language the library does not ship, register a full catalog under a key, then select it like any built-in — built-in and custom locales share one registry, so there is no privileged path:
 
@@ -426,9 +483,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`
-- **Localization** — `configureExpressionMessages`, `registerExpressionLocale`, `getExpressionMessages`, `enMessages`, `zhCNMessages`
+- **JSON Schema** — `inferSchema`, `parseSchemaTree`, `serializeSchemaTree`, `schemaTreeToExpressionType`, `newSchemaTreeField`, `SCHEMA_DIALECT_2020_12`
+- **Localization** — `configureExpressionMessages`, `registerExpressionLocale`, `getExpressionMessages`, `subscribeExpressionMessages`, `enMessages`, `zhCNMessages`
 - **Errors** — `ExpressionError`, `ExpressionNotReadyError`
-- **Types** — `ExpressionType`, `ExpressionMode`, `TemplateHole`, `ExpressionContext`, `ExpressionEngine`, `LoadEngineOptions`, `ExpressionAnalysis`, `ExpressionTypeSpan`, `ExpressionCompletion`, `ExpressionDiagnostic`, `ExpressionMessages`, `ExpressionLocale`, `BuiltInExpressionLocale`, `ConfigureMessagesOptions`, `ConditionInput`, `FieldConditionInput`, `ExpressionConditionInput`, `ConditionGroupInput`, `ConditionBranchInput`, `ConditionOperator`, `ConditionOperatorArity`, `BranchSelection`, `ConditionTreeGroup`, `ConditionTreeNode`, `ConditionTreeRule`, `ConditionTreeOperator`, `ConditionTreeValue`, `ConditionScalar`
+- **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`
 
 ## License
 

package/dist/index.cjs

@@ -359,8 +359,9 @@ function isZenConsistentNumber(value) {
 	return context !== null && literal.digits === context.digits && literal.exponent === context.exponent;
 }
 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_RESERVED_WORDS = new Set([
+const ZEN_ROOT_RESERVED_WORDS = new Set([
 	"and",
 	"or",
 	"not",
@@ -369,8 +370,11 @@ const ZEN_RESERVED_WORDS = new Set([
 	"false",
 	"null"
 ]);
+const ZEN_MEMBER_RESERVED_WORDS = new Set(["true", "false"]);
 function isIdentifierPath(subject) {
-	if (!SUBJECT_PATTERN.test(subject) || (subject.match(/[A-Z_$][\w$]*/gi) ?? []).some((segment) => ZEN_RESERVED_WORDS.has(segment))) return false;
+	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;
 	for (const match of subject.matchAll(SUBJECT_INDEX_PATTERN)) if (match.groups?.index === void 0 || !isZenUnsignedIntegerText(match.groups.index)) return false;
 	return true;
 }
@@ -395,14 +399,17 @@ function toZenLiteral(value) {
 function encodeZenString(value) {
 	const hasSingle = value.includes("'");
 	const hasDouble = value.includes("\"");
-	if (hasSingle && hasDouble) throw new ExpressionError("String contains both single and double quotes and has no ZEN literal representation");
-	return hasSingle ? `"${value}"` : `'${value}'`;
+	const hasBacktick = value.includes("`");
+	if (!hasSingle) return `'${value}'`;
+	if (!hasDouble) return `"${value}"`;
+	if (!hasBacktick) return `\`${value}\``;
+	throw new ExpressionError("String contains every ZEN raw-string delimiter and has no literal representation");
 }
 function toArrayLiteral(value) {
 	return isArray(value) ? toZenLiteral(value) : `[${toZenLiteral(value)}]`;
 }
 function zenIsEmpty(subject) {
-	return `(${subject} == null or (type(${subject}) == 'string' and len(trim(${subject})) == 0) or (type(${subject}) == 'array' and len(${subject}) == 0))`;
+	return `(${subject} == null or (type(${subject}) == 'string' and len(trim(${subject})) == 0) or (type(${subject}) == 'array' and len(${subject}) == 0) or (type(${subject}) == 'object' and len(keys(${subject})) == 0))`;
 }
 function compileFieldCondition(subject, operator, value) {
 	switch (operator) {
@@ -970,7 +977,7 @@ function tokenize(input) {
 			index += 1;
 			continue;
 		}
-		if (char === "'" || char === "\"") {
+		if (char === "'" || char === "\"" || char === "`") {
 			const end = input.indexOf(char, index + 1);
 			if (end === -1) return null;
 			tokens.push({
@@ -1153,33 +1160,45 @@ const zhCNMessages = {
 	expectedType: (expectedType, actualType) => `期望 \`${expectedType}\`，实际为 \`${actualType}\`。`
 };
 const localeRegistry = new Map([["en-US", enMessages], ["zh-CN", zhCNMessages]]);
+let activeBaseMessages = enMessages;
 let activeMessages = enMessages;
+const messageListeners = /* @__PURE__ */ new Set();
 function registerExpressionLocale(locale, messages) {
 	localeRegistry.set(locale, messages);
 }
 function configureExpressionMessages({ locale, messages }) {
-	const base = locale === void 0 ? activeMessages : localeRegistry.get(locale) ?? activeMessages;
-	activeMessages = messages === void 0 ? base : {
+	const base = locale === void 0 ? activeBaseMessages : localeRegistry.get(locale) ?? activeBaseMessages;
+	const nextMessages = messages === void 0 ? base : {
 		...base,
 		...messages
 	};
+	activeBaseMessages = base;
+	if (nextMessages === activeMessages) return;
+	activeMessages = nextMessages;
+	for (const listener of messageListeners) listener(activeMessages);
 }
 function getExpressionMessages() {
 	return activeMessages;
 }
+function subscribeExpressionMessages(listener) {
+	messageListeners.add(listener);
+	return () => {
+		messageListeners.delete(listener);
+	};
+}
 function parseOffset(text) {
 	const trimmed = text?.trim();
 	return trimmed ? Number(trimmed) : NaN;
 }
 function extractPosition(message) {
-	const segments = message.split(" at ");
-	const last = segments.length <= 1 ? void 0 : segments.at(-1);
-	if (last === void 0) return null;
-	const [left, right] = last.replace("(", "").replace(")", "").split(", ");
-	const from = parseOffset(left);
-	if (Number.isNaN(from)) return null;
-	const to = parseOffset(right);
-	return [from, Number.isNaN(to) ? from : to];
+	const positionPattern = / at (?:\(\s*(?<rangeFrom>\d+)\s*,\s*(?<rangeTo>\d+)\s*\)|(?<point>\d+))(?=\s*(?:;|$))/g;
+	let position = null;
+	for (const match of message.matchAll(positionPattern)) {
+		const from = parseOffset(match.groups?.rangeFrom ?? match.groups?.point);
+		const to = parseOffset(match.groups?.rangeTo);
+		position = [from, Number.isNaN(to) ? from : to];
+	}
+	return position;
 }
 function normalizeDiagnostic(raw, source) {
 	if (raw === null || raw === void 0) return null;
@@ -1299,11 +1318,301 @@ 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;
@@ -1331,18 +1640,24 @@ 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;
 exports.satisfiesType = satisfiesType;
 exports.satisfiesTypeSync = satisfiesTypeSync;
+exports.schemaTreeToExpressionType = schemaTreeToExpressionType;
 exports.selectBranch = selectBranch;
 exports.selectBranchWith = selectBranchWith;
+exports.serializeSchemaTree = serializeSchemaTree;
+exports.subscribeExpressionMessages = subscribeExpressionMessages;
 exports.templateHoleAt = templateHoleAt;
 exports.toZenLiteral = toZenLiteral;
 exports.zhCNMessages = zhCNMessages;