@samva/markup 0.4.0 → 0.5.0

package/dist/input-schema-zjkgrXn2.js

@@ -0,0 +1,455 @@
+import { n as isObject, t as hasProperty } from "./guards-eV1qLbf2.js";
+import { Validator } from "@cfworker/json-schema";
+//#region src/json-schema/2020-12/meta/applicator.json
+var applicator_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/applicator",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/applicator": true },
+	$dynamicAnchor: "meta",
+	title: "Applicator vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"prefixItems": { "$ref": "#/$defs/schemaArray" },
+		"items": { "$dynamicRef": "#meta" },
+		"contains": { "$dynamicRef": "#meta" },
+		"additionalProperties": { "$dynamicRef": "#meta" },
+		"properties": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"default": {}
+		},
+		"patternProperties": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"propertyNames": { "format": "regex" },
+			"default": {}
+		},
+		"dependentSchemas": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"default": {}
+		},
+		"propertyNames": { "$dynamicRef": "#meta" },
+		"if": { "$dynamicRef": "#meta" },
+		"then": { "$dynamicRef": "#meta" },
+		"else": { "$dynamicRef": "#meta" },
+		"allOf": { "$ref": "#/$defs/schemaArray" },
+		"anyOf": { "$ref": "#/$defs/schemaArray" },
+		"oneOf": { "$ref": "#/$defs/schemaArray" },
+		"not": { "$dynamicRef": "#meta" }
+	},
+	$defs: { "schemaArray": {
+		"type": "array",
+		"minItems": 1,
+		"items": { "$dynamicRef": "#meta" }
+	} }
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/content.json
+var content_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/content",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/content": true },
+	$dynamicAnchor: "meta",
+	title: "Content vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"contentEncoding": { "type": "string" },
+		"contentMediaType": { "type": "string" },
+		"contentSchema": { "$dynamicRef": "#meta" }
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/core.json
+var core_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/core",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/core": true },
+	$dynamicAnchor: "meta",
+	title: "Core vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"$id": {
+			"$ref": "#/$defs/uriReferenceString",
+			"$comment": "Non-empty fragments not allowed.",
+			"pattern": "^[^#]*#?$"
+		},
+		"$schema": { "$ref": "#/$defs/uriString" },
+		"$ref": { "$ref": "#/$defs/uriReferenceString" },
+		"$anchor": { "$ref": "#/$defs/anchorString" },
+		"$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
+		"$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
+		"$vocabulary": {
+			"type": "object",
+			"propertyNames": { "$ref": "#/$defs/uriString" },
+			"additionalProperties": { "type": "boolean" }
+		},
+		"$comment": { "type": "string" },
+		"$defs": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" }
+		}
+	},
+	$defs: {
+		"anchorString": {
+			"type": "string",
+			"pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+		},
+		"uriString": {
+			"type": "string",
+			"format": "uri"
+		},
+		"uriReferenceString": {
+			"type": "string",
+			"format": "uri-reference"
+		}
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/format-annotation.json
+var format_annotation_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true },
+	$dynamicAnchor: "meta",
+	title: "Format vocabulary meta-schema for annotation results",
+	type: ["object", "boolean"],
+	properties: { "format": { "type": "string" } }
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/meta-data.json
+var meta_data_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/meta-data": true },
+	$dynamicAnchor: "meta",
+	title: "Meta-data vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"title": { "type": "string" },
+		"description": { "type": "string" },
+		"default": true,
+		"deprecated": {
+			"type": "boolean",
+			"default": false
+		},
+		"readOnly": {
+			"type": "boolean",
+			"default": false
+		},
+		"writeOnly": {
+			"type": "boolean",
+			"default": false
+		},
+		"examples": {
+			"type": "array",
+			"items": true
+		}
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/unevaluated.json
+var unevaluated_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true },
+	$dynamicAnchor: "meta",
+	title: "Unevaluated applicator vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"unevaluatedItems": { "$dynamicRef": "#meta" },
+		"unevaluatedProperties": { "$dynamicRef": "#meta" }
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/validation.json
+var validation_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/validation",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/validation": true },
+	$dynamicAnchor: "meta",
+	title: "Validation vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, {
+			"type": "array",
+			"items": { "$ref": "#/$defs/simpleTypes" },
+			"minItems": 1,
+			"uniqueItems": true
+		}] },
+		"const": true,
+		"enum": {
+			"type": "array",
+			"items": true
+		},
+		"multipleOf": {
+			"type": "number",
+			"exclusiveMinimum": 0
+		},
+		"maximum": { "type": "number" },
+		"exclusiveMaximum": { "type": "number" },
+		"minimum": { "type": "number" },
+		"exclusiveMinimum": { "type": "number" },
+		"maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"pattern": {
+			"type": "string",
+			"format": "regex"
+		},
+		"maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"uniqueItems": {
+			"type": "boolean",
+			"default": false
+		},
+		"maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minContains": {
+			"$ref": "#/$defs/nonNegativeInteger",
+			"default": 1
+		},
+		"maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"required": { "$ref": "#/$defs/stringArray" },
+		"dependentRequired": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#/$defs/stringArray" }
+		}
+	},
+	$defs: {
+		"nonNegativeInteger": {
+			"type": "integer",
+			"minimum": 0
+		},
+		"nonNegativeIntegerDefault0": {
+			"$ref": "#/$defs/nonNegativeInteger",
+			"default": 0
+		},
+		"simpleTypes": { "enum": [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		] },
+		"stringArray": {
+			"type": "array",
+			"items": { "type": "string" },
+			"uniqueItems": true,
+			"default": []
+		}
+	}
+};
+//#endregion
+//#region src/input-schema.ts
+const meta = new Validator({
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/schema",
+	$vocabulary: {
+		"https://json-schema.org/draft/2020-12/vocab/core": true,
+		"https://json-schema.org/draft/2020-12/vocab/applicator": true,
+		"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+		"https://json-schema.org/draft/2020-12/vocab/validation": true,
+		"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+		"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+		"https://json-schema.org/draft/2020-12/vocab/content": true
+	},
+	$dynamicAnchor: "meta",
+	title: "Core and Validation specifications meta-schema",
+	allOf: [
+		{ "$ref": "meta/core" },
+		{ "$ref": "meta/applicator" },
+		{ "$ref": "meta/unevaluated" },
+		{ "$ref": "meta/validation" },
+		{ "$ref": "meta/meta-data" },
+		{ "$ref": "meta/format-annotation" },
+		{ "$ref": "meta/content" }
+	],
+	type: ["object", "boolean"],
+	$comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+	properties: {
+		"definitions": {
+			"$comment": "\"definitions\" has been replaced by \"$defs\".",
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"deprecated": true,
+			"default": {}
+		},
+		"dependencies": {
+			"$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+			"type": "object",
+			"additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] },
+			"deprecated": true,
+			"default": {}
+		},
+		"$recursiveAnchor": {
+			"$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+			"$ref": "meta/core#/$defs/anchorString",
+			"deprecated": true
+		},
+		"$recursiveRef": {
+			"$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+			"$ref": "meta/core#/$defs/uriReferenceString",
+			"deprecated": true
+		}
+	}
+}, "2020-12", false);
+for (const part of [
+	applicator_default,
+	content_default,
+	core_default,
+	format_annotation_default,
+	meta_data_default,
+	unevaluated_default,
+	validation_default
+]) meta.addSchema(part);
+/** JSON Schema dialect accepted by template publications. */
+const INPUT_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+const canonicalJson = (value) => {
+	if (Array.isArray(value)) return value.map(canonicalJson);
+	if (isObject(value)) return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonicalJson(item)]));
+	return value;
+};
+const annotations = /* @__PURE__ */ new Set([
+	"title",
+	"description",
+	"default",
+	"examples",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"$comment"
+]);
+const scalarKeywords = /* @__PURE__ */ new Set([
+	"$schema",
+	"$ref",
+	"type",
+	"enum",
+	"const",
+	"required",
+	"minProperties",
+	"maxProperties",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf"
+]);
+const schemaMaps = /* @__PURE__ */ new Set([
+	"properties",
+	"$defs",
+	"patternProperties",
+	"dependentSchemas"
+]);
+const schemaValues = /* @__PURE__ */ new Set([
+	"additionalProperties",
+	"items",
+	"contains",
+	"not",
+	"if",
+	"then",
+	"else",
+	"propertyNames"
+]);
+const schemaArrays = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+/** Check every schema position before deriving identity; unknown keywords never disappear. */
+const canonicalSchema = (schema, path = "#") => {
+	if (typeof schema === "boolean") return schema;
+	if (!isObject(schema)) throw new TypeError(`Invalid schema at ${path}`);
+	const shape = meta.validate(schema);
+	if (!shape.valid) throw new TypeError(`Invalid JSON Schema at ${path}: ${JSON.stringify(shape.errors)}`);
+	const result = {};
+	for (const [key, value] of Object.entries(schema).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+		if (annotations.has(key)) continue;
+		if (schemaMaps.has(key)) {
+			if (!isObject(value)) throw new TypeError(`Invalid ${path}/${key}`);
+			result[key] = Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, child]) => [name, canonicalSchema(child, `${path}/${key}/${name}`)]));
+		} else if (schemaValues.has(key)) result[key] = canonicalSchema(value, `${path}/${key}`);
+		else if (schemaArrays.has(key)) {
+			if (!Array.isArray(value)) throw new TypeError(`Invalid ${path}/${key}`);
+			result[key] = value.map((child, index) => canonicalSchema(child, `${path}/${key}/${index}`));
+		} else if (scalarKeywords.has(key)) {
+			if (key === "$ref" && (typeof value !== "string" || !(value === "#" || value.startsWith("#/")))) throw new TypeError(`Only local JSON Pointer references are supported at ${path}/$ref`);
+			if (key === "$schema" && value !== "https://json-schema.org/draft/2020-12/schema") throw new TypeError(`Expected JSON Schema 2020-12 at ${path}`);
+			result[key] = canonicalJson(value);
+		} else throw new TypeError(`Unsupported input schema keyword ${path}/${key}`);
+	}
+	return result;
+};
+/** Direct portable JSON Schema authoring; the caller declares its JSON input type. */
+const jsonSchema = (schema) => ({ "~standard": {
+	version: 1,
+	vendor: "samva-json-schema",
+	jsonSchema: {
+		input: () => schema,
+		output: () => schema
+	}
+} });
+/** Pinned Effect/Zod converters omit arbitrary refinements, so inspect those vendors' check metadata. */
+const rejectNonportableChecks = (source) => {
+	const vendor = source["~standard"].vendor;
+	if (vendor !== "effect" && vendor !== "zod") return;
+	const seen = /* @__PURE__ */ new WeakSet();
+	const visit = (value) => {
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child);
+			return;
+		}
+		if (!isObject(value) || seen.has(value)) return;
+		seen.add(value);
+		if (vendor === "zod" && isObject(value._zod)) {
+			visit(value._zod.def);
+			return;
+		}
+		if (vendor === "effect" && value.encoding !== void 0) throw new TypeError("Nonportable Effect transform; use a JSON input schema without decoding transforms");
+		if (vendor === "effect" && value._tag === "Suspend") throw new TypeError("Unsupported suspended Effect converter; use local JSON Schema references");
+		if (vendor === "zod" && value.type === "lazy") throw new TypeError("Unsupported lazy Zod converter; author recursive input with local JSON Schema references");
+		if (vendor === "zod" && (value.check === "custom" || value.check === "overwrite" || [
+			"transform",
+			"default",
+			"prefault",
+			"catch"
+		].includes(String(value.type)))) throw new TypeError("Nonportable Zod refinement/transform; express constraints in JSON Schema");
+		if (vendor === "effect" && value._tag === "Filter" && (!isObject(value.annotations) || typeof value.annotations.toJsonSchema !== "function")) throw new TypeError("Nonportable Effect refinement; provide a JSON Schema constraint");
+		for (const [key, child] of Object.entries(value)) if (key !== "~standard" && key !== "annotations") visit(child);
+	};
+	if (vendor === "effect" && hasProperty(source, "ast")) visit(source.ast);
+	else visit(source);
+};
+/** Convert caller input, never validator output. Both conversion directions must be portable. */
+const inputSchema = (source) => {
+	rejectNonportableChecks(source);
+	const converter = source["~standard"].jsonSchema;
+	const schema = structuredClone(converter.input({ target: "draft-2020-12" }));
+	const canonical = canonicalSchema(schema);
+	const output = canonicalSchema(converter.output({ target: "draft-2020-12" }));
+	if (JSON.stringify(canonical) !== JSON.stringify(output)) throw new TypeError("Template schemas must preserve JSON input; input/output conversion differs");
+	const validator = new Validator(schema, "2020-12", false);
+	const validate = (value) => {
+		const result = validator.validate(value);
+		validate.errors = result.errors;
+		return result.valid;
+	};
+	validate.errors = [];
+	return {
+		schema,
+		validationIdentity: JSON.stringify(canonical),
+		validate
+	};
+};
+//#endregion
+export { inputSchema as n, jsonSchema as r, INPUT_SCHEMA_DIALECT as t };
+
+//# sourceMappingURL=input-schema-zjkgrXn2.js.map

package/dist/input-schema.d.ts

@@ -1,2 +1,2 @@
-import { a as jsonSchema, i as inputSchema, n as InputIssue, r as InputSchema, t as INPUT_SCHEMA_DIALECT } from "./input-schema-BIfzI63B.js";
+import { a as jsonSchema, i as inputSchema, n as InputIssue, r as InputSchema, t as INPUT_SCHEMA_DIALECT } from "./input-schema-7dPFVvNE.js";
 export { INPUT_SCHEMA_DIALECT, InputIssue, InputSchema, inputSchema, jsonSchema };

package/dist/input-schema.js

@@ -1,170 +1,2 @@
-import { Validator } from "@cfworker/json-schema";
-import applicator from "ajv/dist/refs/json-schema-2020-12/meta/applicator.json" with { type: "json" };
-import content from "ajv/dist/refs/json-schema-2020-12/meta/content.json" with { type: "json" };
-import core from "ajv/dist/refs/json-schema-2020-12/meta/core.json" with { type: "json" };
-import format_annotation from "ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json" with { type: "json" };
-import meta_data from "ajv/dist/refs/json-schema-2020-12/meta/meta-data.json" with { type: "json" };
-import unevaluated from "ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json" with { type: "json" };
-import validation from "ajv/dist/refs/json-schema-2020-12/meta/validation.json" with { type: "json" };
-import metaSchema from "ajv/dist/refs/json-schema-2020-12/schema.json" with { type: "json" };
-import { Predicate } from "effect";
-//#region src/input-schema.ts
-const meta = new Validator(metaSchema, "2020-12", false);
-for (const part of [
-	applicator,
-	content,
-	core,
-	format_annotation,
-	meta_data,
-	unevaluated,
-	validation
-]) meta.addSchema(part);
-/** JSON Schema dialect accepted by template publications. */
-const INPUT_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
-const canonicalJson = (value) => {
-	if (Array.isArray(value)) return value.map(canonicalJson);
-	if (Predicate.isObject(value)) return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonicalJson(item)]));
-	return value;
-};
-const annotations = /* @__PURE__ */ new Set([
-	"title",
-	"description",
-	"default",
-	"examples",
-	"deprecated",
-	"readOnly",
-	"writeOnly",
-	"$comment"
-]);
-const scalarKeywords = /* @__PURE__ */ new Set([
-	"$schema",
-	"$ref",
-	"type",
-	"enum",
-	"const",
-	"required",
-	"minProperties",
-	"maxProperties",
-	"minItems",
-	"maxItems",
-	"uniqueItems",
-	"minLength",
-	"maxLength",
-	"pattern",
-	"minimum",
-	"maximum",
-	"exclusiveMinimum",
-	"exclusiveMaximum",
-	"multipleOf"
-]);
-const schemaMaps = /* @__PURE__ */ new Set([
-	"properties",
-	"$defs",
-	"patternProperties",
-	"dependentSchemas"
-]);
-const schemaValues = /* @__PURE__ */ new Set([
-	"additionalProperties",
-	"items",
-	"contains",
-	"not",
-	"if",
-	"then",
-	"else",
-	"propertyNames"
-]);
-const schemaArrays = /* @__PURE__ */ new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
-/** Check every schema position before deriving identity; unknown keywords never disappear. */
-const canonicalSchema = (schema, path = "#") => {
-	if (typeof schema === "boolean") return schema;
-	if (!Predicate.isObject(schema)) throw new TypeError(`Invalid schema at ${path}`);
-	const shape = meta.validate(schema);
-	if (!shape.valid) throw new TypeError(`Invalid JSON Schema at ${path}: ${JSON.stringify(shape.errors)}`);
-	const result = {};
-	for (const [key, value] of Object.entries(schema).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
-		if (annotations.has(key)) continue;
-		if (schemaMaps.has(key)) {
-			if (!Predicate.isObject(value)) throw new TypeError(`Invalid ${path}/${key}`);
-			result[key] = Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, child]) => [name, canonicalSchema(child, `${path}/${key}/${name}`)]));
-		} else if (schemaValues.has(key)) result[key] = canonicalSchema(value, `${path}/${key}`);
-		else if (schemaArrays.has(key)) {
-			if (!Array.isArray(value)) throw new TypeError(`Invalid ${path}/${key}`);
-			result[key] = value.map((child, index) => canonicalSchema(child, `${path}/${key}/${index}`));
-		} else if (scalarKeywords.has(key)) {
-			if (key === "$ref" && (typeof value !== "string" || !(value === "#" || value.startsWith("#/")))) throw new TypeError(`Only local JSON Pointer references are supported at ${path}/$ref`);
-			if (key === "$schema" && value !== "https://json-schema.org/draft/2020-12/schema") throw new TypeError(`Expected JSON Schema 2020-12 at ${path}`);
-			result[key] = canonicalJson(value);
-		} else throw new TypeError(`Unsupported input schema keyword ${path}/${key}`);
-	}
-	return result;
-};
-/** Direct portable JSON Schema authoring; the caller declares its JSON input type. */
-const jsonSchema = (schema) => ({ "~standard": {
-	version: 1,
-	vendor: "samva-json-schema",
-	jsonSchema: {
-		input: () => schema,
-		output: () => schema
-	}
-} });
-/** Pinned Effect/Zod converters omit arbitrary refinements, so inspect those vendors' check metadata. */
-const rejectNonportableChecks = (source) => {
-	const vendor = source["~standard"].vendor;
-	if (vendor !== "effect" && vendor !== "zod") return;
-	const seen = /* @__PURE__ */ new WeakSet();
-	const visit = (value) => {
-		if (Array.isArray(value)) {
-			for (const child of value) visit(child);
-			return;
-		}
-		if (!Predicate.isObject(value) || seen.has(value)) return;
-		seen.add(value);
-		if (vendor === "zod" && Predicate.isObject(value._zod)) {
-			visit(value._zod.def);
-			return;
-		}
-		if (vendor === "effect" && value.encoding !== void 0) throw new TypeError("Nonportable Effect transform; use a JSON input schema without decoding transforms");
-		if (vendor === "effect" && value._tag === "Suspend") throw new TypeError("Unsupported suspended Effect converter; use local JSON Schema references");
-		if (vendor === "zod" && value.type === "lazy") throw new TypeError("Unsupported lazy Zod converter; author recursive input with local JSON Schema references");
-		if (vendor === "zod" && (value.check === "custom" || value.check === "overwrite" || [
-			"transform",
-			"default",
-			"prefault",
-			"catch"
-		].includes(String(value.type)))) throw new TypeError("Nonportable Zod refinement/transform; express constraints in JSON Schema");
-		if (vendor === "effect" && value._tag === "Filter" && (!Predicate.isObject(value.annotations) || typeof value.annotations.toJsonSchema !== "function")) throw new TypeError("Nonportable Effect refinement; provide a JSON Schema constraint");
-		for (const [key, child] of Object.entries(value)) if (key !== "~standard" && key !== "annotations") visit(child);
-	};
-	if (vendor === "effect" && Predicate.hasProperty(source, "ast")) visit(source.ast);
-	else visit(source);
-};
-/** Convert caller input, never validator output. Both conversion directions must be portable. */
-const inputSchema = (source) => {
-	rejectNonportableChecks(source);
-	const converter = source["~standard"].jsonSchema;
-	const schema = structuredClone(converter.input({ target: "draft-2020-12" }));
-	const canonical = canonicalSchema(schema);
-	const output = canonicalSchema(converter.output({ target: "draft-2020-12" }));
-	if (JSON.stringify(canonical) !== JSON.stringify(output)) throw new TypeError("Template schemas must preserve JSON input; input/output conversion differs");
-	const validator = new Validator(schema, "2020-12", false);
-	const validate = (value) => {
-		const result = validator.validate(value);
-		validate.errors = result.errors;
-		return result.valid;
-	};
-	validate.errors = [];
-	return {
-		schema,
-		validationIdentity: JSON.stringify(canonical),
-		validate
-	};
-};
-//#endregion
+import { n as inputSchema, r as jsonSchema, t as INPUT_SCHEMA_DIALECT } from "./input-schema-zjkgrXn2.js";
 export { INPUT_SCHEMA_DIALECT, inputSchema, jsonSchema };
-
-//# sourceMappingURL=input-schema.js.map

package/dist/interpolate.d.ts

@@ -1,16 +1,13 @@
-import { Schema } from "effect";
 //#region src/interpolate.d.ts
-declare const DocumentVariableTypeSchema: Schema.Literals<readonly ["string", "number", "boolean", "date", "array", "object"]>;
-type DocumentVariableType = typeof DocumentVariableTypeSchema.Type;
+type DocumentVariableType = "string" | "number" | "boolean" | "date" | "array" | "object";
 /** One entry of a template's declared variable schema. */
-declare const DocumentVariableSchema: Schema.Struct<{
-  readonly name: Schema.String;
-  readonly type: Schema.Literals<readonly ["string", "number", "boolean", "date", "array", "object"]>;
-  readonly required: Schema.Boolean;
-  readonly default: Schema.optional<Schema.Unknown>;
-  readonly description: Schema.optional<Schema.String>;
-}>;
-interface DocumentVariable extends Schema.Schema.Type<typeof DocumentVariableSchema> {}
+interface DocumentVariable {
+  readonly name: string;
+  readonly type: DocumentVariableType;
+  readonly required: boolean;
+  readonly default?: unknown;
+  readonly description?: string | undefined;
+}
 declare const variableReferencePattern: RegExp;
 declare const getVariableValue: (variables: Record<string, unknown>, variableSchema: ReadonlyArray<DocumentVariable>, name: string) => unknown;
 declare const stringifyVariable: (value: unknown) => string;
@@ -23,5 +20,5 @@ declare const interpolate: (text: string, variables: Record<string, unknown>, va
 declare const variableReferences: (text: string) => Set<string>;
 declare const addVariableReferences: (target: Set<string>, text: string) => void;
 //#endregion
-export { DocumentVariable, DocumentVariableSchema, DocumentVariableType, DocumentVariableTypeSchema, InterpolationResult, addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
+export { DocumentVariable, DocumentVariableType, InterpolationResult, addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
 //# sourceMappingURL=interpolate.d.ts.map