markdown-schema 0.2.0

package/dist/index.js

@@ -0,0 +1,1039 @@
+// src/index/parse-template/infer-section/freetext.ts
+import { toMarkdown } from "mdast-util-to-markdown";
+import { gfmToMarkdown } from "mdast-util-gfm";
+
+// src/index/parse-template/_shared/extract-directive-body.ts
+var TEMPLATE_ONLY_RE = /<!--\s*TEMPLATE-ONLY:\s*([\s\S]*?)\s*-->/;
+function extractDirectiveBody(html) {
+  const m = html.match(TEMPLATE_ONLY_RE);
+  return m ? m[1].trim() : null;
+}
+
+// src/index/parse-template/infer-section/freetext.ts
+var freetext = (nodes, { section }) => {
+  const hasNestedDirective = (n) => {
+    if (typeof n !== "object" || n === null) return false;
+    const node = n;
+    if (node.type === "html" && typeof node.value === "string") {
+      if (extractDirectiveBody(node.value) !== null) return true;
+    }
+    if (Array.isArray(node.children)) {
+      return node.children.some(hasNestedDirective);
+    }
+    return false;
+  };
+  for (const n of nodes) {
+    if (hasNestedDirective(n)) {
+      throw new Error(
+        `Section "${section}": free-text bodies cannot contain TEMPLATE-ONLY directives`
+      );
+    }
+  }
+  const root = { type: "root", children: nodes };
+  return toMarkdown(root, { extensions: [gfmToMarkdown()] }).trim();
+};
+
+// src/index/parse-template/infer-section/table.ts
+import { toString } from "mdast-util-to-string";
+var table = (nodes, { section }) => {
+  const t = nodes.find((n) => n.type === "table");
+  if (!t) throw new Error(`Section "${section}" must contain a table`);
+  const [head, ...body] = t.children;
+  const headers = head.children.map((c) => toString(c).trim());
+  return body.map((row) => {
+    const obj = /* @__PURE__ */ Object.create(null);
+    row.children.forEach(
+      (cell, i) => obj[headers[i]] = toString(cell).trim()
+    );
+    return obj;
+  });
+};
+
+// src/index/parse-template/infer-section/bullet-list.ts
+import { toString as toString2 } from "mdast-util-to-string";
+var bulletList = (nodes, { section }) => {
+  const l = nodes.find((n) => n.type === "list");
+  if (!l) throw new Error(`Section "${section}" must contain a list`);
+  return l.children.map((item) => toString2(item).trim());
+};
+
+// src/index/parse-template/infer-section/task-list.ts
+import { toString as toString3 } from "mdast-util-to-string";
+var taskList = (nodes, { section }) => {
+  const list = nodes.find((n) => n.type === "list");
+  if (!list) throw new Error(`Section "${section}" must contain a list`);
+  return list.children.map((item) => ({
+    checked: item.checked ?? false,
+    text: toString3(item).trim()
+  }));
+};
+
+// src/index/code-blocks.ts
+var codeBlocks = (nodes) => nodes.filter((n) => n.type === "code").map((n) => ({ lang: n.lang ?? null, value: n.value }));
+
+// src/index/raw-nodes.ts
+var rawNodes = (nodes) => nodes;
+
+// src/index/parse-template/infer-section/optional.ts
+var optional = (ex) => (nodes, ctx) => {
+  try {
+    return ex(nodes, ctx);
+  } catch {
+    return void 0;
+  }
+};
+
+// src/index/fenced-code-with-marker.ts
+function fencedCodeWithMarker(opts) {
+  return (nodes, { section }) => {
+    const idx = nodes.findIndex(
+      (n) => n.type === "html" && opts.marker.test(n.value)
+    );
+    if (idx === -1) {
+      throw new Error(
+        `Section "${section}" must contain ${opts.markerLabel ?? "a marker comment"}`
+      );
+    }
+    const next = nodes[idx + 1];
+    if (!next || next.type !== "code") {
+      throw new Error(
+        `Section "${section}": code block must follow ${opts.markerLabel ?? "the marker"}`
+      );
+    }
+    return { lang: next.lang ?? null, value: next.value };
+  };
+}
+
+// src/index/parse-template/infer-section/repeated/repeated-where.ts
+import { toString as toString4 } from "mdast-util-to-string";
+function repeatedWhere(opts) {
+  return (nodes, ctx) => {
+    const groups = [];
+    let current = null;
+    for (const node of nodes) {
+      if (opts.startsAt(node)) {
+        if (current) groups.push(current);
+        current = {
+          heading: opts.headingFrom?.(node) ?? toString4(node).trim(),
+          nodes: opts.includeBoundary ? [node] : []
+        };
+      } else if (current) {
+        current.nodes.push(node);
+      }
+    }
+    if (current) groups.push(current);
+    return groups.map((g) => {
+      const out = { heading: g.heading };
+      for (const [key, ex] of Object.entries(opts.shape)) {
+        out[key] = ex(g.nodes, { section: `${ctx.section} > ${g.heading}` });
+      }
+      return out;
+    });
+  };
+}
+
+// src/index/parse-template/infer-section/repeated.ts
+import { toString as toString5 } from "mdast-util-to-string";
+function repeated(opts) {
+  return (nodes, ctx) => {
+    let depth = opts.by;
+    return repeatedWhere({
+      startsAt: (n) => {
+        if (n.type !== "heading") return false;
+        if (depth === void 0) depth = n.depth;
+        return n.depth === depth;
+      },
+      headingFrom: (n) => toString5(n).trim(),
+      shape: opts.shape,
+      includeBoundary: false
+    })(nodes, ctx);
+  };
+}
+
+// src/index/parse-template/define-doc-schema.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import { z } from "zod";
+
+// src/index/parse-template/define-doc-schema/split-doc.ts
+import { toString as toString6 } from "mdast-util-to-string";
+
+// src/index/parse-template/define-doc-schema/split-doc/extract-frontmatter.ts
+import { parse as parseYaml } from "yaml";
+function extractFrontmatter(tree) {
+  const node = tree.children.find((n) => n.type === "yaml");
+  if (!node) return void 0;
+  const raw = node.value;
+  const parsed = parseYaml(raw);
+  return parsed ?? {};
+}
+
+// src/index/parse-template/define-doc-schema/split-doc.ts
+function splitDoc(tree, opts) {
+  const frontmatter = extractFrontmatter(tree);
+  let title = "";
+  const sections = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const node of tree.children) {
+    if (opts.titleDepth !== void 0 && !title && node.type === "heading" && node.depth === opts.titleDepth) {
+      title = toString6(node).trim();
+      continue;
+    }
+    if (node.type === "heading" && node.depth === opts.sectionDepth) {
+      current = toString6(node).trim();
+      sections.set(current, []);
+      continue;
+    }
+    if (current) sections.get(current).push(node);
+  }
+  return { frontmatter, title, sections };
+}
+
+// src/index/parse-template/define-doc-schema.ts
+function defineDocSchema(spec) {
+  const shape = {};
+  shape.frontmatter = z.unknown().optional();
+  if (spec.title) shape.title = spec.title.schema;
+  for (const [key, sec] of Object.entries(spec.sections)) {
+    shape[key] = sec.optional ? sec.schema.optional() : sec.schema;
+  }
+  let composite = z.object(shape).strict();
+  if (spec.refine) {
+    composite = composite.superRefine(
+      (doc, ctx) => spec.refine(doc, ctx)
+    );
+  }
+  const sectionDepth = spec.sectionDepth ?? 2;
+  const titleDepth = spec.title ? spec.titleDepth ?? 1 : void 0;
+  return {
+    /**
+     * Parses and validates a raw markdown string against this document schema.
+     *
+     * @param raw - The raw markdown content to parse.
+     * @returns A fully-typed document object.
+     */
+    parse(raw) {
+      const tree = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).parse(raw);
+      const { frontmatter, title, sections } = splitDoc(tree, {
+        titleDepth,
+        sectionDepth
+      });
+      const lifted = {};
+      if (frontmatter !== void 0) lifted.frontmatter = frontmatter;
+      if (spec.title) lifted.title = title;
+      for (const [key, sec] of Object.entries(spec.sections)) {
+        const heading = sec.heading ?? key;
+        const nodes = sections.get(heading);
+        if (!nodes) {
+          if (sec.optional) continue;
+          throw new Error(`Missing required section: "${heading}"`);
+        }
+        if (nodes.length === 0 && sec.optional) continue;
+        lifted[key] = sec.extract(nodes, { section: heading });
+      }
+      return composite.parse(lifted);
+    }
+  };
+}
+
+// src/index/parse-template.ts
+import { unified as unified2 } from "unified";
+import remarkParse2 from "remark-parse";
+import remarkFrontmatter2 from "remark-frontmatter";
+import remarkGfm2 from "remark-gfm";
+
+// src/index/parse-template/infer-section.ts
+import { z as z6 } from "zod";
+
+// src/index/parse-template/_shared/parse-directive/_shared/split-escaped-choices.ts
+function splitEscapedChoices(input) {
+  const choices = [];
+  let current = "";
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === "\\") {
+      const next = input[i + 1];
+      if (next === "\\") {
+        current += "\\";
+        i += 2;
+      } else if (next === "|") {
+        current += "|";
+        i += 2;
+      } else {
+        current += "\\" + (next ?? "");
+        i += 2;
+      }
+    } else if (ch === "|") {
+      choices.push(current.trim());
+      current = "";
+      i++;
+    } else {
+      current += ch;
+      i++;
+    }
+  }
+  choices.push(current.trim());
+  return choices.filter(Boolean);
+}
+
+// src/index/parse-template/_shared/parse-directive/parse-enum.ts
+function parseEnum(body) {
+  const parts = body.split(";").map((s) => s.trim());
+  const choicesPart = parts[0] ?? body;
+  const after = choicesPart.slice("enum:".length).trim();
+  const choices = splitEscapedChoices(after);
+  const required = !parts.slice(1).includes("optional");
+  return { kind: "enum", choices, required };
+}
+
+// src/index/parse-template/_shared/parse-directive/parse-field.ts
+function parseField(body) {
+  const parts = body.split(";").map((s) => s.trim());
+  let required = true;
+  let regex;
+  let defaultValue;
+  let onlyIf;
+  for (const part of parts) {
+    if (part === "string") {
+    } else if (part === "optional") {
+      required = false;
+    } else if (part === "required") {
+      required = true;
+    } else if (part.startsWith("regex")) {
+      const m = part.match(/`([^`]+)`/);
+      if (m) regex = m[1];
+    } else if (part.startsWith("default=")) {
+      defaultValue = part.slice("default=".length).replace(/^["']/, "").replace(/["']$/, "");
+    } else if (part.startsWith("only-if ")) {
+      const rest = part.slice("only-if ".length);
+      const eqIdx = rest.indexOf("=");
+      if (eqIdx > -1) {
+        onlyIf = {
+          key: rest.slice(0, eqIdx).trim(),
+          value: rest.slice(eqIdx + 1).trim()
+        };
+      }
+    }
+  }
+  return { kind: "field", required, regex, defaultValue, onlyIf };
+}
+
+// src/index/parse-template/_shared/directive-error.ts
+var DirectiveError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "DirectiveError";
+    this.body = options?.body;
+    this.position = options?.position;
+    this.file = options?.file;
+  }
+  /** The raw directive body that triggered the error, if available. */
+  body;
+  /** Source position of the directive opener, if available. */
+  position;
+  /** Source file path, if available. */
+  file;
+};
+
+// src/index/parse-template/_shared/parse-directive/parse-freetext-directive.ts
+function parseFreetextDirective(body) {
+  const allLines = body.split("\n");
+  const openerLine = allLines[0] ?? "";
+  const bodyLines = allLines.slice(1);
+  for (const line of bodyLines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    if (trimmed.startsWith("//")) continue;
+    throw new DirectiveError(
+      `freetext modifiers must be on the directive opener, not in the body; found: "${trimmed}"`,
+      { body }
+    );
+  }
+  const parts = openerLine.slice("freetext".length).split(";").map((s) => s.trim()).filter(Boolean);
+  let optional2 = false;
+  for (const part of parts) {
+    if (part === "optional") {
+      optional2 = true;
+    } else if (part === "required") {
+    } else {
+      throw new DirectiveError(`unknown freetext modifier: '${part}'`, {
+        body
+      });
+    }
+  }
+  return { kind: "freetext", optional: optional2 };
+}
+
+// src/index/parse-template/_shared/parse-directive/parse-guide.ts
+function parseGuide(body) {
+  const lines = body.split("\n").slice(1);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    if (trimmed.startsWith("//")) continue;
+    throw new DirectiveError(
+      `guide block: line must start with '//' or be blank; got: "${trimmed}"`,
+      { body }
+    );
+  }
+  return { kind: "guide" };
+}
+
+// src/index/parse-template/_shared/parse-directive/parse-row-directive/parse-column-spec.ts
+function parseColumnSpec(spec) {
+  const parts = spec.split(";").map((s) => s.trim());
+  let required = true;
+  let regex;
+  let enumChoices;
+  let defaultValue;
+  for (const part of parts) {
+    if (part === "string") {
+    } else if (part === "optional") {
+      required = false;
+    } else if (part === "required") {
+      required = true;
+    } else if (part.startsWith("regex")) {
+      const m = part.match(/`([^`]+)`/);
+      if (m) regex = m[1];
+    } else if (part.startsWith("enum:")) {
+      enumChoices = splitEscapedChoices(part.slice("enum:".length).trim());
+    } else if (part.startsWith("default=")) {
+      defaultValue = part.slice("default=".length).replace(/^["']/, "").replace(/["']$/, "");
+    }
+  }
+  return { required, regex, enumChoices, defaultValue };
+}
+
+// src/index/parse-template/_shared/parse-directive/parse-row-directive.ts
+function parseRowDirective(body) {
+  const allLines = body.split("\n");
+  const openerLine = allLines[0] ?? "";
+  const bodyLines = allLines.slice(1);
+  const openerParts = openerLine.slice("row".length).split(";").map((s) => s.trim()).filter(Boolean);
+  const columns = {};
+  let minRows;
+  let maxRows;
+  let sectionOptional = false;
+  for (const part of openerParts) {
+    if (part.startsWith("min-rows:")) {
+      minRows = parseInt(part.slice("min-rows:".length).trim(), 10);
+    } else if (part.startsWith("max-rows:")) {
+      maxRows = parseInt(part.slice("max-rows:".length).trim(), 10);
+    } else if (part === "section-optional") {
+      sectionOptional = true;
+    }
+  }
+  for (const line of bodyLines) {
+    if (line.trim().length === 0) continue;
+    if (line.trim().startsWith("//")) continue;
+    if (line.trim().startsWith("min-rows:") || line.trim().startsWith("max-rows:") || line.trim() === "section-optional") {
+      throw new DirectiveError(
+        `min-rows / max-rows / section-optional must be on the directive opener, not in the body`,
+        { body }
+      );
+    }
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > -1) {
+      let colName = line.slice(0, colonIdx).trim();
+      if (colName.startsWith('"') && colName.endsWith('"') || colName.startsWith("'") && colName.endsWith("'")) {
+        colName = colName.slice(1, -1);
+      }
+      const spec = line.slice(colonIdx + 1).trim();
+      if (colName) columns[colName] = parseColumnSpec(spec);
+    }
+  }
+  return { kind: "row", columns, minRows, maxRows, sectionOptional };
+}
+
+// src/index/parse-template/_shared/parse-directive/parse-section-directive.ts
+function parseSectionDirective(body) {
+  const allLines = body.split("\n");
+  const openerLine = allLines[0] ?? "";
+  const bodyLines = allLines.slice(1);
+  for (const line of bodyLines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    if (trimmed.startsWith("//")) continue;
+    throw new DirectiveError(
+      `section modifiers must be on the directive opener, not in the body; found: "${trimmed}"`,
+      { body }
+    );
+  }
+  const parts = openerLine.slice("section".length).split(";").map((s) => s.trim()).filter(Boolean);
+  let optional2 = false;
+  let removeIf;
+  let minGroups;
+  let maxGroups;
+  for (const part of parts) {
+    if (part === "optional") {
+      optional2 = true;
+    } else if (part.startsWith("remove-if ")) {
+      const rest = part.slice("remove-if ".length);
+      const eqIdx = rest.indexOf("=");
+      if (eqIdx > -1) {
+        removeIf = {
+          key: rest.slice(0, eqIdx).trim(),
+          value: rest.slice(eqIdx + 1).trim()
+        };
+      }
+    } else if (part.startsWith("min-groups:")) {
+      minGroups = parseInt(part.slice("min-groups:".length).trim(), 10);
+    } else if (part.startsWith("max-groups:")) {
+      maxGroups = parseInt(part.slice("max-groups:".length).trim(), 10);
+    }
+  }
+  return { kind: "section", optional: optional2, removeIf, minGroups, maxGroups };
+}
+
+// src/index/parse-template/_shared/parse-directive.ts
+function parseDirective(body, opts) {
+  if (body === "guide" || body.startsWith("guide\n") || body.startsWith("guide;"))
+    return parseGuide(body);
+  if (body === "row" || body.startsWith("row\n") || body.startsWith("row;"))
+    return parseRowDirective(body);
+  if (body === "section" || body.startsWith("section\n") || body.startsWith("section;"))
+    return parseSectionDirective(body);
+  if (body === "freetext" || body.startsWith("freetext\n") || body.startsWith("freetext;"))
+    return parseFreetextDirective(body);
+  const stripped = body.split("\n").filter((l) => !l.trim().startsWith("//")).join("\n").trim();
+  const firstToken = stripped.split(/[\s;]/)[0] ?? "";
+  if (stripped.startsWith("enum:")) return parseEnum(stripped);
+  if (firstToken === "string") return parseField(stripped);
+  const token = firstToken || stripped.slice(0, 20);
+  throw new DirectiveError(`unknown TEMPLATE-ONLY directive kind: '${token}'`, {
+    body,
+    position: opts?.position,
+    file: opts?.file
+  });
+}
+
+// src/index/parse-template/infer-section/build-row-schema.ts
+import { z as z2 } from "zod";
+
+// src/index/parse-template/_shared/compile-user-regex.ts
+import { checkSync } from "recheck";
+var MAX_REGEX_LENGTH = 200;
+var MAX_POLYNOMIAL_DEGREE = 2;
+function compileUserRegex(src, label) {
+  const ctx = label ? ` for ${label}` : "";
+  if (src.length > MAX_REGEX_LENGTH) {
+    throw new DirectiveError(
+      `regex${ctx} is too long (${src.length} > ${MAX_REGEX_LENGTH} characters)`
+    );
+  }
+  const diagnostics = checkSync(src, "");
+  if (diagnostics.status === "vulnerable") {
+    const c = diagnostics.complexity;
+    const tolerable = c?.type === "polynomial" && c.degree <= MAX_POLYNOMIAL_DEGREE;
+    if (!tolerable) {
+      const detail = c?.type === "polynomial" ? `is super-linear (degree ${c.degree})` : "is vulnerable to catastrophic backtracking (ReDoS)";
+      throw new DirectiveError(`regex${ctx} ${detail}: \`${src}\``);
+    }
+  } else if (diagnostics.status !== "safe") {
+    throw new DirectiveError(
+      `regex${ctx} could not be proven safe (${diagnostics.status}): \`${src}\``
+    );
+  }
+  try {
+    return new RegExp(src);
+  } catch (err) {
+    throw new DirectiveError(
+      `regex${ctx} is invalid: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+// src/index/parse-template/infer-section/build-row-schema.ts
+function buildRowSchema(columns) {
+  const shape = {};
+  for (const [col, spec] of Object.entries(columns)) {
+    const re = spec.regex ? compileUserRegex(spec.regex, col) : void 0;
+    let field;
+    if (spec.enumChoices && spec.enumChoices.length > 0) {
+      field = z2.enum(spec.enumChoices);
+    } else if (re) {
+      field = z2.string().regex(re);
+    } else {
+      field = z2.string();
+    }
+    if (spec.required) {
+      if (spec.enumChoices && spec.enumChoices.length > 0) {
+        field = z2.enum(spec.enumChoices);
+      } else if (re) {
+        field = z2.string().min(1).regex(re);
+      } else {
+        field = z2.string();
+      }
+    } else {
+      field = field.optional();
+    }
+    shape[col] = field;
+  }
+  return z2.object(shape).strict();
+}
+
+// src/index/parse-template/infer-section/parse-block-directives/block-html-nodes.ts
+function blockHtmlNodes(nodes) {
+  return nodes.filter((n) => n.type === "html");
+}
+
+// src/index/parse-template/infer-section/parse-block-directives.ts
+function parseBlockDirectives(nodes) {
+  const result = [];
+  for (const n of blockHtmlNodes(nodes)) {
+    const body = extractDirectiveBody(n.value);
+    if (!body) continue;
+    const d = parseDirective(body);
+    if (d) result.push(d);
+  }
+  return result;
+}
+
+// src/index/parse-template/infer-section/find-directive.ts
+function findDirective(directives, kind) {
+  return directives.find(
+    (d) => d.kind === kind
+  );
+}
+
+// src/index/parse-template/_shared/collect-item-directives.ts
+function collectItemDirectives(list) {
+  const result = {};
+  for (const item of list.children) {
+    const para = item.children.find(
+      (c) => c.type === "paragraph"
+    );
+    if (!para) continue;
+    let label = "";
+    let directive = null;
+    for (const child of para.children) {
+      if (child.type === "text") {
+        label += child.value;
+      } else if (child.type === "html") {
+        const body = extractDirectiveBody(child.value);
+        if (body) {
+          directive = parseDirective(body);
+        }
+      } else if (child.type === "inlineCode") {
+      }
+    }
+    const colonIdx = label.indexOf(":");
+    if (colonIdx > -1) {
+      const key = label.slice(0, colonIdx).trim();
+      if (key) result[key] = directive;
+    }
+  }
+  return result;
+}
+
+// src/index/parse-template/infer-section/is-labeled-list.ts
+function isLabeledList(list) {
+  const directives = collectItemDirectives(list);
+  return Object.keys(directives).length > 0 && Object.values(directives).some((d) => d !== null);
+}
+
+// src/index/parse-template/infer-section/is-task-list.ts
+function isTaskList(list) {
+  return list.children.some(
+    (item) => item.checked !== null && item.checked !== void 0
+  );
+}
+
+// src/index/parse-template/infer-section/build-labeled-list-schema.ts
+import { z as z3 } from "zod";
+function buildLabeledListSchema(itemDirectives) {
+  const specs = {};
+  for (const [key, d] of Object.entries(itemDirectives)) {
+    if (!d) {
+      specs[key] = { required: false, validate: () => null };
+      continue;
+    }
+    if (d.kind === "enum") {
+      specs[key] = {
+        required: d.required,
+        validate: (val) => {
+          if (d.required && !val) return `${key} is required`;
+          if (val && !d.choices.includes(val))
+            return `Invalid option: expected one of ${d.choices.map((c) => `"${c}"`).join("|")}`;
+          return null;
+        }
+      };
+    } else if (d.kind === "field") {
+      const spec = d;
+      const re = spec.regex ? compileUserRegex(spec.regex, key) : void 0;
+      specs[key] = {
+        required: spec.required,
+        validate: (val) => {
+          if (spec.required && !val) return `${key} is required`;
+          if (val && re) {
+            if (!re.test(val)) return `${key} does not match required format`;
+          }
+          return null;
+        },
+        onlyIf: spec.onlyIf
+      };
+    }
+  }
+  return z3.array(z3.string()).transform((lines) => {
+    const obj = /* @__PURE__ */ Object.create(null);
+    for (const line of lines) {
+      const idx = line.indexOf(":");
+      if (idx >= 0) {
+        const k = line.slice(0, idx).trim();
+        const v = line.slice(idx + 1).trim();
+        if (k) obj[k] = v || void 0;
+      }
+    }
+    return obj;
+  }).superRefine((obj, ctx) => {
+    for (const [key, spec] of Object.entries(specs)) {
+      const val = obj[key];
+      const err = spec.validate(val);
+      if (err) {
+        ctx.addIssue({ code: "custom", path: [key], message: err });
+      }
+      if (spec.onlyIf && val) {
+        const guardVal = obj[spec.onlyIf.key];
+        if (guardVal !== spec.onlyIf.value) {
+          ctx.addIssue({
+            code: "custom",
+            path: [key],
+            message: `${key} is only allowed when ${spec.onlyIf.key}=${spec.onlyIf.value}`
+          });
+        }
+      }
+    }
+  });
+}
+
+// src/index/parse-template/infer-section/build-repeated-schema.ts
+import { z as z4 } from "zod";
+function buildRepeatedSchema(nodes, minGroups, maxGroups, headingSchema) {
+  const groupItemZod = z4.object({
+    heading: headingSchema ?? z4.string().min(1),
+    items: z4.array(z4.string())
+  });
+  let schema = z4.array(groupItemZod);
+  if (minGroups) schema = schema.min(minGroups);
+  if (maxGroups) schema = schema.max(maxGroups);
+  return schema;
+}
+
+// src/index/parse-template/infer-section/directive-to-field-schema.ts
+import { z as z5 } from "zod";
+function directiveToFieldSchema(directive) {
+  if (directive.kind === "enum") {
+    const base = z5.enum(directive.choices);
+    return directive.required ? base : base.optional();
+  }
+  if (directive.kind === "field") {
+    const base = directive.regex ? z5.string().min(1).regex(compileUserRegex(directive.regex)) : z5.string().min(1);
+    return directive.required ? base : base.optional();
+  }
+  return z5.string().min(1);
+}
+
+// src/index/parse-template/infer-section.ts
+function inferSection(nodes, _heading) {
+  const blockDirectives = parseBlockDirectives(nodes);
+  const sectionDir = findDirective(blockDirectives, "section");
+  const rowDir = findDirective(blockDirectives, "row");
+  const freetextDir = findDirective(blockDirectives, "freetext");
+  const isOptional = (sectionDir?.optional ?? rowDir?.sectionOptional ?? false) || (freetextDir?.optional ?? false);
+  const contentNodes = nodes.filter((n) => {
+    if (n.type !== "html") return true;
+    const body = extractDirectiveBody(n.value);
+    return body === null;
+  });
+  if (freetextDir) {
+    if (rowDir) {
+      throw new Error(
+        `Section "${_heading}" cannot use both 'freetext' and 'row' directives`
+      );
+    }
+    let extract = freetext;
+    let schema = z6.string().min(1);
+    if (isOptional) {
+      extract = optional(freetext);
+      schema = schema.optional();
+    }
+    return { extract, schema, optional: isOptional };
+  }
+  const hasSubHeadings = contentNodes.some(
+    (n) => n.type === "heading"
+  );
+  if (hasSubHeadings) {
+    const minGroups = sectionDir?.minGroups;
+    const maxGroups = sectionDir?.maxGroups;
+    let headingSchema;
+    const firstHeading = contentNodes.find(
+      (n) => n.type === "heading"
+    );
+    if (firstHeading) {
+      const inlineHtml = firstHeading.children.find(
+        (c) => c.type === "html"
+      );
+      if (inlineHtml) {
+        const body = extractDirectiveBody(inlineHtml.value);
+        if (body) {
+          const dir = parseDirective(body);
+          if (dir.kind === "field" || dir.kind === "enum") {
+            headingSchema = directiveToFieldSchema(dir);
+          } else {
+            throw new DirectiveError(
+              `H3 sub-headings only support inline field or enum directives, got: ${dir.kind}`
+            );
+          }
+        }
+      }
+    }
+    const schema = buildRepeatedSchema(
+      contentNodes,
+      minGroups,
+      maxGroups,
+      headingSchema
+    );
+    return {
+      extract: repeated({ shape: { items: bulletList } }),
+      schema,
+      optional: isOptional
+    };
+  }
+  const hasTable = contentNodes.some((n) => n.type === "table");
+  if (rowDir || hasTable) {
+    let rowSchema = z6.record(z6.string(), z6.string());
+    if (rowDir) rowSchema = buildRowSchema(rowDir.columns);
+    let arraySchema = z6.array(rowSchema);
+    if (rowDir?.minRows)
+      arraySchema = arraySchema.min(
+        rowDir.minRows
+      );
+    if (rowDir?.maxRows)
+      arraySchema = arraySchema.max(
+        rowDir.maxRows
+      );
+    let extract = table;
+    if (isOptional) {
+      extract = optional(table);
+      arraySchema = arraySchema.optional();
+    }
+    return { extract, schema: arraySchema, optional: isOptional };
+  }
+  const listNode = contentNodes.find((n) => n.type === "list");
+  if (listNode) {
+    if (isTaskList(listNode)) {
+      return {
+        extract: taskList,
+        schema: z6.array(z6.object({ checked: z6.boolean(), text: z6.string() })),
+        optional: isOptional
+      };
+    }
+    const itemDirs = collectItemDirectives(listNode);
+    if (isLabeledList(listNode)) {
+      const schema = buildLabeledListSchema(itemDirs);
+      return { extract: bulletList, schema, optional: isOptional };
+    }
+    return {
+      extract: bulletList,
+      schema: z6.array(z6.string()),
+      optional: isOptional
+    };
+  }
+  throw new Error(
+    `Section "${_heading}" has no recognized shape; add a 'freetext' directive if free-form content is intended`
+  );
+}
+
+// src/index/parse-template/split-sections.ts
+import { toString as toString7 } from "mdast-util-to-string";
+function splitSections(tree, titleDepth, sectionDepth) {
+  const sections = /* @__PURE__ */ new Map();
+  let current = null;
+  let titleSeen = false;
+  for (const node of tree.children) {
+    if (node.type === "heading" && node.depth === titleDepth && !titleSeen) {
+      titleSeen = true;
+      continue;
+    }
+    if (node.type === "heading" && node.depth === sectionDepth) {
+      for (const child of node.children) {
+        if (child.type === "html") {
+          const body = extractDirectiveBody(child.value);
+          if (body !== null) {
+            const pos = node.position?.start;
+            throw new DirectiveError(
+              `H2 headings cannot carry inline TEMPLATE-ONLY directives \u2014 only H1 (title) and H3 (per-group heading inside repeated sections) support inline directives`,
+              {
+                body,
+                position: pos ? { line: pos.line, column: pos.column } : void 0
+              }
+            );
+          }
+        }
+      }
+      current = toString7(node).trim();
+      sections.set(current, []);
+      continue;
+    }
+    if (current !== null) {
+      sections.get(current).push(node);
+    }
+  }
+  return sections;
+}
+
+// src/index/parse-template/build-title-schema.ts
+import { z as z7 } from "zod";
+function buildTitleSchema(tree, depth) {
+  const h = tree.children.find(
+    (n) => n.type === "heading" && n.depth === depth
+  );
+  if (!h) return void 0;
+  let prefix = "";
+  let hasPlaceholder = false;
+  let directiveHtml;
+  for (const child of h.children) {
+    if (child.type === "text") prefix += child.value;
+    else if (child.type === "html") {
+      hasPlaceholder = true;
+      directiveHtml = child.value;
+      break;
+    }
+  }
+  prefix = prefix.replace(/^\s+/, "");
+  const hadTrailingSpace = /\s$/.test(prefix);
+  prefix = prefix.replace(/\s+$/, "");
+  if (prefix && hasPlaceholder) {
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const sep = hadTrailingSpace ? " " : "";
+    const body = directiveHtml ? extractDirectiveBody(directiveHtml) : null;
+    let directive = null;
+    if (body) {
+      try {
+        directive = parseDirective(body);
+      } catch (err) {
+        if (!(err instanceof DirectiveError)) throw err;
+      }
+    }
+    if (directive && directive.kind === "field") {
+      const innerSource = directive.regex ? compileUserRegex(directive.regex, "title").source.replace(
+        /^\^|\$$/g,
+        ""
+      ) : void 0;
+      const suffix = innerSource ? `(?:${innerSource})` : `.+`;
+      const label = directive.regex ? directive.regex : "value";
+      return z7.string().regex(
+        new RegExp(`^${escaped}${sep}${suffix}$`),
+        `title must match '${prefix}${sep}<${label}>'`
+      );
+    }
+    if (directive && directive.kind === "enum") {
+      const choicePattern = directive.choices.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+      return z7.string().regex(
+        new RegExp(`^${escaped}${sep}(?:${choicePattern})$`),
+        `title must be '${prefix}${sep}<${directive.choices.join(" | ")}>'`
+      );
+    }
+    return z7.string().regex(
+      new RegExp(`^${escaped}${sep}[A-Z][A-Za-z0-9]*$`),
+      `title must be '${prefix}${sep}PascalCaseName'`
+    );
+  }
+  if (prefix) {
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return z7.string().regex(new RegExp(`^${escaped}$`), `title must be '${prefix}'`);
+  }
+  return z7.string().min(1);
+}
+
+// src/index/parse-template/heading-to-key.ts
+function headingToKey(heading) {
+  const withoutNumber = heading.replace(/^\d+(\.\d+)*\.\s*/, "");
+  const cleaned = withoutNumber.replace(/\s*\(.*\)\s*$/, "").replace(/\s*\/.*$/, "").trim();
+  const words = cleaned.split(/[\s-]+/).filter(Boolean);
+  if (words.length === 0) return heading.toLowerCase();
+  const [first, ...rest] = words;
+  return first.toLowerCase() + rest.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+
+// src/index/parse-template/validate-directive-shape.ts
+function validateDirectiveShape(raw, file) {
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const openerIdx = line.indexOf("<!-- TEMPLATE-ONLY:");
+    if (openerIdx < 0) continue;
+    const beforeOpener = line.slice(0, openerIdx).trim();
+    const isInline = beforeOpener.length > 0;
+    const closesOnSameLine = line.indexOf("-->", openerIdx) > -1;
+    const lineNum = i + 1;
+    const col = openerIdx + 1;
+    const pos = { line: lineNum, column: col };
+    if (isInline && !closesOnSameLine) {
+      throw new DirectiveError(
+        `${file ?? "template.md"}:${lineNum}:${col}: inline TEMPLATE-ONLY directive must close on the same line; "-->" not found before line end`,
+        { position: pos, file }
+      );
+    }
+    if (!isInline && !closesOnSameLine) {
+      let found = false;
+      for (let j = i + 1; j < lines.length; j++) {
+        if ((lines[j] ?? "").includes("-->")) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        throw new DirectiveError(
+          `${file ?? "template.md"}:${lineNum}:${col}: block TEMPLATE-ONLY directive is unclosed; "-->" not found`,
+          { position: pos, file }
+        );
+      }
+    }
+  }
+}
+
+// src/index/parse-template.ts
+function parseTemplate(templateRaw, opts) {
+  validateDirectiveShape(templateRaw, opts?.file);
+  const tree = unified2().use(remarkParse2).use(remarkFrontmatter2, ["yaml"]).use(remarkGfm2).parse(templateRaw);
+  const titleDepth = 1;
+  const sectionDepth = 2;
+  const titleValidation = buildTitleSchema(tree, titleDepth);
+  const sections = splitSections(tree, titleDepth, sectionDepth);
+  const sectionSpecs = {};
+  for (const [heading, nodes] of sections) {
+    const inference = inferSection(nodes, heading);
+    const key = headingToKey(heading);
+    sectionSpecs[key] = {
+      heading,
+      extract: inference.extract,
+      schema: inference.schema,
+      optional: inference.optional
+    };
+  }
+  return defineDocSchema({
+    title: titleValidation ? { schema: titleValidation } : void 0,
+    sections: sectionSpecs,
+    refine: opts?.refine
+  });
+}
+export {
+  bulletList,
+  codeBlocks,
+  defineDocSchema,
+  fencedCodeWithMarker,
+  freetext,
+  headingToKey,
+  optional,
+  parseTemplate,
+  rawNodes,
+  repeated,
+  repeatedWhere,
+  table,
+  taskList
+};
+//# sourceMappingURL=index.js.map