@asterdoc/schemas 0.0.0-stage → 0.10.0

package/dist/index.js

@@ -0,0 +1,2096 @@
+// src/zod/config.ts
+var SCHEMA_VERSIONS = ["2026-10-28"];
+var SCHEMA_VERSION = "2026-10-28";
+var SCHEMA_BASE = "https://schema.asterdoc.com";
+var MANIFEST_SCHEMA_ID = `${SCHEMA_BASE}/manifest.json`;
+var CONFIG_SCHEMA_ID = `${SCHEMA_BASE}/config.json`;
+var LOCK_SCHEMA_ID = `${SCHEMA_BASE}/lock.json`;
+var REGISTRY_SCHEMA_ID = `${SCHEMA_BASE}/registry.json`;
+var REGISTRY_ITEM_SCHEMA_ID = `${SCHEMA_BASE}/registry-item.json`;
+var SCHEMA_ROOT_ID = `${SCHEMA_BASE}/schema.json`;
+var SCHEMA_VERSIONED_ID = `${SCHEMA_BASE}/${SCHEMA_VERSION}.json`;
+var schemaId = (name) => `${SCHEMA_BASE}/${SCHEMA_VERSION}/${name}.json`;
+function schemaVersionUrl(version) {
+  return `${SCHEMA_BASE}/${version}.json`;
+}
+function isSchemaVersion(value) {
+  return SCHEMA_VERSIONS.includes(value);
+}
+var DATED_ADDRESS = /^([0-9]{4}-[0-9]{2}-[0-9]{2})(?:\.json|\/[a-z][a-z0-9-]*\.json)$/;
+function readSchemaAddress(address) {
+  const prefix = `${SCHEMA_BASE}/`;
+  if (!address.startsWith(prefix)) return { kind: "foreign" };
+  const rest = address.slice(prefix.length);
+  const match = DATED_ADDRESS.exec(rest);
+  if (!match) return { kind: "undated" };
+  const version = match[1];
+  return isSchemaVersion(version) ? { kind: "known", version } : { kind: "unknown-version", version };
+}
+
+// src/zod/module.ts
+import { z as z35 } from "zod";
+
+// src/zod/artifacts/form/index.ts
+import { z as z30 } from "zod";
+
+// src/zod/primitives/name.ts
+var ARTIFACT_NAME_PATTERN = /^[A-Za-z0-9]([A-Za-z0-9]|-[A-Za-z0-9])*$/;
+var IDENTIFIER_PATTERN = /^[a-z][a-zA-Z0-9_]*$/;
+var REGISTRY_NAMESPACE_PATTERN = /^@[a-zA-Z0-9][a-zA-Z0-9-_]*$/;
+var HOSTNAME_NAMESPACE_SOURCE = "@[a-z0-9-]+(?:\\.[a-z0-9-]+)+";
+var unanchored = (pattern) => pattern.source.slice(1, -1);
+var ARTIFACT_REFERENCE_PATTERN = new RegExp(
+  `^(?:${unanchored(REGISTRY_NAMESPACE_PATTERN)}|${HOSTNAME_NAMESPACE_SOURCE})/${unanchored(ARTIFACT_NAME_PATTERN)}$`
+);
+
+// src/zod/artifacts/shared/base.ts
+import { z as z6 } from "zod";
+
+// src/zod/primitives/metadata.ts
+import { z } from "zod";
+var MetadataSchema = z.record(
+  z.string().min(1).max(100).regex(/^[A-Za-z0-9]([A-Za-z0-9]|-[A-Za-z0-9])*$/).describe("Metadata key identifier. Must start with alphanumeric character and can contain alphanumeric characters and hyphens"),
+  z.union([
+    z.string().max(500).describe("Metadata value as a string (max 500 characters)"),
+    z.number().describe("Metadata value as a number"),
+    z.boolean().describe("Metadata value as a boolean"),
+    z.null().describe("Metadata value as null")
+  ])
+).meta({
+  title: "Metadata",
+  description: "Custom key-value pairs for storing domain-specific or organizational metadata. Keys must be alphanumeric with hyphens, values can be strings, numbers, booleans, or null"
+});
+
+// src/zod/primitives/version.ts
+var CORE_AND_PRERELEASE_SOURCE = "(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?";
+var BUILD_METADATA_SOURCE = "(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?";
+var ARTIFACT_VERSION_PATTERN = new RegExp(`^${CORE_AND_PRERELEASE_SOURCE}${BUILD_METADATA_SOURCE}$`);
+var REGISTRY_VERSION_PATTERN = new RegExp(`^${CORE_AND_PRERELEASE_SOURCE}$`);
+function parseVersion(version) {
+  const match = ARTIFACT_VERSION_PATTERN.exec(version);
+  if (!match) return void 0;
+  const prerelease = match[4];
+  return {
+    core: [match[1], match[2], match[3]],
+    prerelease: prerelease === void 0 ? [] : prerelease.split(".")
+  };
+}
+var NUMERIC_IDENTIFIER = /^\d+$/;
+function compareNumeric(a, b) {
+  if (a.length !== b.length) return a.length < b.length ? -1 : 1;
+  return compareText(a, b);
+}
+function compareText(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 || b.length === 0) return b.length - a.length;
+  for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
+    const left = a[i];
+    const right = b[i];
+    const leftNumeric = NUMERIC_IDENTIFIER.test(left);
+    const rightNumeric = NUMERIC_IDENTIFIER.test(right);
+    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+    const order = leftNumeric ? compareNumeric(left, right) : compareText(left, right);
+    if (order !== 0) return order;
+  }
+  return a.length - b.length;
+}
+function compareArtifactVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) {
+    if (!left && !right) return compareText(a, b);
+    return left ? 1 : -1;
+  }
+  for (let i = 0; i < 3; i += 1) {
+    const order = compareNumeric(left.core[i], right.core[i]);
+    if (order !== 0) return order;
+  }
+  return Math.sign(comparePrerelease(left.prerelease, right.prerelease));
+}
+
+// src/zod/artifacts/shared/content-ref.ts
+import { z as z3 } from "zod";
+
+// src/zod/primitives/checksum.ts
+import { z as z2 } from "zod";
+var ChecksumSchema = z2.string().regex(/^sha256:[a-f0-9]{64}$/).describe("SHA-256 checksum for integrity verification");
+
+// src/zod/artifacts/shared/content-ref.ts
+var InlineContentRefSchema = z3.object({
+  kind: z3.literal("inline"),
+  text: z3.string().min(1).max(1e6).describe("Inline text content")
+}).strict().meta({
+  title: "InlineContentRef",
+  description: "Inline content reference with embedded text"
+});
+var FileContentRefSchema = z3.object({
+  kind: z3.literal("file"),
+  path: z3.string().min(1).max(1e3).describe("Path to the content file"),
+  mimeType: z3.string().min(1).max(100).describe("MIME type of the file content"),
+  title: z3.string().min(1).max(200).describe("Human-readable title").optional(),
+  description: z3.string().min(1).max(2e3).describe("Description of the content").optional(),
+  checksum: ChecksumSchema.optional()
+}).strict().meta({
+  title: "FileContentRef",
+  description: "File content reference with path and metadata"
+});
+var ContentRefSchema = z3.discriminatedUnion("kind", [
+  InlineContentRefSchema,
+  FileContentRefSchema
+]).meta({
+  title: "ContentRef",
+  description: "Content reference \u2014 inline text or file reference"
+});
+
+// src/zod/artifacts/shared/edition.ts
+import { z as z5 } from "zod";
+
+// src/zod/primitives/artifact-selectors.ts
+import { z as z4 } from "zod";
+
+// src/zod/primitives/artifact-coordinate.ts
+var SEGMENT_SOURCE = "[a-z0-9](?:[a-z0-9]|-[a-z0-9])*";
+var COORDINATE_SEGMENT_PATTERN = new RegExp(`^${SEGMENT_SOURCE}$`);
+var CURRENT_EDITION = "current";
+var LATEST_VERSION = "latest";
+var RESERVED_EDITION_KEYS = ["current", "latest", "editions", "tags", "diff"];
+function isReservedEditionKey(value) {
+  return RESERVED_EDITION_KEYS.includes(value);
+}
+var EDITION_KEY_PATTERN = /^[a-z0-9]([a-z0-9]|-[a-z0-9])*$/;
+var EDITION_KEY_MAX_LENGTH = 64;
+var EDITION_KEY_SCHEMA_PATTERN = new RegExp(
+  `^(?!(?:${RESERVED_EDITION_KEYS.join("|")})$)${EDITION_KEY_PATTERN.source.slice(1)}`
+);
+var unanchored2 = (pattern) => pattern.source.slice(1, -1);
+var ADDRESS_SOURCE = `@?${SEGMENT_SOURCE}/${SEGMENT_SOURCE}/${SEGMENT_SOURCE}`;
+var VERSION_SOURCE = `${LATEST_VERSION}|${unanchored2(ARTIFACT_VERSION_PATTERN)}`;
+var EDITION_SOURCE = [
+  `(?!(?:${RESERVED_EDITION_KEYS.filter((key) => key !== CURRENT_EDITION).join("|")})(?:@|$))`,
+  `(?=[a-z0-9-]{1,${EDITION_KEY_MAX_LENGTH}}(?:@|$))`,
+  unanchored2(EDITION_KEY_PATTERN)
+].join("");
+var ARTIFACT_ADDRESS_PATTERN = new RegExp(`^${ADDRESS_SOURCE}$`);
+var ARTIFACT_COORDINATE_PATTERN = new RegExp(
+  `^${ADDRESS_SOURCE}(?:/(?:${EDITION_SOURCE}))?(?:@(?:${VERSION_SOURCE}))?$`
+);
+var COORDINATE_PARTS = new RegExp(
+  `^@?(?<org>${SEGMENT_SOURCE})/(?<repo>${SEGMENT_SOURCE})/(?<name>${SEGMENT_SOURCE})(?:/(?<edition>${EDITION_SOURCE}))?(?:@(?<version>${VERSION_SOURCE}))?$`
+);
+function parseArtifactCoordinate(value) {
+  const match = COORDINATE_PARTS.exec(value);
+  if (!match) return void 0;
+  const { org, repo, name, edition, version } = match.groups;
+  if (edition !== void 0 && edition !== CURRENT_EDITION && isReservedEditionKey(edition)) return void 0;
+  if (edition !== void 0 && edition.length > EDITION_KEY_MAX_LENGTH) return void 0;
+  return {
+    org,
+    repo,
+    name,
+    ...edition !== void 0 && edition !== CURRENT_EDITION && { edition },
+    ...version !== void 0 && version !== LATEST_VERSION && { version }
+  };
+}
+function formatArtifactCoordinate(coordinate) {
+  const edition = coordinate.edition === void 0 ? "" : `/${coordinate.edition}`;
+  const version = coordinate.version === void 0 ? "" : `@${coordinate.version}`;
+  return `@${coordinate.org}/${coordinate.repo}/${coordinate.name}${edition}${version}`;
+}
+function isEditionSelector(value) {
+  return value === CURRENT_EDITION || value.length <= EDITION_KEY_MAX_LENGTH && EDITION_KEY_PATTERN.test(value) && !isReservedEditionKey(value);
+}
+function isVersionSelector(value) {
+  return value === LATEST_VERSION || ARTIFACT_VERSION_PATTERN.test(value);
+}
+
+// src/zod/primitives/artifact-selectors.ts
+var EditionKeySchema = z4.string().min(1).max(EDITION_KEY_MAX_LENGTH).regex(
+  EDITION_KEY_SCHEMA_PATTERN,
+  `Expected an edition key: lowercase letters and digits with single hyphens, such as 2024-03, and not one of ${RESERVED_EDITION_KEYS.join(", ")}`
+);
+var EditionSelectorSchema = z4.string().max(EDITION_KEY_MAX_LENGTH).refine(isEditionSelector, "Expected an edition key, such as 2024-03, or 'current'");
+var VersionSelectorSchema = z4.string().max(200).refine(isVersionSelector, "Expected a version, such as 1.2.0, or 'latest'");
+var ArtifactCoordinateSchema = z4.string().regex(
+  ARTIFACT_COORDINATE_PATTERN,
+  "Expected a registry coordinate such as @org/repo/name, @org/repo/name/2024-03 or @org/repo/name/2024-03@1.0.0"
+);
+
+// src/zod/artifacts/shared/edition.ts
+var EDITION_DATE_PATTERN = new RegExp(
+  `^(?:\\d{4}(?:-(?:0[1-9]|1[0-2]))?|${z5.regexes.date.source.slice(1, -1)})$`
+);
+var editionFactsShape = {
+  label: z5.string().min(1).max(200).describe(`The issuer's edition text exactly as printed, such as "Rev. March 2024". For display only.`),
+  date: z5.string().regex(EDITION_DATE_PATTERN, "Expected an edition date as YYYY, YYYY-MM or YYYY-MM-DD that names a real day").describe("When the issuer released the edition, at the precision the issuer gives: YYYY, YYYY-MM or YYYY-MM-DD.").optional(),
+  effectiveFrom: z5.iso.date().describe("The date the edition takes effect. Only when the issuer prints one.").optional()
+};
+var ArtifactEditionSchema = z5.object({
+  key: EditionKeySchema.describe("Stable edition identifier, unique among the editions of one artifact (for example 2024-03 or 3b). Lowercase letters and digits with single hyphens, and not current, latest, editions, tags or diff. It is the edition segment of a coordinate such as @org/repo/w-9/2024-03 and never changes once published."),
+  ...editionFactsShape
+}).strict().meta({
+  title: "ArtifactEdition",
+  description: "One edition of an issued artifact, as printed by its issuer. Facts the issuer decides later, such as which edition is current, are not part of it."
+});
+
+// src/zod/artifacts/shared/base.ts
+var ArtifactSchema = z6.object({
+  $schema: z6.url().describe("JSON Schema URI for this artifact instance.").optional(),
+  name: z6.string().min(1).max(128).regex(ARTIFACT_NAME_PATTERN).describe("Artifact identifier. Must start with a letter or digit, can contain letters, numbers, and hyphens (no leading/trailing/consecutive hyphens). Every edition of one artifact shares the same name."),
+  version: z6.string().min(1).max(200).regex(ARTIFACT_VERSION_PATTERN).describe("Artifact version (SemVer 2.0.0, such as 1.2.3 or 1.3.0-beta.1). It counts the publisher's own changes, never the issuer's edition; each edition has its own version line. Required for publishing to registry.").optional(),
+  title: z6.string().min(1).max(200).describe("Human-readable title. Recommended for published/shared artifacts and directory browsing.").optional(),
+  description: z6.string().min(0).max(2e3).describe("Detailed description or context for the artifact.").optional(),
+  code: z6.string().min(1).max(200).describe("The form number as printed by its issuer, such as W-9 or ACORD 25, or a self-issued form's own number.").optional(),
+  issuer: z6.string().min(1).max(200).describe("The organization that issues the form, such as U.S. Internal Revenue Service.").optional(),
+  edition: ArtifactEditionSchema.describe("The issuer's edition this artifact encodes. Omitted for artifacts that are not issued in editions.").optional(),
+  language: z6.string().min(2).max(35).regex(/^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/).describe("BCP 47-style source language tag for this artifact. Defaults to en when omitted.").optional(),
+  metadata: MetadataSchema.describe("Custom key-value pairs for storing domain-specific or organizational metadata").optional(),
+  instructions: ContentRefSchema.describe("Domain or compliance reference content (e.g., IRS instructions, regulatory guidance)").optional(),
+  agentInstructions: ContentRefSchema.describe("LLM/agent prompts for field ordering, grouping, tone, and presentation guidance").optional()
+}).meta({
+  title: "Artifact",
+  description: "Root schema for all Asterdoc artifacts (containers and documents)."
+});
+
+// src/zod/artifacts/shared/layer.ts
+import { z as z7 } from "zod";
+var SignatureSlotTypeSchema = z7.enum(["signature", "initials", "date_signed", "capacity", "printed_name"]).describe("Type of signing field: signature/initials (glyph), date_signed, capacity (signer role/title), or printed_name");
+var AbsolutePlacementSchema = z7.object({
+  page: z7.number().int().min(1).describe("1-based page number"),
+  x: z7.number().min(0).describe("X in points from the left page edge"),
+  y: z7.number().min(0).describe("Y in points from the top page edge"),
+  width: z7.number().min(1).describe("Width in points"),
+  height: z7.number().min(1).describe("Height in points")
+}).strict().meta({ title: "AbsolutePlacement" });
+var AnchorPlacementSchema = z7.object({
+  anchor: z7.object({
+    text: z7.string().min(1).max(500).describe("Literal document text to find; must be unique unless occurrence is set"),
+    offsetX: z7.number().describe("Horizontal offset in points from the left of the found text").optional(),
+    offsetY: z7.number().describe("Vertical offset in points from the top of the found text").optional(),
+    occurrence: z7.number().int().min(1).describe("1-based match index in reading order when the text repeats").optional()
+  }).strict(),
+  width: z7.number().min(1).describe("Width in points"),
+  height: z7.number().min(1).describe("Height in points")
+}).strict().meta({ title: "AnchorPlacement" });
+var SignatureSlotSchema = z7.object({
+  party: z7.object({
+    role: z7.string().min(1).max(100).describe("Party role this slot binds to"),
+    index: z7.number().int().min(0).describe("0-based index for multi-party roles; defaults to 0").optional()
+  }).strict(),
+  type: SignatureSlotTypeSchema,
+  required: z7.boolean().describe("Whether this slot must be signed. Defaults to true").optional(),
+  label: z7.string().min(1).max(200).describe("Human-readable label").optional(),
+  placement: z7.union([
+    z7.literal("flow").describe("In-flow: the field sits where the template content places it; located after conversion via an injected marker"),
+    AbsolutePlacementSchema,
+    AnchorPlacementSchema
+  ]).describe("Placement: 'flow', absolute coordinates, or a text anchor")
+}).strict().meta({
+  title: "SignatureSlot",
+  description: "Signature slot binding a party to a placement on this layer"
+});
+var REACT_LAYER_MIME_TYPES = ["text/tsx", "text/jsx"];
+function isReactLayerMimeType(mimeType) {
+  return mimeType !== void 0 && REACT_LAYER_MIME_TYPES.includes(mimeType.toLowerCase());
+}
+var REACT_LAYER_RULE = `React layers must be file layers: ${REACT_LAYER_MIME_TYPES.join(" and ")} name a composition module by path, so an inline layer cannot declare one`;
+function caseInsensitiveAlternative(value) {
+  return [...value].map(
+    (character) => /[a-z]/i.test(character) ? `[${character.toLowerCase()}${character.toUpperCase()}]` : character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  ).join("");
+}
+var REACT_LAYER_MIME_PATTERN = `^(?:${REACT_LAYER_MIME_TYPES.map(caseInsensitiveAlternative).join("|")})$`;
+var LayerBaseSchema = z7.object({
+  mimeType: z7.string().min(1).max(100).describe("MIME type of the layer content (e.g., text/markdown, application/pdf)"),
+  title: z7.string().min(1).max(200).describe("Human-readable title for this layer").optional(),
+  description: z7.string().min(1).max(2e3).describe("Description of what this layer represents").optional(),
+  signatures: z7.record(
+    z7.string().min(1).max(100).describe("Slot ID"),
+    SignatureSlotSchema
+  ).describe("Signature slots keyed by slot id").optional()
+});
+var InlineLayerSchema = LayerBaseSchema.extend({
+  kind: z7.literal("inline"),
+  // The exclusion is stated to JSON Schema as well as to Zod: a refinement
+  // alone would validate at runtime and vanish from the published schema.
+  mimeType: z7.string().min(1).max(100).refine((value) => !isReactLayerMimeType(value), { error: REACT_LAYER_RULE }).describe("MIME type of the layer content (e.g., text/markdown). Never a React composition type").meta({ not: { pattern: REACT_LAYER_MIME_PATTERN } }),
+  text: z7.string().min(1).max(1e6).describe("Layer content with interpolation placeholders (e.g., {{fields.fieldName}})")
+}).strict().meta({
+  title: "InlineLayer",
+  description: "Inline layer with embedded content"
+});
+var LAYER_FONT_RULE = "Only PDF layers (application/pdf) can declare a font";
+var LAYER_BINDINGS_RULE = "Only PDF layers (application/pdf) can declare bindings; other templates name values as {{fields.fieldName}}";
+var PDF_MIME_PATTERN = `^${caseInsensitiveAlternative("application/pdf")}$`;
+function isPdfMimeType(mimeType) {
+  return mimeType.toLowerCase() === "application/pdf";
+}
+var DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+function isDocxMimeType(mimeType) {
+  return mimeType.toLowerCase() === DOCX_MIME_TYPE;
+}
+var TEXT_TEMPLATE_MIME_TYPES = ["text/plain", "text/markdown", "text/html"];
+function isTextTemplateMimeType(mimeType) {
+  return TEXT_TEMPLATE_MIME_TYPES.includes(mimeType.toLowerCase());
+}
+var PdfBindingsSchema = z7.record(
+  z7.string().min(1).max(500).describe("AcroForm field name in the PDF template, fully qualified (e.g., topmostSubform[0].Page1[0].f1_01[0])"),
+  z7.string().min(1).max(500).describe("Asterdoc path whose value fills the field (e.g., fields.name, parties.buyer.name)")
+).describe("PDF layers only. Maps each AcroForm field name (key) to the Asterdoc path (value) that fills it");
+var PdfBindingsFromSchema = z7.string().min(1).max(128).describe("PDF layers only. Key of a sibling PDF layer whose bindings this layer reuses");
+function pdfOnlyLayerKeysJsonSchema(keys) {
+  return keys.map((key) => ({
+    if: { required: [key] },
+    then: { properties: { mimeType: { pattern: PDF_MIME_PATTERN } } }
+  }));
+}
+var LayerFontSchema = z7.object({
+  path: z7.string().min(1).max(1e3).describe("Logical resolver path of a TrueType-outline font program (.ttf), resolved like the layer path"),
+  checksum: ChecksumSchema.optional()
+}).strict().meta({
+  title: "LayerFont",
+  description: "Font a PDF layer draws filled values and overlay text with"
+});
+var LAYER_FORMAT_RULE = "Only PDF layers (application/pdf) can declare a format";
+var LayerMoneyFormatSchema = z7.object({
+  currencyDisplay: z7.literal("none").describe("`none` prints the amount without a currency symbol or code, for a template that pre-prints the symbol beside each money box")
+}).strict().meta({
+  title: "LayerMoneyFormat",
+  description: "How a PDF layer presents money values"
+});
+var LayerFormatSchema = z7.object({
+  money: LayerMoneyFormatSchema.optional()
+}).strict().meta({
+  title: "LayerFormat",
+  description: "Presentation a PDF layer's template requires of filled values, applied over the caller's formatter"
+});
+var FileLayerObjectSchema = LayerBaseSchema.extend({
+  kind: z7.literal("file"),
+  path: z7.string().min(1).max(1e3).describe("Logical resolver path; the CLI resolves file-backed artifacts from their directory and stdin artifacts from cwd"),
+  checksum: ChecksumSchema.optional(),
+  font: LayerFontSchema.describe("Font for filled values and overlay text; PDF layers only. It is tried after a font supplied at render time and before the form's own fonts").optional(),
+  format: LayerFormatSchema.describe("Presentation the template requires of filled values; PDF layers only. It applies to this layer alone, not to a layer that reuses its bindings").optional(),
+  bindings: PdfBindingsSchema.optional(),
+  bindingsFrom: PdfBindingsFromSchema.optional()
+}).strict();
+var PDF_ONLY_FILE_LAYER_KEYS = ["font", "format", "bindings", "bindingsFrom"];
+function withPdfOnlyFileLayerRules(schema) {
+  return schema.refine(
+    (layer) => layer.font === void 0 || isPdfMimeType(layer.mimeType),
+    { error: LAYER_FONT_RULE, path: ["font"] }
+  ).refine(
+    (layer) => layer.format === void 0 || isPdfMimeType(layer.mimeType),
+    { error: LAYER_FORMAT_RULE, path: ["format"] }
+  ).refine(
+    (layer) => layer.bindings === void 0 || isPdfMimeType(layer.mimeType),
+    { error: LAYER_BINDINGS_RULE, path: ["bindings"] }
+  ).refine(
+    (layer) => layer.bindingsFrom === void 0 || isPdfMimeType(layer.mimeType),
+    { error: LAYER_BINDINGS_RULE, path: ["bindingsFrom"] }
+  );
+}
+var FileLayerSchema = withPdfOnlyFileLayerRules(FileLayerObjectSchema.meta({
+  title: "FileLayer",
+  description: "File-backed layer with path reference"
+}));
+var LayerSchema = z7.discriminatedUnion("kind", [
+  InlineLayerSchema,
+  FileLayerSchema
+]).meta({
+  title: "Layer",
+  description: "Layer specification \u2014 inline content or file reference",
+  // The file layer's font, format and bindings refinements.
+  allOf: pdfOnlyLayerKeysJsonSchema(PDF_ONLY_FILE_LAYER_KEYS)
+});
+var REACT_LAYER_FORM_ONLY_RULE = `Only a form can declare a React layer: a composition renders a form and its data, so a document or checklist layer cannot be ${REACT_LAYER_MIME_TYPES.join(" or ")}`;
+function withoutReactLayers(layers) {
+  return layers.superRefine((value, ctx) => {
+    for (const [key, layer] of Object.entries(value)) {
+      if (isReactLayerMimeType(layer.mimeType)) {
+        ctx.addIssue({ code: "custom", path: [key, "mimeType"], message: REACT_LAYER_FORM_ONLY_RULE });
+      }
+    }
+  }).meta({
+    allOf: [{
+      additionalProperties: {
+        not: { properties: { mimeType: { pattern: REACT_LAYER_MIME_PATTERN } }, required: ["mimeType"] }
+      }
+    }]
+  });
+}
+
+// src/zod/artifacts/expressions/defs-section.ts
+import { z as z9 } from "zod";
+
+// src/zod/artifacts/expressions/expression.ts
+import { z as z8 } from "zod";
+var BaseExpressionSchema = z8.object({
+  label: z8.string().min(1).max(200).describe("Display label for the computed value").optional(),
+  description: z8.string().min(1).max(1e3).describe("Description or documentation of the computed value").optional()
+}).strict();
+var ExpressionString = z8.string().min(1).max(2e3).describe("Expression string to evaluate");
+var OptionalExpressionString = ExpressionString.optional();
+var BooleanExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("boolean"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to a boolean")
+});
+var StringExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("string"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to a string")
+});
+var NumberExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("number"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to a number")
+});
+var IntegerExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("integer"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to an integer")
+});
+var PercentageExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("percentage"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to a percentage (0-100)")
+});
+var RatingExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("rating"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to a rating value")
+});
+var DateExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("date"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to an ISO 8601 date (YYYY-MM-DD)")
+});
+var TimeExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("time"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to a time (HH:MM:SS)")
+});
+var DatetimeExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("datetime"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to an ISO 8601 datetime")
+});
+var DurationExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("duration"),
+  value: z8.string().min(1).max(2e3).describe("Expression that evaluates to an ISO 8601 duration string")
+});
+var MoneyExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("money"),
+  value: z8.object({
+    amount: ExpressionString,
+    currency: ExpressionString
+  }).strict().describe("Money object with amount and currency expressions")
+});
+var AddressExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("address"),
+  value: z8.object({
+    line1: ExpressionString,
+    line2: OptionalExpressionString,
+    locality: ExpressionString,
+    region: ExpressionString,
+    postalCode: ExpressionString,
+    country: ExpressionString
+  }).strict().describe("Address object with component expressions")
+});
+var PhoneExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("phone"),
+  value: z8.object({
+    number: ExpressionString,
+    type: OptionalExpressionString,
+    extension: OptionalExpressionString
+  }).strict().describe("Phone object with number and optional type/extension expressions")
+});
+var CoordinateExpressionValueSchema = z8.object({
+  lat: ExpressionString,
+  lon: ExpressionString
+}).strict();
+var CoordinateExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("coordinate"),
+  value: CoordinateExpressionValueSchema.describe("Coordinate object with latitude and longitude expressions")
+});
+var BboxExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("bbox"),
+  value: z8.object({
+    southWest: CoordinateExpressionValueSchema.describe("Southwest (minimum) corner expressions"),
+    northEast: CoordinateExpressionValueSchema.describe("Northeast (maximum) corner expressions")
+  }).strict().describe("Bounding box with southwest and northeast corner expressions")
+});
+var PersonExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("person"),
+  value: z8.object({
+    name: ExpressionString,
+    title: OptionalExpressionString,
+    firstName: OptionalExpressionString,
+    middleName: OptionalExpressionString,
+    lastName: OptionalExpressionString,
+    suffix: OptionalExpressionString
+  }).strict().describe("Person object with name component expressions")
+});
+var OrganizationExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("organization"),
+  value: z8.object({
+    name: ExpressionString,
+    legalName: OptionalExpressionString,
+    domicile: OptionalExpressionString,
+    entityType: OptionalExpressionString,
+    entityId: OptionalExpressionString,
+    taxId: OptionalExpressionString
+  }).strict().describe("Organization object with component expressions")
+});
+var IdentificationExpressionSchema = BaseExpressionSchema.extend({
+  type: z8.literal("identification"),
+  value: z8.object({
+    type: ExpressionString,
+    number: ExpressionString,
+    issuer: OptionalExpressionString,
+    issueDate: OptionalExpressionString,
+    expiryDate: OptionalExpressionString
+  }).strict().describe("Identification object with type, number, and optional issuer/date expressions")
+});
+var SCALAR_EXPRESSION_SCHEMAS = [
+  BooleanExpressionSchema,
+  StringExpressionSchema,
+  NumberExpressionSchema,
+  IntegerExpressionSchema,
+  PercentageExpressionSchema,
+  RatingExpressionSchema,
+  DateExpressionSchema,
+  TimeExpressionSchema,
+  DatetimeExpressionSchema,
+  DurationExpressionSchema
+];
+var OBJECT_EXPRESSION_SCHEMAS = [
+  MoneyExpressionSchema,
+  AddressExpressionSchema,
+  PhoneExpressionSchema,
+  CoordinateExpressionSchema,
+  BboxExpressionSchema,
+  PersonExpressionSchema,
+  OrganizationExpressionSchema,
+  IdentificationExpressionSchema
+];
+var ExpressionSchema = z8.discriminatedUnion("type", [
+  ...SCALAR_EXPRESSION_SCHEMAS,
+  ...OBJECT_EXPRESSION_SCHEMAS
+]).meta({
+  title: "Expression",
+  description: "A typed computed value with optional metadata (label, description). The type property determines the expected result type and value schema."
+});
+var SCALAR_EXPRESSION_TYPES = SCALAR_EXPRESSION_SCHEMAS.map((schema) => schema.shape.type.value);
+var OBJECT_EXPRESSION_TYPES = OBJECT_EXPRESSION_SCHEMAS.map((schema) => schema.shape.type.value);
+var ALL_EXPRESSION_TYPES = [...SCALAR_EXPRESSION_TYPES, ...OBJECT_EXPRESSION_TYPES];
+
+// src/zod/artifacts/expressions/defs-section.ts
+var DefsSectionSchema = z9.record(
+  z9.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Definition identifier (camelCase, starts with lowercase letter)"),
+  ExpressionSchema
+).meta({
+  title: "DefsSection",
+  description: "Named computed values with type information that can be referenced in conditional expressions"
+});
+
+// src/zod/artifacts/rules/rules-section.ts
+import { z as z11 } from "zod";
+
+// src/zod/artifacts/rules/validation-rule.ts
+import { z as z10 } from "zod";
+var RuleSeveritySchema = z10.enum(["error", "warning"]).describe("Severity level: error blocks submission, warning allows but warns");
+var ValidationRuleSchema = z10.object({
+  expr: z10.string().min(1).max(2e3).describe('Boolean expression that must evaluate to true for the form to be valid. Has access to field values directly (e.g., "ssn or ein") and defs section values.'),
+  message: z10.string().min(1).max(500).describe("Error message displayed when the rule fails (expression evaluates to false)"),
+  severity: RuleSeveritySchema.describe("Severity level: error (default) blocks submission, warning allows but warns").optional()
+}).strict().meta({
+  title: "ValidationRule",
+  description: "A form-level validation rule with a boolean expression and error message"
+});
+
+// src/zod/artifacts/rules/rules-section.ts
+var RulesSectionSchema = z11.record(
+  z11.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Validation rule identifier (camelCase, starts with lowercase letter)"),
+  ValidationRuleSchema
+).meta({
+  title: "RulesSection",
+  description: "Form-level validation rules keyed by rule identifier. Rules use expressions to validate cross-field constraints."
+});
+
+// src/zod/artifacts/form/field.ts
+import { z as z24 } from "zod";
+
+// src/zod/artifacts/form/base-field.ts
+import { z as z13 } from "zod";
+
+// src/zod/artifacts/expressions/cond-expr.ts
+import { z as z12 } from "zod";
+var CondExprSchema = z12.union([
+  z12.boolean().describe("Literal boolean value"),
+  z12.string().min(1).max(2e3).describe("Expression string - either inline expression or reference to a defs key")
+]).meta({
+  title: "CondExpr",
+  description: "Conditional expression: boolean literal or expression string"
+});
+
+// src/zod/artifacts/form/base-field.ts
+var BaseFieldSchema = z13.object({
+  label: z13.string().min(1).max(200).describe("Display label for the field").optional(),
+  description: z13.string().min(1).max(1e3).describe("Description or help text for the field").optional(),
+  required: CondExprSchema.optional(),
+  visible: CondExprSchema.optional()
+}).strict();
+
+// src/zod/primitives/coordinate.ts
+import { z as z14 } from "zod";
+var CoordinateSchema = z14.object({
+  lat: z14.number().min(-90).max(90).describe("Latitude in decimal degrees (WGS84), range -90 (South Pole) to 90 (North Pole)"),
+  lon: z14.number().min(-180).max(180).describe("Longitude in decimal degrees (WGS84), range -180 (west) to 180 (east)")
+}).strict().meta({
+  title: "Coordinate",
+  description: "Geographic coordinate (WGS84) with latitude and longitude in decimal degrees"
+});
+
+// src/zod/primitives/bbox.ts
+import { z as z15 } from "zod";
+var BboxSchema = z15.object({
+  southWest: CoordinateSchema.describe("Southwest corner coordinate (minimum latitude and longitude)"),
+  northEast: CoordinateSchema.describe("Northeast corner coordinate (maximum latitude and longitude)")
+}).strict().meta({
+  title: "Bbox",
+  description: "Geographic bounding box defined by southwest (minimum) and northeast (maximum) corner coordinates"
+});
+
+// src/zod/primitives/money.ts
+import { z as z16 } from "zod";
+var CurrencyCodeSchema = z16.string().min(3).max(3).regex(/^[A-Z]{3}$/);
+var MoneySchema = z16.object({
+  amount: z16.number().describe("Monetary amount expressed in decimal form (e.g., 99.99 for USD). Negative values allowed for debts/credits"),
+  currency: CurrencyCodeSchema.describe("ISO 4217 alpha-3 currency code (e.g., USD, EUR, GBP)")
+}).strict().meta({
+  title: "Money",
+  description: "Monetary value with currency code. Represents an amount in a specific currency, supporting both positive and negative values"
+});
+
+// src/zod/primitives/address.ts
+import { z as z17 } from "zod";
+var AddressSchema = z17.object({
+  line1: z17.string().min(1).max(200).describe("Primary address line"),
+  line2: z17.string().max(200).describe("Secondary address line").optional(),
+  locality: z17.string().min(1).max(200).describe("City or locality name"),
+  region: z17.string().min(1).max(100).describe("State, province, or region name"),
+  postalCode: z17.string().min(3).max(20).regex(/^[A-Z0-9\s-]+$/).describe("Postal or ZIP code"),
+  country: z17.string().min(2).max(100).describe('ISO 3166-1 country code (e.g., "US", "GB", "FRA") or full country name')
+}).strict().meta({
+  title: "Address",
+  description: "Physical address with street, locality, region, postal code, and country"
+});
+
+// src/zod/primitives/phone.ts
+import { z as z18 } from "zod";
+var PhoneSchema = z18.object({
+  number: z18.string().min(8).max(16).regex(/^\+[1-9]\d{1,14}$/).describe("Phone number in E.164 international format (e.g., +14155552671)"),
+  type: z18.string().min(1).max(50).describe("Type or category of phone number (e.g., mobile, work, home)").optional(),
+  extension: z18.string().min(1).max(20).describe("Phone extension or extension number").optional()
+}).strict().meta({
+  title: "Phone",
+  description: "Phone number in E.164 international format with optional type and extension"
+});
+
+// src/zod/primitives/duration.ts
+import { z as z19 } from "zod";
+var ISO_8601_DURATION_PATTERN = String.raw`^P(?=\d|T\d)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(?:T(?=\d)(\d+H)?(\d+M)?(\d+(?:\.\d+)?S)?)?$`;
+var ISO_8601_DURATION_REGEX = new RegExp(ISO_8601_DURATION_PATTERN);
+var DurationSchema = z19.string().regex(ISO_8601_DURATION_REGEX).meta({
+  title: "Duration",
+  description: "ISO 8601 duration string representing a time period. Format: P[n]Y[n]M[n]W[n]DT[n]H[n]M[n]S where P indicates period, T separates date and time components. Examples: P1Y (1 year), P3M (3 months), P2W (2 weeks), P1DT12H (1 day 12 hours), PT30M (30 minutes), PT5S (5 seconds)"
+});
+
+// src/zod/primitives/person.ts
+import { z as z20 } from "zod";
+var PersonSchema = z20.object({
+  name: z20.string().min(1).max(200).describe("Person's full name (complete name as a single string)"),
+  title: z20.string().min(1).max(50).describe("Name prefix or title (e.g., Mr., Mrs., Dr., Prof.)").optional(),
+  firstName: z20.string().min(1).max(100).describe("Person's first or given name").optional(),
+  middleName: z20.string().min(1).max(100).describe("Person's middle name or initial").optional(),
+  lastName: z20.string().min(1).max(100).describe("Person's last name or surname").optional(),
+  suffix: z20.string().min(1).max(50).describe("Name suffix (e.g., Jr., Sr., III, Esq.)").optional()
+}).strict().meta({
+  title: "Person",
+  description: "Person with name (required) and optional name components (title, first name, middle name, last name, suffix)"
+});
+
+// src/zod/primitives/organization.ts
+import { z as z21 } from "zod";
+var OrganizationSchema = z21.object({
+  name: z21.string().min(1).max(200).describe("Organization name"),
+  legalName: z21.string().min(1).max(200).describe("Legal or registered name of the organization").optional(),
+  domicile: z21.string().min(1).max(100).describe("Domicile").optional(),
+  entityType: z21.string().min(1).max(100).describe("Legal entity type of the organization").optional(),
+  entityId: z21.string().min(1).max(100).describe("Business identification number").optional(),
+  taxId: z21.string().min(1).max(100).describe("Tax identification number").optional()
+}).strict().meta({
+  title: "Organization",
+  description: "Organization with legal details and identification"
+});
+
+// src/zod/primitives/identification.ts
+import { z as z22 } from "zod";
+var IdentificationSchema = z22.object({
+  type: z22.string().min(1).max(50).describe("Type of identification document (e.g., ssn, passport, license, ein)"),
+  number: z22.string().min(1).max(100).describe("Identification number or identifier"),
+  issuer: z22.string().min(1).max(100).describe("Issuing authority, country, or state (e.g., US, CA, DMV)").optional(),
+  issueDate: z22.iso.date().describe("Issue date in ISO 8601 format (YYYY-MM-DD)").optional(),
+  expiryDate: z22.iso.date().describe("Expiry date in ISO 8601 format (YYYY-MM-DD)").optional()
+}).strict().meta({
+  title: "Identification",
+  description: "Identification document with type, number, issuer, and optional issue and expiry dates"
+});
+
+// src/zod/artifacts/form/pattern.ts
+import { z as z23 } from "zod";
+import safeRegex from "safe-regex";
+var MAX_PATTERN_LENGTH = 500;
+function findPatternProblem(pattern) {
+  if (pattern.length > MAX_PATTERN_LENGTH) return "too_long";
+  try {
+    new RegExp(pattern);
+  } catch {
+    return "invalid";
+  }
+  if (!safeRegex(pattern)) return "redos";
+  return void 0;
+}
+var PATTERN_PROBLEM_PHRASES = {
+  too_long: `exceeds the maximum length of ${MAX_PATTERN_LENGTH} characters`,
+  invalid: "has invalid regular expression syntax",
+  redos: "is potentially unsafe (ReDoS vulnerability detected)"
+};
+function describePatternProblem(problem, subject = "Pattern") {
+  return `${subject} ${PATTERN_PROBLEM_PHRASES[problem]}`;
+}
+var FieldPatternSchema = z23.string().min(1).max(MAX_PATTERN_LENGTH).superRefine((pattern, ctx) => {
+  const problem = findPatternProblem(pattern);
+  if (problem) ctx.addIssue({ code: "custom", message: describePatternProblem(problem) });
+}).describe("Regular expression pattern for validation");
+
+// src/zod/artifacts/form/ordered-bounds.ts
+function getOrderedBoundsIssue(min, max, minField, maxField, isOrdered) {
+  if (min === void 0 || max === void 0 || isOrdered(min, max)) {
+    return void 0;
+  }
+  return {
+    path: [maxField],
+    message: `${maxField} must be greater than or equal to ${minField}`
+  };
+}
+function compareTemporalBounds(min, max) {
+  const minTime = Date.parse(min);
+  const maxTime = Date.parse(max);
+  if (Number.isFinite(minTime) && Number.isFinite(maxTime)) {
+    return minTime <= maxTime;
+  }
+  return min <= max;
+}
+function parseClockTimeSeconds(value) {
+  const match = /^(\d{2}):(\d{2})(?::(\d{2}(?:\.\d+)?))?$/.exec(value);
+  if (!match) return void 0;
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  const seconds = match[3] !== void 0 ? Number(match[3]) : 0;
+  if (![hours, minutes, seconds].every(Number.isFinite)) return void 0;
+  return hours * 3600 + minutes * 60 + seconds;
+}
+function compareClockTimeBounds(min, max) {
+  const minSeconds = parseClockTimeSeconds(min);
+  const maxSeconds = parseClockTimeSeconds(max);
+  if (minSeconds !== void 0 && maxSeconds !== void 0) {
+    return minSeconds <= maxSeconds;
+  }
+  return min <= max;
+}
+
+// src/zod/artifacts/form/field.ts
+var EnumOptionValueSchema = z24.union([z24.string(), z24.number()]);
+var EnumOptionSchema = z24.object({
+  value: EnumOptionValueSchema.describe("Internal option value"),
+  label: z24.string().min(1).max(200).describe("Human-readable label for the option in the artifact source language").optional()
+}).strict();
+var CountSchema = z24.number().int().min(0);
+var EnumOptionsSchema = z24.array(EnumOptionSchema).min(1).superRefine((options, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  options.forEach((option, index) => {
+    if (seen.has(option.value)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "value"],
+        message: `Duplicate option value ${JSON.stringify(option.value)}`
+      });
+    }
+    seen.add(option.value);
+  });
+});
+var TextFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("text"),
+  minLength: CountSchema.describe("Minimum length").optional(),
+  maxLength: CountSchema.describe("Maximum length").optional(),
+  pattern: FieldPatternSchema.optional(),
+  default: z24.string().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(
+    field.minLength,
+    field.maxLength,
+    "minLength",
+    "maxLength",
+    (min, max) => min <= max
+  );
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var BooleanFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("boolean"),
+  default: z24.boolean().describe("Default value").optional()
+});
+var NumberFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("number"),
+  min: z24.number().describe("Minimum value").optional(),
+  max: z24.number().describe("Maximum value").optional(),
+  step: z24.number().positive().describe("Allowed increment: a value must be a multiple of step (e.g., 0.01 for cents)").optional(),
+  default: z24.number().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", (min, max) => min <= max);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var CoordinateFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("coordinate"),
+  default: CoordinateSchema.optional()
+});
+var BboxFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("bbox"),
+  default: BboxSchema.optional()
+});
+var MoneyFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("money"),
+  min: z24.number().describe("Minimum amount").optional(),
+  max: z24.number().describe("Maximum amount").optional(),
+  currency: CurrencyCodeSchema.describe("ISO 4217 alpha-3 currency code a value must use (e.g., USD). Omit to accept any currency").optional(),
+  default: MoneySchema.optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", (min, max) => min <= max);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var AddressFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("address"),
+  default: AddressSchema.optional()
+});
+var PhoneFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("phone"),
+  default: PhoneSchema.optional()
+});
+var DurationFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("duration"),
+  default: DurationSchema.optional()
+});
+var EmailFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("email"),
+  minLength: CountSchema.describe("Minimum length").optional(),
+  maxLength: CountSchema.describe("Maximum length").optional(),
+  default: z24.string().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(
+    field.minLength,
+    field.maxLength,
+    "minLength",
+    "maxLength",
+    (min, max) => min <= max
+  );
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var UuidFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("uuid"),
+  minLength: CountSchema.describe("Minimum length").optional(),
+  maxLength: CountSchema.describe("Maximum length").optional(),
+  pattern: FieldPatternSchema.optional(),
+  default: z24.string().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(
+    field.minLength,
+    field.maxLength,
+    "minLength",
+    "maxLength",
+    (min, max) => min <= max
+  );
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var UriFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("uri"),
+  minLength: CountSchema.describe("Minimum length").optional(),
+  maxLength: CountSchema.describe("Maximum length").optional(),
+  pattern: FieldPatternSchema.optional(),
+  default: z24.string().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(
+    field.minLength,
+    field.maxLength,
+    "minLength",
+    "maxLength",
+    (min, max) => min <= max
+  );
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var EnumFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("enum"),
+  enum: EnumOptionsSchema.describe("Array of allowed options for the enum field"),
+  default: EnumOptionValueSchema.describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  if (field.default !== void 0 && !field.enum.some((option) => option.value === field.default)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["default"],
+      message: "Default value must match one of the enum option values"
+    });
+  }
+});
+var DateFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("date"),
+  min: z24.iso.date().describe("Minimum date (ISO 8601: YYYY-MM-DD)").optional(),
+  max: z24.iso.date().describe("Maximum date (ISO 8601: YYYY-MM-DD)").optional(),
+  default: z24.iso.date().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", compareTemporalBounds);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var DatetimeValueSchema = z24.iso.datetime({ offset: true }).regex(
+  /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/
+);
+var DatetimeFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("datetime"),
+  min: DatetimeValueSchema.describe("Minimum datetime (ISO 8601 with Z or \xB1HH:MM timezone)").optional(),
+  max: DatetimeValueSchema.describe("Maximum datetime (ISO 8601 with Z or \xB1HH:MM timezone)").optional(),
+  default: DatetimeValueSchema.describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", compareTemporalBounds);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var TimeValueSchema = z24.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?$/);
+var TimeFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("time"),
+  min: TimeValueSchema.describe("Minimum time (HH:MM:SS[.fff])").optional(),
+  max: TimeValueSchema.describe("Maximum time (HH:MM:SS[.fff])").optional(),
+  default: TimeValueSchema.describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", compareClockTimeBounds);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var PersonFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("person"),
+  default: PersonSchema.optional()
+});
+var OrganizationFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("organization"),
+  default: OrganizationSchema.optional()
+});
+var IdentificationFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("identification"),
+  allowedTypes: z24.array(z24.string()).describe("Allowed ID types (e.g., passport, drivers_license)").optional(),
+  default: IdentificationSchema.optional()
+});
+var MultiselectFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("multiselect"),
+  enum: EnumOptionsSchema.describe("Available options"),
+  min: CountSchema.describe("Minimum selections required").optional(),
+  max: CountSchema.describe("Maximum selections allowed").optional(),
+  default: z24.array(EnumOptionValueSchema).describe("Default selected values").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", (min, max) => min <= max);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+  field.default?.forEach((value, index) => {
+    if (!field.enum.some((option) => option.value === value)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["default", index],
+        message: "Default value must match one of the multiselect option values"
+      });
+    }
+  });
+});
+var PercentageFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("percentage"),
+  min: z24.number().describe("Minimum value (default: 0)").optional(),
+  max: z24.number().describe("Maximum value (default: 100)").optional(),
+  precision: CountSchema.describe("Decimal places (default: 2)").optional(),
+  default: z24.number().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", (min, max) => min <= max);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var RatingFieldSchema = BaseFieldSchema.extend({
+  type: z24.literal("rating"),
+  min: z24.number().describe("Minimum value (default: 1)").optional(),
+  max: z24.number().describe("Maximum value (default: 5)").optional(),
+  step: z24.number().positive().describe("Increment step (e.g., 0.5 for half stars, default: 1)").optional(),
+  default: z24.number().describe("Default value").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(field.min, field.max, "min", "max", (min, max) => min <= max);
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+});
+var FieldsetFieldObjectSchema = BaseFieldSchema.extend({
+  type: z24.literal("fieldset"),
+  fields: z24.lazy(() => z24.record(
+    z24.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Nested field identifier (camelCase, starts with lowercase letter)"),
+    FormFieldSchema
+  ))
+}).meta({
+  id: "FieldsetField",
+  title: "FieldsetField",
+  description: "Field that groups nested fields under one key"
+});
+var FieldsetFieldSchema = FieldsetFieldObjectSchema;
+var ListFieldObjectSchema = BaseFieldSchema.extend({
+  type: z24.literal("list"),
+  item: z24.lazy(() => FormFieldSchema),
+  minItems: z24.number().int().min(0).describe("Minimum number of items").optional(),
+  maxItems: z24.number().int().min(0).describe("Maximum number of items").optional()
+}).superRefine((field, ctx) => {
+  const issue = getOrderedBoundsIssue(
+    field.minItems,
+    field.maxItems,
+    "minItems",
+    "maxItems",
+    (min, max) => min <= max
+  );
+  if (issue) ctx.addIssue({ code: "custom", ...issue });
+}).meta({
+  id: "ListField",
+  title: "ListField",
+  description: "Field that holds a list of items, each shaped by the item field"
+});
+var ListFieldSchema = ListFieldObjectSchema;
+var FIELD_SCHEMAS = [
+  TextFieldSchema,
+  BooleanFieldSchema,
+  NumberFieldSchema,
+  CoordinateFieldSchema,
+  BboxFieldSchema,
+  MoneyFieldSchema,
+  AddressFieldSchema,
+  PhoneFieldSchema,
+  DurationFieldSchema,
+  EmailFieldSchema,
+  UuidFieldSchema,
+  UriFieldSchema,
+  EnumFieldSchema,
+  DateFieldSchema,
+  DatetimeFieldSchema,
+  TimeFieldSchema,
+  PersonFieldSchema,
+  OrganizationFieldSchema,
+  IdentificationFieldSchema,
+  MultiselectFieldSchema,
+  PercentageFieldSchema,
+  RatingFieldSchema,
+  FieldsetFieldObjectSchema,
+  ListFieldObjectSchema
+];
+var FormFieldSchema = z24.lazy(() => z24.discriminatedUnion("type", FIELD_SCHEMAS)).meta({
+  title: "FormField",
+  description: "Single input/data element, nested fieldset, or recursive list"
+});
+var FORM_FIELD_TYPES = FIELD_SCHEMAS.map((schema) => schema.shape.type.value);
+
+// src/zod/artifacts/form/annex.ts
+import { z as z25 } from "zod";
+var FormAnnexSchema = z25.object({
+  title: z25.string().min(1).max(200).describe("Title or heading for the annex slot").optional(),
+  description: z25.string().min(1).max(1e3).describe("Description of what document should be attached").optional(),
+  required: CondExprSchema.optional(),
+  visible: CondExprSchema.optional(),
+  order: z25.number().min(0).describe("Display order for rendering").optional()
+}).strict().meta({
+  title: "FormAnnex",
+  description: "Defines an annex slot where a document must or may be attached at runtime"
+});
+
+// src/zod/artifacts/form/party.ts
+import { z as z29 } from "zod";
+
+// src/zod/primitives/attachment.ts
+import { z as z26 } from "zod";
+var AttachmentSchema = z26.object({
+  name: z26.string().min(1).max(255).describe("Original file name"),
+  mimeType: z26.string().min(1).max(100).describe("MIME type of the attached file"),
+  checksum: ChecksumSchema.optional()
+}).strict().meta({
+  title: "Attachment",
+  description: "Attachment data representing an attached document. The key in the record is the annex identifier (the key from form.annexes)."
+});
+
+// src/zod/primitives/runtime-party.ts
+import { z as z27 } from "zod";
+var PartyIdSchema = z27.string().min(1).describe("Identifier of this party in the fill, such as tenant-0");
+var RuntimePersonSchema = PersonSchema.extend({
+  id: PartyIdSchema
+});
+var RuntimeOrganizationSchema = OrganizationSchema.extend({
+  id: PartyIdSchema
+});
+
+// src/zod/primitives/signature.ts
+import { z as z28 } from "zod";
+var SignatureSchema = z28.object({
+  image: z28.string().min(1).describe("Base64-encoded signature image or data URI").optional(),
+  timestamp: z28.iso.datetime().describe("ISO 8601 date-time when the signature was captured"),
+  method: z28.union([
+    z28.literal("drawn"),
+    z28.literal("typed"),
+    z28.literal("uploaded"),
+    z28.literal("certificate")
+  ]).describe("Method used to capture the signature"),
+  type: z28.union([
+    z28.literal("signature"),
+    z28.literal("initials")
+  ]).default("signature").describe("Whether this is a full signature or initials").optional(),
+  metadata: z28.record(z28.string(), z28.unknown()).describe("Additional metadata (IP address, device info, etc.)").optional()
+}).strict().meta({
+  title: "Signature",
+  description: "Captured signature data containing the signature image, timestamp, capture method, and optional metadata."
+});
+
+// src/zod/primitives/registry-reference.ts
+var NAMESPACE_SOURCE = REGISTRY_NAMESPACE_PATTERN.source.slice(1, -1);
+var REGISTRY_ITEM_NAME_MAX_LENGTH = 128;
+var NAME_SOURCE = `(?=[a-z0-9-]{1,${REGISTRY_ITEM_NAME_MAX_LENGTH}}(?:[/@]|$))${SEGMENT_SOURCE}`;
+var REGISTRY_REFERENCE_PATTERN = new RegExp(
+  `^${NAMESPACE_SOURCE}/${NAME_SOURCE}(?:/(?:${EDITION_SOURCE}))?(?:@(?:${VERSION_SOURCE}))?$`
+);
+var REFERENCE_PARTS = new RegExp(
+  `^(?<namespace>${NAMESPACE_SOURCE})/(?<name>${NAME_SOURCE})(?:/(?<edition>${EDITION_SOURCE}))?(?:@(?<version>${VERSION_SOURCE}))?$`
+);
+function parseRegistryReference(value) {
+  const match = REFERENCE_PARTS.exec(value);
+  if (!match) return void 0;
+  const { namespace, name, edition, version } = match.groups;
+  return {
+    namespace,
+    name,
+    ...edition !== void 0 && edition !== CURRENT_EDITION && { edition },
+    ...version !== void 0 && version !== LATEST_VERSION && { version }
+  };
+}
+function formatRegistryReference(reference) {
+  const edition = reference.edition === void 0 ? "" : `/${reference.edition}`;
+  const version = reference.version === void 0 ? "" : `@${reference.version}`;
+  return `${reference.namespace}/${reference.name}${edition}${version}`;
+}
+
+// src/zod/artifacts/form/party.ts
+var FormSignatureSchema = z29.object({
+  required: z29.boolean().describe("Whether signature is required for this role (default: false)").optional(),
+  witnesses: z29.number().int().min(0).describe("Number of caller-declared witness attestations required for this signature (default: 0)").optional(),
+  notarized: z29.boolean().describe("Whether at least one caller-declared attesting witness must have notary status (default: false)").optional()
+}).strict().meta({
+  title: "FormSignature",
+  description: "Design-time signature requirements for a party role"
+});
+var FormPaymentSchema = z29.object({
+  required: z29.boolean().describe("Whether payment is required for this role (default: false)").optional(),
+  amount: z29.union([
+    MoneySchema,
+    MoneyExpressionSchema
+  ]).describe("Amount owed: a fixed Money value, or a MoneyExpression resolved from filled data at request time")
+}).strict().meta({
+  title: "FormPayment",
+  description: "Design-time payment requirement for a party role"
+});
+var FormPartySchema = z29.object({
+  label: z29.string().min(1).max(100).describe("Display name for this role"),
+  description: z29.string().max(500).describe("Description of this role").optional(),
+  partyType: z29.union([
+    z29.literal("person"),
+    z29.literal("organization"),
+    z29.literal("any")
+  ]).describe("Constraint on party type (default: any)").optional(),
+  min: z29.number().int().min(0).describe("Minimum parties required (default: 1)").optional(),
+  max: z29.number().int().min(1).describe("Maximum parties allowed (default: 1)").optional(),
+  required: CondExprSchema.optional(),
+  signature: FormSignatureSchema.optional(),
+  payment: FormPaymentSchema.optional()
+}).strict().superRefine((party, ctx) => {
+  const min = party.min ?? 1;
+  const max = party.max ?? 1;
+  if (min > max) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["max"],
+      message: "max must be greater than or equal to min"
+    });
+  }
+}).meta({
+  title: "FormParty",
+  description: "Design-time party role definition. Defines what roles exist and what constraints apply when filling a form."
+});
+
+// src/zod/artifacts/form/index.ts
+var FormSchema = ArtifactSchema.extend({
+  kind: z30.literal("form"),
+  defs: DefsSectionSchema.optional(),
+  rules: RulesSectionSchema.describe("Form-level validation rules for cross-field constraints. Rules use expressions with direct access to field values and defs section values.").optional(),
+  fields: z30.record(
+    z30.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Field identifier (camelCase, starts with lowercase letter)"),
+    FormFieldSchema
+  ).describe("Form field definitions keyed by field identifier. Fields define the input structure and validation rules for the form").optional(),
+  layers: z30.record(
+    z30.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Layer identifier (camelCase, starts with lowercase letter)"),
+    LayerSchema
+  ).describe("Named layers for rendering this form into different formats. Keys are user-defined identifiers (e.g., markdown, pdf, html)").optional(),
+  defaultLayer: z30.string().min(1).max(100).describe("Key of the default layer to use when none specified at render time").optional(),
+  allowAdditionalAnnexes: z30.boolean().describe("Whether additional ad-hoc annexes can be attached beyond those defined in the annexes record (default: false)").optional(),
+  annexes: z30.record(
+    z30.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Annex identifier (camelCase, starts with lowercase letter)"),
+    FormAnnexSchema
+  ).describe("Predefined annex slots keyed by identifier. Each slot can be marked as required (must be filled at runtime) or optional").optional(),
+  parties: z30.record(
+    z30.string().min(1).max(50).regex(IDENTIFIER_PATTERN).describe("Party role identifier (e.g., buyer, seller, landlord, buyerRepresentative)"),
+    FormPartySchema
+  ).describe("Party role definitions keyed by role identifier. Each role specifies constraints on who can fill it (person/organization) and signature requirements.").optional()
+}).strict().meta({
+  title: "Form",
+  description: "A form artifact that defines a data contract with field definitions, optional layers for rendering, and optional annexes. Forms are the primary artifact type for structured data collection and document generation."
+});
+
+// src/zod/artifacts/document/index.ts
+import { z as z31 } from "zod";
+var DocumentSchema = ArtifactSchema.extend({
+  kind: z31.literal("document"),
+  layers: withoutReactLayers(z31.record(
+    z31.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Layer identifier (camelCase, starts with lowercase letter)"),
+    LayerSchema
+  ).describe("Named layers for rendering this document into different formats. Keys are user-defined identifiers (e.g., markdown, pdf, html)")).optional(),
+  defaultLayer: z31.string().min(1).max(100).describe("Key of the default layer to use when none specified at render time").optional()
+}).strict().meta({
+  title: "Document",
+  description: "A document artifact representing static content with no inputs. Documents can have multiple layers for rendering to different output formats (e.g., PDF, Markdown, HTML)."
+});
+
+// src/zod/artifacts/bundle/item.ts
+import { z as z34 } from "zod";
+
+// src/zod/artifacts/checklist/index.ts
+import { z as z33 } from "zod";
+
+// src/zod/artifacts/shared/unique.ts
+function addDuplicateIdentityIssues(members, identityOf, options, addIssue) {
+  const firstIndexByIdentity = /* @__PURE__ */ new Map();
+  for (const [index, member] of members.entries()) {
+    const identity = identityOf(member);
+    const firstIndex = firstIndexByIdentity.get(identity);
+    if (firstIndex === void 0) {
+      firstIndexByIdentity.set(identity, index);
+      continue;
+    }
+    const firstPath = `${options.collection}.${firstIndex}.${options.property}`;
+    const message = `Duplicate ${options.label} "${identity}". First declared at ${firstPath}.`;
+    addIssue([firstIndex, options.property], message);
+    addIssue([index, options.property], message);
+  }
+}
+
+// src/zod/artifacts/checklist/item.ts
+import { z as z32 } from "zod";
+var BooleanStatusSpecSchema = z32.object({
+  kind: z32.literal("boolean"),
+  default: z32.boolean().describe("Default status value (true/false) for new instances").optional()
+}).strict().meta({
+  title: "BooleanStatusSpec",
+  description: "Boolean status (e.g., incomplete/complete) with an optional default value."
+});
+var EnumStatusOptionSchema = z32.object({
+  value: z32.string().min(1).max(64).describe('Internal status value (e.g., "todo", "in-progress", "done")'),
+  label: z32.string().min(1).max(256).describe("Human-readable label for the status option"),
+  description: z32.string().min(1).max(2e3).describe("Optional description or help text for this status option").optional()
+}).strict().meta({
+  title: "EnumStatusOption"
+});
+var EnumStatusSpecSchema = z32.object({
+  kind: z32.literal("enum"),
+  options: z32.array(EnumStatusOptionSchema).min(1).describe("Allowed status options"),
+  default: z32.string().min(1).max(64).describe("Default status value for new instances (must match one of the option values)").optional()
+}).strict().meta({
+  title: "EnumStatusSpec",
+  description: "Enum-based status with a set of allowed options and an optional default."
+}).superRefine((status, ctx) => {
+  if (status.default !== void 0 && !status.options.some((option) => option.value === status.default)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["default"],
+      message: "Default status value must match one of the option values"
+    });
+  }
+});
+var StatusSpecSchema = z32.discriminatedUnion("kind", [
+  BooleanStatusSpecSchema,
+  EnumStatusSpecSchema
+]).meta({
+  title: "StatusSpec",
+  description: "Specification for how checklist item status should be represented (boolean or enum)."
+});
+var ChecklistItemSchema = z32.object({
+  id: z32.string().min(1).max(128).describe('Unique identifier for the checklist item (e.g., "task-1", "step-a"). Used to link to runtime status.'),
+  title: z32.string().min(1).max(500).describe("Title or label for the checklist item"),
+  description: z32.string().min(1).max(2e3).describe("Detailed description or instructions for the item").optional(),
+  status: StatusSpecSchema.optional()
+}).strict().meta({
+  title: "ChecklistItem",
+  description: "A single item in a checklist artifact. Each item has an ID, title, optional description, and an optional status specification (boolean or enum). If status is omitted, a default boolean status may be assumed (implementation-defined)."
+});
+
+// src/zod/artifacts/checklist/index.ts
+var ChecklistSchema = ArtifactSchema.extend({
+  kind: z33.literal("checklist"),
+  items: z33.array(ChecklistItemSchema).superRefine((items, ctx) => {
+    addDuplicateIdentityIssues(
+      items,
+      (item) => item.id,
+      { collection: "items", property: "id", label: "checklist item ID" },
+      (path, message) => ctx.addIssue({ code: "custom", path, message })
+    );
+  }).describe("Array of checklist items. Each item represents a task, step, or requirement."),
+  layers: withoutReactLayers(z33.record(
+    z33.string().min(1).max(100).regex(IDENTIFIER_PATTERN).describe("Layer identifier (camelCase, starts with lowercase letter)"),
+    LayerSchema
+  ).describe("Named layers for rendering this checklist into different formats. Keys are user-defined identifiers (e.g., markdown, pdf, html)")).optional(),
+  defaultLayer: z33.string().min(1).max(100).describe("Key of the default layer to use when none specified at render time").optional()
+}).strict().meta({
+  title: "Checklist",
+  description: "A checklist artifact containing an ordered list of items to track. Each item may define how its status should be represented at runtime (boolean or enum)."
+});
+
+// src/zod/artifacts/bundle/item.ts
+var ContentItemBaseSchema = z34.object({
+  key: z34.string().min(1).max(100).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/).describe("Unique identifier for this content item, used to reference it in defs expressions"),
+  include: CondExprSchema.optional()
+});
+var InlineContentItemSchema = ContentItemBaseSchema.extend({
+  type: z34.literal("inline"),
+  artifact: z34.lazy(() => z34.union([
+    DocumentSchema,
+    FormSchema,
+    ChecklistSchema,
+    BundleSchema
+  ])).describe("Inline artifact definition (document, form, checklist, or nested bundle)")
+}).strict();
+var PathContentItemSchema = ContentItemBaseSchema.extend({
+  type: z34.literal("path"),
+  path: z34.string().min(1).describe("Path to the artifact file, relative to the bundle file's directory")
+}).strict();
+var RegistryContentItemSchema = ContentItemBaseSchema.extend({
+  type: z34.literal("registry"),
+  slug: z34.string().regex(ARTIFACT_ADDRESS_PATTERN, "Expected an artifact address such as @org/repo/name, with no edition or version").describe("Artifact address @org/repo/name, with no edition or version"),
+  edition: EditionKeySchema.describe("Edition key. When omitted, the registry's current edition is used.").optional(),
+  version: z34.string().regex(ARTIFACT_VERSION_PATTERN, "Expected an exact SemVer version such as 1.2.0").describe("Exact version. When omitted, the latest version of the edition is used.").optional()
+}).strict();
+var BundleObjectSchema = ArtifactSchema.extend({
+  kind: z34.literal("bundle"),
+  defs: DefsSectionSchema.optional(),
+  contents: z34.array(z34.lazy(() => BundleContentItemSchema)).superRefine((contents, ctx) => {
+    addDuplicateIdentityIssues(
+      contents,
+      (content) => content.key,
+      { collection: "contents", property: "key", label: "bundle content key" },
+      (path, message) => ctx.addIssue({ code: "custom", path, message })
+    );
+  }).describe("Ordered bundle contents. Each item has a key and is either an inline artifact, path reference, or registry reference.")
+}).strict().meta({
+  title: "Bundle",
+  description: "A bundle artifact that groups together related artifacts into a single distributable unit. Bundles can contain documents, forms, checklists, and other bundles."
+});
+var BundleSchema = BundleObjectSchema;
+var BundleContentItemSchema = z34.discriminatedUnion("type", [
+  InlineContentItemSchema,
+  PathContentItemSchema,
+  RegistryContentItemSchema
+]).meta({
+  title: "BundleContentItem",
+  description: "Bundle content item: an inline artifact, path reference, or registry reference with optional include condition"
+});
+
+// src/zod/module.ts
+var AsterdocRegistry = z35.globalRegistry;
+function register(schema, id) {
+  AsterdocRegistry.add(schema, { ...schema.meta(), id });
+}
+register(FormSchema, "Form");
+register(DocumentSchema, "Document");
+register(BundleSchema, "Bundle");
+register(ChecklistSchema, "Checklist");
+register(BundleContentItemSchema, "BundleContentItem");
+register(ChecklistItemSchema, "ChecklistItem");
+register(FormFieldSchema, "FormField");
+register(FormAnnexSchema, "FormAnnex");
+register(FormPartySchema, "FormParty");
+register(LayerSchema, "Layer");
+register(AddressSchema, "Address");
+register(AttachmentSchema, "Attachment");
+register(BboxSchema, "Bbox");
+register(CoordinateSchema, "Coordinate");
+register(DurationSchema, "Duration");
+register(IdentificationSchema, "Identification");
+register(MoneySchema, "Money");
+register(MetadataSchema, "Metadata");
+register(OrganizationSchema, "Organization");
+register(PersonSchema, "Person");
+register(PhoneSchema, "Phone");
+register(SignatureSchema, "Signature");
+register(CondExprSchema, "CondExpr");
+register(DefsSectionSchema, "DefsSection");
+var AsterdocSchema = z35.union([
+  FormSchema,
+  DocumentSchema,
+  ChecklistSchema,
+  BundleSchema
+]).meta({
+  title: "Asterdoc",
+  description: "Root schema for any Asterdoc artifact document"
+});
+register(AsterdocSchema, "Asterdoc");
+
+// src/zod/registry/registry-entry.ts
+import { z as z36 } from "zod";
+var RegistryCacheConfigSchema = z36.strictObject({
+  ttl: z36.number().int().min(0).describe("Cache TTL in seconds. 0 disables caching for this registry.").optional()
+}).meta({
+  title: "RegistryCacheConfig",
+  description: "Per-registry cache configuration"
+});
+var RegistryEntryObjectSchema = z36.strictObject({
+  url: z36.url().describe("Registry base URL"),
+  headers: z36.record(z36.string(), z36.string()).describe("HTTP headers for authentication (supports ${ENV_VAR} expansion)").optional(),
+  cache: RegistryCacheConfigSchema.describe("Per-registry cache settings").optional()
+}).meta({
+  title: "RegistryEntryObject",
+  description: "Registry configuration with authentication options"
+});
+var RegistryEntrySchema = z36.union([
+  z36.url().describe("Simple registry URL"),
+  RegistryEntryObjectSchema
+]).meta({
+  title: "RegistryEntry",
+  description: "Registry configuration - URL string or object with authentication"
+});
+var ArtifactOutputFormatSchema = z36.union([
+  z36.literal("json"),
+  z36.literal("yaml"),
+  z36.literal("typed"),
+  z36.literal("ts")
+]).meta({
+  title: "ArtifactOutputFormat",
+  description: "Output format for installed artifacts"
+});
+
+// src/zod/registry/global-config.ts
+import { z as z37 } from "zod";
+var CacheConfigSchema = z37.strictObject({
+  ttl: z37.number().int().min(0).default(3600).describe("Default cache TTL in seconds. 0 disables caching. Default: 3600 (1 hour)").optional(),
+  directory: z37.string().describe("Custom cache directory. A leading ~ uses the home directory; relative paths use the config file directory. Default: ~/.asterdoc/cache").optional()
+}).meta({
+  title: "CacheConfig",
+  description: "Cache configuration for registry data"
+});
+var GlobalDefaultsSchema = z37.strictObject({
+  output: ArtifactOutputFormatSchema.default("json").describe("Default output format for artifacts: json, yaml, typed (json + .d.ts), or ts (TypeScript module)").optional(),
+  artifactsDir: z37.string().default("artifacts").describe("Default directory for installed artifacts").optional()
+}).meta({
+  title: "GlobalDefaults",
+  description: "Default settings for CLI operations"
+});
+var TelemetryConfigSchema = z37.strictObject({
+  enabled: z37.boolean().describe("Send anonymous CLI usage telemetry. Set to false to opt out. Default: true").optional()
+}).meta({
+  title: "TelemetryConfig",
+  description: "Telemetry preferences for the CLI"
+});
+var SecurityConfigSchema = z37.strictObject({
+  allowedContentTypes: z37.array(z37.string()).describe("Content types permitted for layer downloads, added to the built-in defaults. Blocked types are never allowed.").optional()
+}).meta({
+  title: "SecurityConfig",
+  description: "Security settings for layer downloads"
+});
+var GlobalConfigSchema = z37.object({
+  $schema: z37.url().describe("JSON Schema URI for validation").optional(),
+  registries: z37.record(
+    z37.string().regex(REGISTRY_NAMESPACE_PATTERN).describe("Registry namespace (must start with @)"),
+    RegistryEntrySchema
+  ).describe("Configured registries by namespace").optional(),
+  defaults: GlobalDefaultsSchema.optional(),
+  cache: CacheConfigSchema.describe("Global cache configuration for registry data").optional(),
+  security: SecurityConfigSchema.describe("Security settings for layer downloads").optional(),
+  telemetry: TelemetryConfigSchema.describe("Telemetry preferences").optional(),
+  anonymousId: z37.uuid().describe("Anonymous telemetry identifier. The CLI generates it once and keeps it across resets.").optional()
+}).strict().meta({
+  title: "Asterdoc Global Config",
+  description: "Schema for ~/.asterdoc/config.json global configuration file"
+});
+
+// src/zod/registry/lock.ts
+import { z as z38 } from "zod";
+var LockIntegritySchema = z38.string().regex(/^sha256-[A-Za-z0-9+/]{43}=$/);
+var LockedLayerSchema = z38.object({
+  integrity: LockIntegritySchema.describe("SHA-256 integrity of the layer file (sha256-<base64>)"),
+  path: z38.string().describe("Relative path to the layer file from project root")
+}).meta({
+  title: "LockedLayer",
+  description: "Information about an installed layer file"
+});
+var LockedArtifactSchema = z38.object({
+  kind: z38.enum(["form", "document", "checklist", "bundle"]).describe("Artifact kind"),
+  edition: EditionKeySchema.describe("Key of the installed edition, as the registry manifest lists it. Omitted for an artifact that has no editions.").optional(),
+  version: z38.string().describe("Installed artifact version"),
+  resolved: z38.url().describe("Full URL used to fetch the artifact"),
+  integrity: LockIntegritySchema.describe("SHA-256 integrity of the artifact file as written (sha256-<base64>)"),
+  installedAt: z38.iso.datetime().describe("ISO 8601 timestamp when artifact was installed"),
+  output: ArtifactOutputFormatSchema.describe("Output format the artifact was written in"),
+  path: z38.string().describe("Relative path to the artifact file from project root"),
+  layers: z38.record(
+    z38.string().describe("Layer key"),
+    LockedLayerSchema
+  ).describe("Installed layers and their metadata")
+}).meta({
+  title: "LockedArtifact",
+  description: "Information about an installed artifact"
+});
+var LockFileSchema = z38.object({
+  $schema: z38.url().describe("JSON Schema URI for validation").optional(),
+  version: z38.number().default(1).describe("Lock file format version"),
+  artifacts: z38.record(
+    z38.string().regex(ARTIFACT_REFERENCE_PATTERN).describe("Artifact reference (@namespace/name)"),
+    LockedArtifactSchema
+  ).describe("Installed artifacts by reference")
+}).strict().meta({
+  title: "Asterdoc Lock File",
+  description: "Schema for .asterdoc/lock.json lock file"
+});
+
+// src/zod/registry/registry-index.ts
+import { z as z39 } from "zod";
+var RegistryItemNameSchema = z39.string().min(1).max(REGISTRY_ITEM_NAME_MAX_LENGTH).regex(
+  COORDINATE_SEGMENT_PATTERN,
+  "Expected an artifact name: lowercase letters and digits with single hyphens, such as w-9"
+);
+var RegistryVersionKeySchema = z39.string().max(200).regex(
+  REGISTRY_VERSION_PATTERN,
+  "Expected a SemVer version with no build metadata, such as 1.2.0 or 1.3.0-beta.1"
+);
+var REGISTRY_ARTIFACT_PATH_MAX_LENGTH = 500;
+var REGISTRY_ARTIFACT_PATH_PATTERN = /^(?:(?!\.{1,2}\/)[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+\.(?:json|yaml|yml)$/;
+var RegistryVersionEntrySchema = z39.strictObject({
+  path: z39.string().max(REGISTRY_ARTIFACT_PATH_MAX_LENGTH).regex(
+    REGISTRY_ARTIFACT_PATH_PATTERN,
+    "Expected a path relative to the registry base address, such as w-9/2024-03/1.0.0/w-9.json: forward slashes, no leading slash, no . or .. segment, ending in .json, .yaml or .yml"
+  ).describe("Path to the artifact file, relative to the registry base address (the address of the folder that holds registry.json), such as w-9/2024-03/1.0.0/w-9.json. Forward slashes only, no leading slash, no . or .. segment, ending in .json, .yaml or .yml. No two versions in one manifest have the same path."),
+  sha256: z39.string().regex(/^[a-f0-9]{64}$/, "Expected a SHA-256 digest as 64 lowercase hex digits").describe("SHA-256 digest of the bytes of the artifact file at path, as 64 lowercase hex digits. A reader refuses a file whose digest is different.")
+}).meta({
+  title: "RegistryVersionEntry",
+  description: "One version of an artifact in a registry: the path of its file and the checksum of that file. The version itself is the key of this entry."
+});
+var REGISTRY_VERSIONS_EMPTY_RULE = "Expected at least one version";
+var REGISTRY_EDITIONS_EMPTY_RULE = "Expected at least one edition";
+var isNotEmpty = (value) => Object.keys(value).length > 0;
+var isOwnKey = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var listKeys = (value) => Object.keys(value).join(", ");
+var namesEntry = (entries, key) => !isNotEmpty(entries) || isOwnKey(entries, key);
+var keyRuleError = (issue) => issue.code === "invalid_key" ? `${issue.issues?.[0]?.message ?? "Invalid key"}; got "${String(issue.input)}"` : void 0;
+var RegistryVersionsSchema = z39.record(RegistryVersionKeySchema, RegistryVersionEntrySchema, { error: keyRuleError }).refine(isNotEmpty, REGISTRY_VERSIONS_EMPTY_RULE).meta({
+  title: "RegistryVersions",
+  description: "Versions keyed by version. Each key is a SemVer 2.0.0 version with no build metadata, such as 1.2.0 or 1.3.0-beta.1, and never latest or current. At least one version. The order of the keys has no meaning.",
+  minProperties: 1
+});
+var LATEST_VERSION_DESCRIPTION = "The version to use when a request names none. It is the publisher's statement and must be a key of versions. It is normally the highest stable version; a pre-release is the default only when the publisher points at it. A reader uses this value and never compares version numbers.";
+var RegistryEditionEntrySchema = z39.strictObject({
+  ...editionFactsShape,
+  latestVersion: RegistryVersionKeySchema.describe(LATEST_VERSION_DESCRIPTION),
+  versions: RegistryVersionsSchema
+}).superRefine((edition, ctx) => {
+  if (!namesEntry(edition.versions, edition.latestVersion)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["latestVersion"],
+      message: `latestVersion "${edition.latestVersion}" is not a key of versions (${listKeys(edition.versions)})`
+    });
+  }
+}).meta({
+  title: "RegistryEditionEntry",
+  description: "One edition of an issued artifact, as printed by its issuer, and the publisher's versions of it. The edition key is the key of this entry."
+});
+var RegistryEditionsSchema = z39.record(EditionKeySchema, RegistryEditionEntrySchema, { error: keyRuleError }).refine(isNotEmpty, REGISTRY_EDITIONS_EMPTY_RULE).meta({
+  title: "RegistryEditions",
+  description: "Editions keyed by edition key. Each key is lowercase letters and digits with single hyphens, such as 2024-03 or 3b, and never current, latest, editions, tags or diff. At least one edition. The order of the keys has no meaning.",
+  minProperties: 1
+});
+var REGISTRY_ITEM_RELEASES_RULE = "Expected either currentEdition with editions (an artifact that has editions), or latestVersion with versions (an artifact that has none)";
+var REGISTRY_ITEM_EDITIONS_ONLY_RULE = "An artifact that has editions states latestVersion and versions inside each edition, never on the item";
+var editionsOrVersionsJsonSchema = [
+  {
+    required: ["currentEdition", "editions"],
+    not: { anyOf: [{ required: ["latestVersion"] }, { required: ["versions"] }] }
+  },
+  {
+    required: ["latestVersion", "versions"],
+    not: { anyOf: [{ required: ["currentEdition"] }, { required: ["editions"] }] }
+  }
+];
+var RegistryItemObjectSchema = z39.strictObject({
+  name: RegistryItemNameSchema.describe("Artifact name, unique within the registry. Lowercase letters and digits with single hyphens. It is the name segment of a reference such as @acme/w-9, and every edition and version of the artifact shares it."),
+  kind: z39.union([
+    z39.literal("form"),
+    z39.literal("document"),
+    z39.literal("checklist"),
+    z39.literal("bundle")
+  ]).describe("Artifact kind"),
+  title: z39.string().min(1).max(200).describe("Human-readable title").optional(),
+  description: z39.string().max(2e3).describe("Brief description of the artifact").optional(),
+  currentEdition: EditionKeySchema.describe("The edition to use when a request names none. It is the publisher's statement and must be a key of editions. It is not the newest edition by date: a publisher may list an edition that takes effect in the future. A reader uses this value and never compares dates. Present only with editions.").optional(),
+  editions: RegistryEditionsSchema.describe("The issuer's editions of this artifact, keyed by edition key. Present only on an artifact that is issued in editions; then latestVersion and versions are inside each edition and absent on the item.").optional(),
+  latestVersion: RegistryVersionKeySchema.describe(`${LATEST_VERSION_DESCRIPTION} Present only with versions, on an artifact that has no editions.`).optional(),
+  versions: RegistryVersionsSchema.describe("The versions of an artifact that has no editions, keyed by version. Present only when editions is absent.").optional(),
+  layers: z39.array(z39.string().describe("Layer key")).describe("Available layer keys").optional(),
+  tags: z39.array(
+    z39.string().min(1).max(50).describe("Tag for categorization")
+  ).describe("Tags for search and filtering").optional()
+}).superRefine((item, ctx) => {
+  const hasEditions = item.currentEdition !== void 0 || item.editions !== void 0;
+  const hasVersions = item.latestVersion !== void 0 || item.versions !== void 0;
+  if (!hasEditions && !hasVersions) {
+    ctx.addIssue({ code: "custom", path: [], message: REGISTRY_ITEM_RELEASES_RULE });
+    return;
+  }
+  if (hasEditions) {
+    for (const key of ["latestVersion", "versions"]) {
+      if (item[key] !== void 0) {
+        ctx.addIssue({ code: "custom", path: [key], message: REGISTRY_ITEM_EDITIONS_ONLY_RULE });
+      }
+    }
+    if (item.currentEdition === void 0) {
+      ctx.addIssue({ code: "custom", path: ["currentEdition"], message: "Required with editions: name the edition to use by default" });
+    } else if (item.editions === void 0) {
+      ctx.addIssue({ code: "custom", path: ["editions"], message: "Required with currentEdition: list the editions" });
+    } else if (!namesEntry(item.editions, item.currentEdition)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["currentEdition"],
+        message: `currentEdition "${item.currentEdition}" is not a key of editions (${listKeys(item.editions)})`
+      });
+    }
+    return;
+  }
+  if (item.latestVersion === void 0) {
+    ctx.addIssue({ code: "custom", path: ["latestVersion"], message: "Required with versions: name the version to use by default" });
+  } else if (item.versions === void 0) {
+    ctx.addIssue({ code: "custom", path: ["versions"], message: "Required with latestVersion: list the versions" });
+  } else if (!namesEntry(item.versions, item.latestVersion)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["latestVersion"],
+      message: `latestVersion "${item.latestVersion}" is not a key of versions (${listKeys(item.versions)})`
+    });
+  }
+}).meta({
+  title: "RegistryItemSummary",
+  description: "One artifact in the registry, with every release of it. An artifact that is issued in editions has currentEdition and editions; an artifact that is not has latestVersion and versions. Never both, and never neither.",
+  oneOf: editionsOrVersionsJsonSchema
+});
+var RegistryItemSummarySchema = RegistryItemObjectSchema;
+function listVersionEntries(item) {
+  const inEditions = Object.entries(item.editions ?? {}).flatMap(
+    ([editionKey, edition]) => Object.entries(edition.versions).map(([version, entry]) => ({
+      path: ["editions", editionKey, "versions", version],
+      entry
+    }))
+  );
+  const onItem = Object.entries(item.versions ?? {}).map(([version, entry]) => ({ path: ["versions", version], entry }));
+  return [...inEditions, ...onItem];
+}
+var formatLocation = (path) => path.map((part) => typeof part === "number" ? `[${part}]` : `.${String(part)}`).join("").replace(/^\./, "");
+var RegistryIndexSchema = z39.object({
+  $schema: z39.url().describe("JSON Schema URI for validation").optional(),
+  name: z39.string().min(1).max(100).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/).describe("Registry name/identifier (lowercase slug, used for data attributes and metadata)"),
+  homepage: z39.url().describe("Homepage URL for the registry").optional(),
+  description: z39.string().max(2e3).describe("Description of the registry").optional(),
+  enableTelemetry: z39.boolean().default(true).describe("Enable anonymous usage telemetry for artifact installs. Defaults to true.").optional(),
+  enableDirectory: z39.boolean().default(true).describe("Allow this registry to appear in the Asterdoc Hub directory. Defaults to true.").optional(),
+  items: z39.array(RegistryItemSummarySchema).describe("Every artifact in the registry, one item for each artifact name. No two items have the same name, and no two versions in the manifest have the same path.")
+}).strict().superRefine((manifest, ctx) => {
+  const names = /* @__PURE__ */ new Map();
+  const paths = /* @__PURE__ */ new Map();
+  manifest.items.forEach((item, index) => {
+    const firstIndex = names.get(item.name);
+    if (firstIndex === void 0) {
+      names.set(item.name, index);
+    } else {
+      ctx.addIssue({
+        code: "custom",
+        path: ["items", index, "name"],
+        message: `Duplicate item name "${item.name}": items[${firstIndex}] already has it`
+      });
+    }
+    for (const { path, entry } of listVersionEntries(item)) {
+      const location = ["items", index, ...path];
+      const firstLocation = paths.get(entry.path);
+      if (firstLocation === void 0) {
+        paths.set(entry.path, formatLocation(location));
+      } else {
+        ctx.addIssue({
+          code: "custom",
+          path: [...location, "path"],
+          message: `Duplicate path "${entry.path}": ${firstLocation} already has it`
+        });
+      }
+    }
+  });
+}).meta({
+  title: "Asterdoc Registry Manifest",
+  description: "Schema for registry.json, the manifest of a file registry. It lists every artifact the registry serves, with every edition and version of each. Every path is relative to the registry base address: the address of the folder that holds registry.json."
+});
+
+// src/zod/registry/release.ts
+var isOwnKey2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function orderKeys(keys, first, compare) {
+  return [...keys].sort((a, b) => {
+    if (a === first || b === first) return a === b ? 0 : a === first ? -1 : 1;
+    return compare(b, a);
+  });
+}
+var compareKeys = (a, b) => a === b ? 0 : a < b ? -1 : 1;
+var orderVersions = (versions, latestVersion) => orderKeys(Object.keys(versions), latestVersion, compareArtifactVersions);
+function releaseEdition(key, entry) {
+  return {
+    key,
+    label: entry.label,
+    ...entry.date !== void 0 && { date: entry.date },
+    ...entry.effectiveFrom !== void 0 && { effectiveFrom: entry.effectiveFrom }
+  };
+}
+function resolveRegistryRelease(item, request = {}) {
+  const requestedEdition = request.edition === CURRENT_EDITION ? void 0 : request.edition;
+  const requestedVersion = request.version === LATEST_VERSION ? void 0 : request.version;
+  let edition = null;
+  let versions;
+  let latestVersion;
+  if (item.editions === void 0) {
+    if (requestedEdition !== void 0) {
+      return {
+        ok: false,
+        failure: {
+          code: "no-editions",
+          name: item.name,
+          edition: requestedEdition,
+          versions: orderVersions(item.versions, item.latestVersion)
+        }
+      };
+    }
+    versions = item.versions;
+    latestVersion = item.latestVersion;
+  } else {
+    const key = requestedEdition ?? item.currentEdition;
+    const entry2 = isOwnKey2(item.editions, key) ? item.editions[key] : void 0;
+    if (entry2 === void 0) {
+      return {
+        ok: false,
+        failure: {
+          code: "unknown-edition",
+          name: item.name,
+          edition: key,
+          currentEdition: item.currentEdition,
+          editions: orderKeys(Object.keys(item.editions), item.currentEdition, compareKeys)
+        }
+      };
+    }
+    edition = releaseEdition(key, entry2);
+    versions = entry2.versions;
+    latestVersion = entry2.latestVersion;
+  }
+  const version = requestedVersion ?? latestVersion;
+  const entry = isOwnKey2(versions, version) ? versions[version] : void 0;
+  if (entry === void 0) {
+    return {
+      ok: false,
+      failure: {
+        code: "unknown-version",
+        name: item.name,
+        edition: edition === null ? null : edition.key,
+        version,
+        latestVersion,
+        versions: orderVersions(versions, latestVersion)
+      }
+    };
+  }
+  return { ok: true, release: { edition, version, path: entry.path, sha256: entry.sha256 } };
+}
+function describeRegistryReleaseFailure(failure) {
+  switch (failure.code) {
+    case "no-editions":
+      return `${failure.name} has no editions, so it has no edition ${failure.edition}. Its versions: ${failure.versions.join(", ")}.`;
+    case "unknown-edition":
+      return `${failure.name} has no edition ${failure.edition}. Its editions: ${failure.editions.join(", ")} (current: ${failure.currentEdition}).`;
+    case "unknown-version": {
+      const owner = failure.edition === null ? failure.name : `Edition ${failure.edition} of ${failure.name}`;
+      return `${owner} has no version ${failure.version}. Its versions: ${failure.versions.join(", ")} (latest: ${failure.latestVersion}).`;
+    }
+  }
+}
+function listVersions(versions, latestVersion) {
+  return orderVersions(versions, latestVersion).flatMap((version) => {
+    const entry = versions[version];
+    return entry === void 0 ? [] : [{ version, path: entry.path, sha256: entry.sha256, isLatest: version === latestVersion }];
+  });
+}
+function listRegistryReleases(item) {
+  if (item.editions === void 0) {
+    return [{
+      edition: null,
+      isCurrent: true,
+      latestVersion: item.latestVersion,
+      versions: listVersions(item.versions, item.latestVersion)
+    }];
+  }
+  const editions = item.editions;
+  return orderKeys(Object.keys(editions), item.currentEdition, compareKeys).flatMap((key) => {
+    const entry = editions[key];
+    if (entry === void 0) return [];
+    return [{
+      edition: releaseEdition(key, entry),
+      isCurrent: key === item.currentEdition,
+      latestVersion: entry.latestVersion,
+      versions: listVersions(entry.versions, entry.latestVersion)
+    }];
+  });
+}
+
+// src/zod/registry/registry-item.ts
+import { z as z40 } from "zod";
+var RegistryLayerBaseSchema = z40.object({
+  mimeType: z40.string().min(1).max(100).describe("MIME type of the layer content"),
+  title: z40.string().min(1).max(200).describe("Human-readable title for this layer").optional(),
+  description: z40.string().min(1).max(2e3).describe("Description of what this layer represents").optional(),
+  checksum: ChecksumSchema.optional()
+});
+var RegistryInlineLayerSchema = RegistryLayerBaseSchema.extend({
+  kind: z40.literal("inline"),
+  text: z40.string().min(1).max(1e6).describe("Layer content with interpolation placeholders (e.g., {{fields.fieldName}})"),
+  // Registry layers strip undeclared keys, so the PDF-only keys are refused
+  // by name rather than dropped without an error.
+  bindings: z40.never({ error: LAYER_BINDINGS_RULE }).optional(),
+  bindingsFrom: z40.never({ error: LAYER_BINDINGS_RULE }).optional()
+}).meta({
+  title: "RegistryInlineLayer",
+  description: "Inline layer with embedded content"
+});
+var RegistryFileLayerSchema = withPdfOnlyFileLayerRules(FileLayerObjectSchema.extend({
+  url: z40.url().describe("Optional URL to download the layer file from; clients otherwise resolve path relative to the registry item").optional()
+}).meta({
+  title: "RegistryFileLayer",
+  description: "File-backed layer with download URL"
+}));
+var RegistryLayerSchema = z40.discriminatedUnion("kind", [
+  RegistryInlineLayerSchema,
+  RegistryFileLayerSchema
+]).meta({
+  title: "RegistryLayer",
+  description: "Layer in a registry item - inline or file with URL",
+  // The file layer's PDF-only refinements, stated to JSON Schema as well.
+  allOf: pdfOnlyLayerKeysJsonSchema(PDF_ONLY_FILE_LAYER_KEYS)
+});
+var RegistryItemSchema = z40.looseObject({
+  $schema: z40.url().describe("JSON Schema URI for validation").optional(),
+  kind: z40.union([
+    z40.literal("form"),
+    z40.literal("document"),
+    z40.literal("checklist"),
+    z40.literal("bundle")
+  ]).describe("Artifact kind"),
+  name: z40.string().min(1).max(128).regex(ARTIFACT_NAME_PATTERN).describe("Artifact name"),
+  version: z40.string().regex(ARTIFACT_VERSION_PATTERN).describe("Semantic version"),
+  title: z40.string().min(1).max(200).describe("Human-readable title").optional(),
+  description: z40.string().max(2e3).describe("Artifact description").optional(),
+  // Layers with registry-specific URL field
+  layers: z40.record(
+    z40.string().describe("Layer key"),
+    RegistryLayerSchema
+  ).describe("Available layers").optional(),
+  defaultLayer: z40.string().describe("Default layer key").optional()
+  // Additional properties carry the artifact-specific keys (fields, items, etc.)
+}).meta({
+  title: "Asterdoc Registry Item",
+  description: "Schema for registry item files (r/{name}.json)"
+});
+
+// src/zod/manifest.ts
+import { z as z41 } from "zod";
+var ManifestCacheConfigSchema = z41.strictObject({
+  ttl: z41.number().int().min(0).default(3600).describe("Default cache TTL in seconds. 0 disables caching. Default: 3600 (1 hour)").optional(),
+  directory: z41.string().describe("Custom cache directory. A leading ~ uses the home directory; relative paths use the project root").optional()
+}).meta({
+  title: "ManifestCacheConfig",
+  description: "Project-level cache configuration for registry data"
+});
+var ManifestArtifactConfigSchema = z41.strictObject({
+  dir: z41.string().min(1).max(256).default("artifacts").describe('Directory for installed artifacts (default: "artifacts")').optional(),
+  output: ArtifactOutputFormatSchema.default("json").describe("Default output format for artifacts: json, yaml, typed (json + .d.ts), or ts (TypeScript module)").optional()
+}).meta({
+  title: "ManifestArtifactConfig",
+  description: "Configuration for artifact management"
+});
+var ManifestSchema = z41.object({
+  $schema: z41.url().describe("JSON Schema URI for validation").optional(),
+  name: z41.string().regex(/^@[a-z0-9-]+\/[a-z0-9-]+$/).min(3).max(214).describe("Scoped package name (@org/repo-name)"),
+  title: z41.string().min(1).max(200).describe("Human-readable project title"),
+  description: z41.string().max(1e3).describe("Project description").optional(),
+  visibility: z41.union([z41.literal("public"), z41.literal("private")]).default("private").describe("Project visibility"),
+  registries: z41.record(
+    z41.string().regex(REGISTRY_NAMESPACE_PATTERN).describe("Registry namespace (must start with @)"),
+    RegistryEntrySchema
+  ).describe("Custom registries for this project (overrides global config)").optional(),
+  artifacts: ManifestArtifactConfigSchema.optional(),
+  cache: ManifestCacheConfigSchema.describe("Project-level cache configuration (overrides global config)").optional(),
+  security: SecurityConfigSchema.describe("Security settings for layer downloads (overrides global config)").optional()
+}).strict().meta({
+  title: "Asterdoc Project Manifest",
+  description: "Schema for asterdoc.json project manifest files"
+});
+var ManifestSchemaRegistry = z41.registry();
+ManifestSchemaRegistry.add(ManifestSchema, { ...ManifestSchema.meta(), id: "Manifest" });
+
+// src/index.ts
+var ASTERDOC_SCHEMA_URL = SCHEMA_VERSIONED_ID;
+export {
+  ALL_EXPRESSION_TYPES,
+  ARTIFACT_ADDRESS_PATTERN,
+  ARTIFACT_COORDINATE_PATTERN,
+  ARTIFACT_NAME_PATTERN,
+  ARTIFACT_REFERENCE_PATTERN,
+  ARTIFACT_VERSION_PATTERN,
+  ASTERDOC_SCHEMA_URL,
+  AddressSchema,
+  ArtifactCoordinateSchema,
+  ArtifactEditionSchema,
+  ArtifactOutputFormatSchema,
+  ArtifactSchema,
+  AsterdocRegistry,
+  AsterdocSchema,
+  AttachmentSchema,
+  BboxSchema,
+  BundleContentItemSchema,
+  BundleSchema,
+  CONFIG_SCHEMA_ID,
+  COORDINATE_SEGMENT_PATTERN,
+  CURRENT_EDITION,
+  ChecklistItemSchema,
+  ChecklistSchema,
+  ChecksumSchema,
+  CondExprSchema,
+  ContentRefSchema,
+  CoordinateSchema,
+  CurrencyCodeSchema,
+  DOCX_MIME_TYPE,
+  DefsSectionSchema,
+  DocumentSchema,
+  DurationSchema,
+  EDITION_DATE_PATTERN,
+  EDITION_KEY_MAX_LENGTH,
+  EDITION_KEY_PATTERN,
+  EDITION_KEY_SCHEMA_PATTERN,
+  EditionKeySchema,
+  EditionSelectorSchema,
+  ExpressionSchema,
+  FORM_FIELD_TYPES,
+  FieldPatternSchema,
+  FieldsetFieldSchema,
+  FormAnnexSchema,
+  FormFieldSchema,
+  FormPartySchema,
+  FormSchema,
+  GlobalConfigSchema,
+  GlobalDefaultsSchema,
+  IDENTIFIER_PATTERN,
+  ISO_8601_DURATION_PATTERN,
+  ISO_8601_DURATION_REGEX,
+  IdentificationSchema,
+  LATEST_VERSION,
+  LAYER_BINDINGS_RULE,
+  LOCK_SCHEMA_ID,
+  LayerSchema,
+  ListFieldSchema,
+  LockFileSchema,
+  LockedArtifactSchema,
+  LockedLayerSchema,
+  MANIFEST_SCHEMA_ID,
+  MAX_PATTERN_LENGTH,
+  ManifestSchema,
+  MetadataSchema,
+  MoneySchema,
+  OBJECT_EXPRESSION_TYPES,
+  OrganizationSchema,
+  PersonSchema,
+  PhoneSchema,
+  REACT_LAYER_FORM_ONLY_RULE,
+  REACT_LAYER_MIME_PATTERN,
+  REACT_LAYER_MIME_TYPES,
+  REACT_LAYER_RULE,
+  REGISTRY_ARTIFACT_PATH_MAX_LENGTH,
+  REGISTRY_ARTIFACT_PATH_PATTERN,
+  REGISTRY_EDITIONS_EMPTY_RULE,
+  REGISTRY_ITEM_EDITIONS_ONLY_RULE,
+  REGISTRY_ITEM_NAME_MAX_LENGTH,
+  REGISTRY_ITEM_RELEASES_RULE,
+  REGISTRY_ITEM_SCHEMA_ID,
+  REGISTRY_NAMESPACE_PATTERN,
+  REGISTRY_REFERENCE_PATTERN,
+  REGISTRY_SCHEMA_ID,
+  REGISTRY_VERSIONS_EMPTY_RULE,
+  REGISTRY_VERSION_PATTERN,
+  RESERVED_EDITION_KEYS,
+  RegistryCacheConfigSchema,
+  RegistryEditionEntrySchema,
+  RegistryEditionsSchema,
+  RegistryEntryObjectSchema,
+  RegistryEntrySchema,
+  RegistryFileLayerSchema,
+  RegistryIndexSchema,
+  RegistryInlineLayerSchema,
+  RegistryItemNameSchema,
+  RegistryItemSchema,
+  RegistryItemSummarySchema,
+  RegistryLayerSchema,
+  RegistryVersionEntrySchema,
+  RegistryVersionKeySchema,
+  RegistryVersionsSchema,
+  RuleSeveritySchema,
+  RulesSectionSchema,
+  RuntimeOrganizationSchema,
+  RuntimePersonSchema,
+  SCALAR_EXPRESSION_TYPES,
+  SCHEMA_BASE,
+  SCHEMA_ROOT_ID,
+  SCHEMA_VERSION,
+  SCHEMA_VERSIONED_ID,
+  SCHEMA_VERSIONS,
+  SignatureSchema,
+  SignatureSlotSchema,
+  SignatureSlotTypeSchema,
+  TEXT_TEMPLATE_MIME_TYPES,
+  ValidationRuleSchema,
+  VersionSelectorSchema,
+  compareArtifactVersions,
+  describePatternProblem,
+  describeRegistryReleaseFailure,
+  findPatternProblem,
+  formatArtifactCoordinate,
+  formatRegistryReference,
+  isDocxMimeType,
+  isEditionSelector,
+  isPdfMimeType,
+  isReactLayerMimeType,
+  isReservedEditionKey,
+  isSchemaVersion,
+  isTextTemplateMimeType,
+  isVersionSelector,
+  listRegistryReleases,
+  parseArtifactCoordinate,
+  parseRegistryReference,
+  readSchemaAddress,
+  resolveRegistryRelease,
+  schemaId,
+  schemaVersionUrl
+};