@samva/markup 0.1.1 → 0.2.0

package/dist/emit.js

@@ -1,3 +1,4 @@
+import { sameTemplateSourceLocations } from "./source-locations.js";
 import { isRootTag } from "./ast.js";
 import { createVariablesProxy } from "./variables.js";
 import { renderTemplate } from "./render-template.js";
@@ -5,55 +6,40 @@ import { Result } from "effect";
 //#region src/emit.ts
 /**
 * emitModule — the module-level emit boundary for the TSX authoring layer
-* (design brief §7b). The vite plugin (M12) does the importing: TSX runs at the
+* (design brief §7b). The vite plugin does the importing: TSX runs at the
 * USER's build time and this receives the already-evaluated module object (a
 * record of its exports). emitModule stays bundler-agnostic — it never touches
-* the filesystem, esbuild, or vite. It discovers the named template functions,
-* runs each through renderTemplate (print → parse validation), and additionally
-* renders each one TWICE to guard emission determinism (a build-time clock or
-* RNG produces a different second emission and is reported as unstable).
+* the filesystem, esbuild, or vite. It reads only `moduleExports.default`,
+* runs that function through renderTemplate (print → parse validation), and
+* additionally renders it TWICE to guard emission determinism (a build-time
+* clock or RNG produces a different second emission and is reported as
+* unstable).
 *
-* Non-function and helper exports are ignored silently; a module with zero
-* templates is a distinct diagnostic (the common "forgot to export the function"
-* / "imported the wrong file" mistake).
+* Named exports are ordinary helpers and are never inspected or invoked. A
+* missing or invalid default is a module-level diagnostic (the common "forgot
+* to default-export the function" / "imported the wrong file" mistake).
 *
-* Template discovery
+* Default-export classification
 *
-* Discovery is by PROBING, not by an explicit `isTemplate` marker. A module
-* export is a template iff it is a function that, when invoked with a fresh
-* recording proxy, returns a channel root element (JsxResult with
-* `kind: "element"` and an <Email>/<Sms>/<WhatsApp> tag). Rationale for
-* probing over a marker:
+* This recorder recognizes function exports returning a channel root element.
+* SMS and WhatsApp use the recorded AST; legacy Email roots remain recognizable
+* so the compiler can report the executable defineEmail requirement. Executable
+* email definitions are discovered by their definition marker before this path.
+* Structured function exports have no marker and are classified by probing.
 *
-*   • The canonical template shape (brief §7b) is a plain named exported
-*     function of `Variables<T>` — requiring a `Foo.isTemplate = true` tag or a
-*     `defineTemplate()` wrapper would add ceremony the brief explicitly avoids
-*     ("named exported function is the canonical template shape").
-*   • The proxy makes the probe cheap and side-effect-free for well-formed
-*     templates: property accesses record variables and return refs; no network,
-*     no I/O. Composition helpers that assemble sub-trees also just build AST.
+* The proxy makes the probe cheap and side-effect-free for well-formed
+* templates: property accesses record variables and return refs; no network,
+* no I/O. A default export that throws when called with a proxy, or that
+* returns a non-root node, is `invalid-default-export` rather than a crash.
 *
-* Soundness boundary (documented tradeoff): probing invokes the function, so a
-* helper export with arbitrary arity or side effects is executed once during
-* discovery. We contain the two failure shapes:
-*
-*   • A helper that THROWS when called with a proxy (wrong argument shape, a
-*     coercion-guard trip, an invalid-child assembly) is classified as a
-*     non-template and skipped — the throw is swallowed only for the probe. This
-*     is the one place we catch, and it is confined to classification.
-*   • A helper that RETURNS a non-<Email> node (a bare <Container>, a Fragment,
-*     a string) is likewise skipped.
-*
-* The corollary: a genuine template whose body throws (a real authoring bug —
-* coercing a variable, a malformed child) is misclassified as a helper and
-* silently skipped rather than surfacing its error. That is acceptable because
-* the same bug breaks the template's real emit regardless, and the zero-template
-* diagnostic fires when it was the module's only template. The probe re-runs the
-* function; renderTemplate runs it again on the confirmed templates, so a
-* template function must be a pure builder of its AST (no external side effects)
-* — which the recording-proxy model already requires.
+* A genuine template whose body throws (a real authoring bug — coercing a
+* variable, a malformed child) is therefore classified as an invalid default.
+* That is acceptable because the same bug breaks the template's real emit
+* regardless. Confirmed templates are rendered by renderTemplate, so a
+* template function must be a pure builder of its AST — which the
+* recording-proxy model already requires.
 */
-/** Probe one export: is it a function that yields a channel root document? */
+/** Probe the default export: is it a function that yields a channel root document? */
 const isTemplateFunction = (value) => {
 	if (typeof value !== "function") return false;
 	const { proxy } = createVariablesProxy();
@@ -65,9 +51,17 @@ const isTemplateFunction = (value) => {
 	}
 	return result !== null && typeof result === "object" && result.kind === "element" && isRootTag(result.tag);
 };
-const ZERO_TEMPLATES = {
-	code: "no-templates",
-	message: "no template exports found — a template is a named exported function returning a channel root element (e.g. `export function WelcomeEmail(v: Variables<{…}>) { return <Email>…</Email>; }`; <Sms> and <WhatsApp> roots work the same way)",
+const MISSING_DEFAULT = {
+	code: "missing-default-export",
+	message: "no default export — a structured template must default-export a function returning <Sms> or <WhatsApp>. Email templates must default-export defineEmail with an input schema and fixtures. Named exports are ignored.",
+	span: {
+		start: 0,
+		end: 0
+	}
+};
+const INVALID_DEFAULT = {
+	code: "invalid-default-export",
+	message: "the default export is not a structured Samva template returning <Sms> or <WhatsApp>. Email templates must default-export defineEmail with an input schema and fixtures.",
 	span: {
 		start: 0,
 		end: 0
@@ -82,31 +76,31 @@ const unstableDiagnostic = (name) => ({
 	}
 });
 /**
-* Discovers template functions in an already-evaluated module object, renders
-* each to canonical SML with a determinism guard, and returns per-template
-* results plus an aggregate ok/fail. `moduleExports` is a plain record of the
-* module's exports (the vite plugin imports the TSX; this stays bundler-agnostic
-* and pure).
+* Emits the one supported template from an already-evaluated module object:
+* `moduleExports.default`. Named exports are never probed. `moduleExports` is
+* a plain record of the module's exports (the vite plugin imports the TSX;
+* this stays bundler-agnostic and pure).
 *
-* Discovery is exhaustive and order-preserving over `Object.entries`: every
-* function export is probed, non-templates (helpers, constants, types-erased
-* exports) are ignored silently, and a module with zero templates yields a
-* single `no-templates` diagnostic with `ok: false`.
+* A missing default yields `missing-default-export`. A present default that
+* is not a template function yields `invalid-default-export`. Both fail the
+* aggregate with an empty `templates` array.
 */
 const emitModule = (moduleExports) => {
-	const templates = [];
-	for (const [name, value] of Object.entries(moduleExports)) {
-		if (!isTemplateFunction(value)) continue;
-		templates.push(emitOne(name, value));
-	}
-	if (templates.length === 0) return {
+	if (!Object.hasOwn(moduleExports, "default")) return {
+		ok: false,
+		templates: [],
+		diagnostics: [MISSING_DEFAULT]
+	};
+	const value = moduleExports.default;
+	if (!isTemplateFunction(value)) return {
 		ok: false,
 		templates: [],
-		diagnostics: [ZERO_TEMPLATES]
+		diagnostics: [INVALID_DEFAULT]
 	};
+	const template = emitOne("default", value);
 	return {
-		ok: templates.every((template) => template.ok),
-		templates,
+		ok: template.ok,
+		templates: [template],
 		diagnostics: []
 	};
 };
@@ -126,15 +120,20 @@ const emitOne = (name, template) => {
 		ok: false,
 		source: void 0,
 		variables: [],
+		sourceLocations: {
+			kind: "unavailable",
+			reason: "render-failed"
+		},
 		diagnostics: first.failure.diagnostics
 	};
 	const rendered = first.success;
 	const second = renderTemplate(template);
-	if (Result.isSuccess(second) && second.success.source === rendered.source) return {
+	if (Result.isSuccess(second) && second.success.source === rendered.source && sameTemplateSourceLocations(second.success.sourceLocations, rendered.sourceLocations)) return {
 		name,
 		ok: true,
 		source: rendered.source,
 		variables: rendered.variables,
+		sourceLocations: rendered.sourceLocations,
 		diagnostics: []
 	};
 	return {
@@ -142,6 +141,7 @@ const emitOne = (name, template) => {
 		ok: false,
 		source: rendered.source,
 		variables: rendered.variables,
+		sourceLocations: rendered.sourceLocations,
 		diagnostics: [unstableDiagnostic(name)]
 	};
 };

package/dist/input-schema-BIfzI63B.d.ts

@@ -0,0 +1,23 @@
+import { OutputUnit } from "@cfworker/json-schema";
+import { StandardJSONSchemaV1 } from "effect/StandardSchema";
+//#region src/input-schema.d.ts
+/** JSON Schema dialect accepted by template publications. */
+declare const INPUT_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/** A compiled non-mutating validator and its complete published schema. */
+interface InputSchema<Input> {
+  readonly schema: Record<string, unknown>;
+  /** Canonical validation document; annotations are retained only in schema. */
+  readonly validationIdentity: string;
+  readonly validate: ((value: unknown) => value is Input) & {
+    errors?: readonly OutputUnit[];
+  };
+}
+/** Direct portable JSON Schema authoring; the caller declares its JSON input type. */
+declare const jsonSchema: <Input>(schema: Record<string, unknown>) => StandardJSONSchemaV1<Input>;
+/** Convert caller input, never validator output. Both conversion directions must be portable. */
+declare const inputSchema: <S extends StandardJSONSchemaV1>(source: S) => InputSchema<StandardJSONSchemaV1.InferInput<S>>;
+/** Serializable validation errors suitable for build and request diagnostics. */
+type InputIssue = OutputUnit;
+//#endregion
+export { jsonSchema as a, inputSchema as i, InputIssue as n, InputSchema as r, INPUT_SCHEMA_DIALECT as t };
+//# sourceMappingURL=input-schema-BIfzI63B.d.ts.map

package/dist/input-schema.d.ts

@@ -0,0 +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";
+export { INPUT_SCHEMA_DIALECT, InputIssue, InputSchema, inputSchema, jsonSchema };

package/dist/input-schema.js

@@ -0,0 +1,170 @@
+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
+export { INPUT_SCHEMA_DIALECT, inputSchema, jsonSchema };
+
+//# sourceMappingURL=input-schema.js.map

package/dist/jsx-dev-runtime.d.ts

@@ -1,10 +1,11 @@
-import { a as JsxResult, i as JSX, n as Fragment, t as Component } from "./jsx-runtime-fSxcvlx4.js";
+import { r as JsxSource } from "./source-locations-BCJQnIfU.js";
+import { a as JsxResult, i as JSX, n as Fragment, t as Component } from "./jsx-runtime-C5k_Zq0A.js";
 //#region src/jsx-dev-runtime.d.ts
 interface JsxDevProps {
   readonly children?: unknown;
   readonly [key: string]: unknown;
 }
-declare const jsxDEV: (type: Component<JsxDevProps> | typeof Fragment, props: JsxDevProps) => JsxResult;
+declare const jsxDEV: <P>(type: Component<P> | typeof Fragment, props: P, _key?: string | number | null, _isStaticChildren?: boolean, source?: JsxSource | null, _self?: unknown) => JsxResult;
 //#endregion
-export { Fragment, type JSX, jsxDEV };
+export { Fragment, type JSX, JsxDevProps, jsxDEV };
 //# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/dist/jsx-dev-runtime.js

@@ -1,6 +1,14 @@
+import { attachJsxSourceLocation, completeJsxSourceLocation } from "./source-locations.js";
 import { Fragment, jsx } from "./jsx-runtime.js";
 //#region src/jsx-dev-runtime.ts
-const jsxDEV = (type, props) => jsx(type, props);
+const jsxDEV = (type, props, _key, _isStaticChildren, source, _self) => {
+	const result = jsx(type, props);
+	if (type !== Fragment && result.kind === "element") {
+		const location = completeJsxSourceLocation(source);
+		if (location !== void 0) attachJsxSourceLocation(result, location);
+	}
+	return result;
+};
 //#endregion
 export { Fragment, jsxDEV };
 

package/dist/{jsx-runtime-fSxcvlx4.d.ts → jsx-runtime-C5k_Zq0A.d.ts}

@@ -1,5 +1,5 @@
-import { T as SmlNode, m as ElementNode, n as Attribute } from "./ast-DAhnAvQN.js";
-import { s as VariableRef } from "./variables-3NGLpNTB.js";
+import { E as SmlNode, m as ElementNode, n as Attribute } from "./ast-63I-VLQx.js";
+import { s as VariableRef } from "./variables-if1VrV34.js";
 //#region src/jsx-runtime.d.ts
 /** A component is a plain function of its props that returns a draft node. */
 type Component<P> = (props: P) => SmlNode;
@@ -41,7 +41,7 @@ interface JsxProps {
  * children), so `jsxs` re-exports this.
  */
 declare const jsx: (type: Component<JsxProps> | typeof Fragment, props: JsxProps) => JsxResult;
-declare const jsxs: (type: Component<JsxProps> | typeof Fragment, props: JsxProps) => JsxResult;
+declare const jsxs: typeof jsx;
 /** Groups children without an element wrapper. Its children splice into the parent. */
 declare const Fragment: unique symbol;
 declare namespace JSX {
@@ -54,4 +54,4 @@ declare namespace JSX {
 }
 //#endregion
 export { JsxResult as a, elementDraft as c, normalizeChildren as d, JSX as i, jsx as l, Fragment as n, SmlChild as o, FragmentDraft as r, SmlChildren as s, Component as t, jsxs as u };
-//# sourceMappingURL=jsx-runtime-fSxcvlx4.d.ts.map
+//# sourceMappingURL=jsx-runtime-C5k_Zq0A.d.ts.map

package/dist/jsx-runtime.d.ts

@@ -1,2 +1,2 @@
-import { a as JsxResult, c as elementDraft, d as normalizeChildren, i as JSX, l as jsx, n as Fragment, o as SmlChild, r as FragmentDraft, s as SmlChildren, t as Component, u as jsxs } from "./jsx-runtime-fSxcvlx4.js";
+import { a as JsxResult, c as elementDraft, d as normalizeChildren, i as JSX, l as jsx, n as Fragment, o as SmlChild, r as FragmentDraft, s as SmlChildren, t as Component, u as jsxs } from "./jsx-runtime-C5k_Zq0A.js";
 export { Component, Fragment, FragmentDraft, JSX, JsxResult, SmlChild, SmlChildren, elementDraft, jsx, jsxs, normalizeChildren };

package/dist/jsx-runtime.js

@@ -1,3 +1,4 @@
+import { JSX_SOURCE_LOCATION_PROP, attachJsxSourceLocation, completeJsxSourceLocation } from "./source-locations.js";
 import { VARIABLE_REF, isVariableRef } from "./variables.js";
 import { Predicate } from "effect";
 //#region src/jsx-runtime.ts
@@ -79,6 +80,18 @@ const elementDraft = (tag, attributes, children) => ({
 	children,
 	span: PLACEHOLDER_SPAN
 });
+const stripSourceLocation = (props) => {
+	const source = props[JSX_SOURCE_LOCATION_PROP];
+	if (source === void 0) return {
+		props,
+		source: void 0
+	};
+	const { [JSX_SOURCE_LOCATION_PROP]: _source, ...rest } = props;
+	return {
+		props: rest,
+		source
+	};
+};
 /**
 * The automatic-runtime entry point. `type` is always one of our typed
 * component functions (or `Fragment`); we invoke it with its props. The JSX
@@ -91,7 +104,13 @@ const jsx = (type, props) => {
 		kind: "fragment",
 		children: normalizeChildren(props.children)
 	};
-	return type(props);
+	const { props: cleanProps, source } = stripSourceLocation(props);
+	const result = type(cleanProps);
+	if (source !== void 0 && result.kind === "element") {
+		const location = completeJsxSourceLocation(source);
+		if (location !== void 0) attachJsxSourceLocation(result, location);
+	}
+	return result;
 };
 const jsxs = jsx;
 /** Groups children without an element wrapper. Its children splice into the parent. */

package/dist/model.d.ts

@@ -1,4 +1,4 @@
-import { C as SmlDocument, D as SmlTag } from "./ast-DAhnAvQN.js";
+import { O as SmlTag, w as SmlDocument } from "./ast-63I-VLQx.js";
 import { Result, Schema } from "effect";
 //#region src/model.d.ts
 declare const SmlNodeKeyAttrsSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite]>>;

package/dist/ops.d.ts

@@ -1,5 +1,5 @@
 import { o as SmlParseError } from "./diagnostics-oveE-laV.js";
-import { T as SmlNode } from "./ast-DAhnAvQN.js";
+import { E as SmlNode } from "./ast-63I-VLQx.js";
 import { Result, Schema } from "effect";
 //#region src/ops.d.ts
 /**

package/dist/ops.js

@@ -2,7 +2,7 @@ import { DiagnosticSchema } from "./diagnostics.js";
 import { AttributeValueSchema, SML_TAGS, SmlNodeSchema, documentChannel } from "./ast.js";
 import { CHANNEL_TAG_SPECS, allowedChildren, parseSml } from "./parser.js";
 import { compileSml } from "./compile.js";
-import { i as isBreakingCompatibilityCheck, n as checkSmlCompatibility } from "./checks-CW0nFj5n.js";
+import { a as isBreakingCompatibilityCheck, r as checkSmlCompatibility } from "./checks-DXuERO4B.js";
 import { printSml } from "./printer.js";
 import { Result, Schema } from "effect";
 //#region src/ops.ts
@@ -74,7 +74,7 @@ const ApplyOpsResultSchema = Schema.Struct({
 	diagnostics: Schema.Array(DiagnosticSchema),
 	results: Schema.Array(SmlOpResultSchema)
 });
-var SmlOpError = class extends Schema.TaggedErrorClass()("SmlOpError", { diagnostics: Schema.Array(DiagnosticSchema) }) {
+var SmlOpError = class extends Schema.TaggedError()("SmlOpError", { diagnostics: Schema.Array(DiagnosticSchema) }) {
 	get message() {
 		return this.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
 	}

package/dist/{parser-yzjUOGhc.d.ts → parser-CGBS73Gz.d.ts}

@@ -1,6 +1,15 @@
 import { o as SmlParseError } from "./diagnostics-oveE-laV.js";
-import { C as SmlDocument, D as SmlTag, d as Channel } from "./ast-DAhnAvQN.js";
+import { O as SmlTag, d as Channel, w as SmlDocument } from "./ast-63I-VLQx.js";
 import { Result } from "effect";
+//#region src/limits.d.ts
+/** Hard ceilings shared by SML documents and standalone predicate parsing. */
+declare const SML_PARSER_LIMITS: {
+  readonly maxCharacters: 500000;
+  readonly maxUtf8Bytes: number;
+  readonly maxDepth: 64;
+  readonly maxNodes: 25000;
+};
+//#endregion
 //#region src/parser.d.ts
 type ContentModel = "email" | "block" | "columns" | "list" | "image" | "if" | "inline" | "inline-nolink" | "preview" | "whatsapp" | "buttons" | "verbatim" | "verbatim-if" | "void";
 interface AttributeSpec {
@@ -383,5 +392,5 @@ declare const UNIVERSAL_ATTRIBUTE_TAGS: ReadonlySet<SmlTag>;
 declare const allowedChildren: (model: ContentModel) => ReadonlyArray<SmlTag>;
 declare const parseSml: (source: string) => Result.Result<SmlDocument, SmlParseError>;
 //#endregion
-export { SMS_TAG_SPECS as a, UNIVERSAL_ATTRIBUTE_TAGS as c, parseSml as d, EMAIL_TAG_SPECS as i, WHATSAPP_TAG_SPECS as l, CHANNEL_TAG_SPECS as n, TagSpec as o, ContentModel as r, UNIVERSAL_ATTRIBUTES as s, AttributeSpec as t, allowedChildren as u };
-//# sourceMappingURL=parser-yzjUOGhc.d.ts.map
+export { SMS_TAG_SPECS as a, UNIVERSAL_ATTRIBUTE_TAGS as c, parseSml as d, SML_PARSER_LIMITS as f, EMAIL_TAG_SPECS as i, WHATSAPP_TAG_SPECS as l, CHANNEL_TAG_SPECS as n, TagSpec as o, ContentModel as r, UNIVERSAL_ATTRIBUTES as s, AttributeSpec as t, allowedChildren as u };
+//# sourceMappingURL=parser-CGBS73Gz.d.ts.map

package/dist/parser.d.ts

@@ -1,2 +1,2 @@
-import { a as SMS_TAG_SPECS, c as UNIVERSAL_ATTRIBUTE_TAGS, d as parseSml, i as EMAIL_TAG_SPECS, l as WHATSAPP_TAG_SPECS, n as CHANNEL_TAG_SPECS, o as TagSpec, r as ContentModel, s as UNIVERSAL_ATTRIBUTES, t as AttributeSpec, u as allowedChildren } from "./parser-yzjUOGhc.js";
-export { AttributeSpec, CHANNEL_TAG_SPECS, ContentModel, EMAIL_TAG_SPECS, SMS_TAG_SPECS, TagSpec, UNIVERSAL_ATTRIBUTES, UNIVERSAL_ATTRIBUTE_TAGS, WHATSAPP_TAG_SPECS, allowedChildren, parseSml };
+import { a as SMS_TAG_SPECS, c as UNIVERSAL_ATTRIBUTE_TAGS, d as parseSml, f as SML_PARSER_LIMITS, i as EMAIL_TAG_SPECS, l as WHATSAPP_TAG_SPECS, n as CHANNEL_TAG_SPECS, o as TagSpec, r as ContentModel, s as UNIVERSAL_ATTRIBUTES, t as AttributeSpec, u as allowedChildren } from "./parser-CGBS73Gz.js";
+export { AttributeSpec, CHANNEL_TAG_SPECS, ContentModel, EMAIL_TAG_SPECS, SML_PARSER_LIMITS, SMS_TAG_SPECS, TagSpec, UNIVERSAL_ATTRIBUTES, UNIVERSAL_ATTRIBUTE_TAGS, WHATSAPP_TAG_SPECS, allowedChildren, parseSml };