@broadpaper/core 0.1.1

package/dist/index.js

@@ -0,0 +1,4343 @@
+// src/types/template.ts
+var CURRENT_SCHEMA_VERSION = 1;
+
+// src/richtext/model.ts
+function createParagraph(text = "", marks) {
+  return { type: "paragraph", content: text ? [{ type: "text", text, ...marks ? { marks } : {} }] : [] };
+}
+function createRichText(text = "") {
+  return { type: "doc", content: [createParagraph(text)] };
+}
+function richTextFromTemplate(template) {
+  const paragraphs = template.split(/\n/);
+  return {
+    type: "doc",
+    content: paragraphs.map((p) => ({ type: "paragraph", content: inlineFromTemplate(p) }))
+  };
+}
+function inlineFromTemplate(text) {
+  const out = [];
+  const re = /\{\{\s*([^}]+?)\s*\}\}/g;
+  let last = 0;
+  let m;
+  while (m = re.exec(text)) {
+    if (m.index > last) out.push({ type: "text", text: text.slice(last, m.index) });
+    out.push({ type: "token", expr: m[1] });
+    last = m.index + m[0].length;
+  }
+  if (last < text.length) out.push({ type: "text", text: text.slice(last) });
+  return out;
+}
+function richTextToPlain(doc, tokenText = (e) => `{{${e}}}`) {
+  if (!doc) return "";
+  const lines = [];
+  for (const block of doc.content) {
+    if (block.type === "paragraph") lines.push(inlineToPlain(block.content, tokenText));
+    else for (const item of block.content) for (const p of item.content) lines.push(inlineToPlain(p.content, tokenText));
+  }
+  return lines.join("\n");
+}
+function inlineToPlain(content, tokenText) {
+  return content.map((n) => n.type === "text" ? n.text : n.type === "token" ? tokenText(n.expr) : "\n").join("");
+}
+function richTextTokens(doc) {
+  const out = [];
+  if (!doc) return out;
+  const visitInline = (content) => {
+    for (const n of content) {
+      if (n.type === "token") out.push(n.expr);
+      if (n.type === "text" && n.marks?.link) {
+        for (const e of extractTemplateTokens(n.marks.link)) out.push(e);
+      }
+    }
+  };
+  for (const block of doc.content) {
+    if (block.type === "paragraph") visitInline(block.content);
+    else for (const item of block.content) for (const p of item.content) visitInline(p.content);
+  }
+  return out;
+}
+function extractTemplateTokens(text) {
+  if (!text) return [];
+  const out = [];
+  const re = /\{\{\s*([^}]+?)\s*\}\}/g;
+  let m;
+  while (m = re.exec(text)) out.push(m[1]);
+  return out;
+}
+function isRichTextDoc(value) {
+  return !!value && typeof value === "object" && value.type === "doc" && Array.isArray(value.content);
+}
+
+// src/expr/ast.ts
+function pathToString(segments) {
+  let s = "";
+  for (const seg of segments) {
+    if (seg.kind === "prop") s += s ? `.${seg.name}` : seg.name;
+    else s += `[${seg.index}]`;
+  }
+  return s;
+}
+function exprToString(e) {
+  switch (e.kind) {
+    case "literal":
+      return typeof e.value === "string" ? JSON.stringify(e.value) : String(e.value);
+    case "path":
+      return pathToString(e.segments);
+    case "unary":
+      return e.op === "not" ? `not ${wrap(e.arg)}` : `-${wrap(e.arg)}`;
+    case "binary":
+      return `${wrap(e.left)} ${e.op} ${wrap(e.right)}`;
+    case "conditional":
+      return `${wrap(e.test)} ? ${wrap(e.then)} : ${wrap(e.else)}`;
+    case "call":
+      return `${e.name}(${e.args.map(exprToString).join(", ")})`;
+    case "pipe":
+      return `${exprToString(e.input)} | ${e.name}${e.args.length ? ":" + e.args.map(exprToString).join(":") : ""}`;
+    case "array":
+      return `[${e.items.map(exprToString).join(", ")}]`;
+  }
+}
+function wrap(e) {
+  const s = exprToString(e);
+  return e.kind === "binary" || e.kind === "conditional" || e.kind === "pipe" ? `(${s})` : s;
+}
+function collectPaths(e, out = []) {
+  switch (e.kind) {
+    case "path":
+      out.push(e.segments);
+      break;
+    case "unary":
+      collectPaths(e.arg, out);
+      break;
+    case "binary":
+      collectPaths(e.left, out);
+      collectPaths(e.right, out);
+      break;
+    case "conditional":
+      collectPaths(e.test, out);
+      collectPaths(e.then, out);
+      collectPaths(e.else, out);
+      break;
+    case "call":
+    case "array":
+      for (const a of e.kind === "call" ? e.args : e.items) collectPaths(a, out);
+      break;
+    case "pipe":
+      collectPaths(e.input, out);
+      for (const a of e.args) collectPaths(a, out);
+      break;
+  }
+  return out;
+}
+
+// src/expr/parser.ts
+var ExpressionError = class extends Error {
+  constructor(message, position, source) {
+    super(message);
+    this.position = position;
+    this.source = source;
+    this.name = "ExpressionError";
+  }
+  position;
+  source;
+};
+var MAX_LENGTH = 2e3;
+var MAX_DEPTH = 32;
+var KEYWORDS = /* @__PURE__ */ new Set(["and", "or", "not", "in", "true", "false", "null"]);
+var MULTI_OPS = ["==", "!=", "<=", ">="];
+var SINGLE_OPS = new Set("+-*/%<>()[]|:?,.".split(""));
+function tokenize(src) {
+  if (src.length > MAX_LENGTH) throw new ExpressionError(`Expression is too long (max ${MAX_LENGTH} characters)`, 0, src);
+  const tokens = [];
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    const pos = i;
+    if (/[0-9]/.test(ch) || ch === "." && /[0-9]/.test(src[i + 1] ?? "")) {
+      let j = i;
+      while (j < src.length && /[0-9_]/.test(src[j])) j++;
+      if (src[j] === "." && /[0-9]/.test(src[j + 1] ?? "")) {
+        j++;
+        while (j < src.length && /[0-9]/.test(src[j])) j++;
+      }
+      if ((src[j] === "e" || src[j] === "E") && /[0-9+-]/.test(src[j + 1] ?? "")) {
+        j += 2;
+        while (j < src.length && /[0-9]/.test(src[j])) j++;
+      }
+      tokens.push({ type: "num", value: Number(src.slice(i, j).replace(/_/g, "")), pos });
+      i = j;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      let j = i + 1;
+      let out = "";
+      while (j < src.length && src[j] !== ch) {
+        if (src[j] === "\\" && j + 1 < src.length) {
+          const n = src[j + 1];
+          out += n === "n" ? "\n" : n === "t" ? "	" : n;
+          j += 2;
+        } else {
+          out += src[j];
+          j++;
+        }
+      }
+      if (j >= src.length) throw new ExpressionError("Unterminated string", pos, src);
+      tokens.push({ type: "str", value: out, pos });
+      i = j + 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(ch)) {
+      let j = i;
+      while (j < src.length && /[A-Za-z0-9_$]/.test(src[j])) j++;
+      tokens.push({ type: "ident", value: src.slice(i, j), pos });
+      i = j;
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (MULTI_OPS.includes(two)) {
+      tokens.push({ type: "op", value: two, pos });
+      i += 2;
+      continue;
+    }
+    if (ch === "=" && src[i + 1] !== "=") {
+      tokens.push({ type: "op", value: "==", pos });
+      i++;
+      continue;
+    }
+    if (ch === "&" && src[i + 1] === "&") {
+      tokens.push({ type: "ident", value: "and", pos });
+      i += 2;
+      continue;
+    }
+    if (ch === "|" && src[i + 1] === "|") {
+      tokens.push({ type: "ident", value: "or", pos });
+      i += 2;
+      continue;
+    }
+    if (ch === "!") {
+      tokens.push({ type: "ident", value: "not", pos });
+      i++;
+      continue;
+    }
+    if (SINGLE_OPS.has(ch)) {
+      tokens.push({ type: "op", value: ch, pos });
+      i++;
+      continue;
+    }
+    throw new ExpressionError(`Unexpected character "${ch}"`, pos, src);
+  }
+  tokens.push({ type: "eof", pos: src.length });
+  return tokens;
+}
+var Parser = class {
+  constructor(tokens, src) {
+    this.tokens = tokens;
+    this.src = src;
+  }
+  tokens;
+  src;
+  i = 0;
+  depth = 0;
+  parse() {
+    const e = this.parsePipe();
+    if (this.peek().type !== "eof") this.fail(`Unexpected "${this.describe(this.peek())}"`);
+    return e;
+  }
+  peek() {
+    return this.tokens[this.i];
+  }
+  next() {
+    return this.tokens[this.i++];
+  }
+  isOp(v) {
+    const t = this.peek();
+    return t.type === "op" && t.value === v;
+  }
+  isKw(v) {
+    const t = this.peek();
+    return t.type === "ident" && t.value === v;
+  }
+  expectOp(v) {
+    if (!this.isOp(v)) this.fail(`Expected "${v}" but found "${this.describe(this.peek())}"`);
+    this.next();
+  }
+  describe(t) {
+    return t.type === "eof" ? "end of expression" : t.type === "str" ? `"${t.value}"` : String(t.value);
+  }
+  fail(msg) {
+    throw new ExpressionError(msg, this.peek().pos, this.src);
+  }
+  enter() {
+    if (++this.depth > MAX_DEPTH) this.fail("Expression is nested too deeply");
+  }
+  leave() {
+    this.depth--;
+  }
+  parsePipe() {
+    let e = this.parseConditional();
+    while (this.isOp("|")) {
+      this.next();
+      const nameTok = this.next();
+      if (nameTok.type !== "ident") this.fail("Expected a formatter name after |");
+      const args = [];
+      while (this.isOp(":")) {
+        this.next();
+        args.push(this.parseConditional());
+      }
+      e = { kind: "pipe", input: e, name: nameTok.value, args };
+    }
+    return e;
+  }
+  parseConditional() {
+    const test = this.parseOr();
+    if (this.isOp("?")) {
+      this.enter();
+      this.next();
+      const then = this.parseConditional();
+      this.expectOp(":");
+      const els = this.parseConditional();
+      this.leave();
+      return { kind: "conditional", test, then, else: els };
+    }
+    return test;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.isKw("or")) {
+      this.next();
+      left = { kind: "binary", op: "or", left, right: this.parseAnd() };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.isKw("and")) {
+      this.next();
+      left = { kind: "binary", op: "and", left, right: this.parseNot() };
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.isKw("not")) {
+      this.enter();
+      this.next();
+      const arg2 = this.parseNot();
+      this.leave();
+      return { kind: "unary", op: "not", arg: arg2 };
+    }
+    return this.parseEquality();
+  }
+  parseEquality() {
+    let left = this.parseComparison();
+    for (; ; ) {
+      if (this.isOp("==") || this.isOp("!=")) {
+        const op = this.next();
+        left = { kind: "binary", op: op.value, left, right: this.parseComparison() };
+      } else if (this.isKw("in")) {
+        this.next();
+        left = { kind: "binary", op: "in", left, right: this.parseComparison() };
+      } else return left;
+    }
+  }
+  parseComparison() {
+    let left = this.parseAdditive();
+    while (this.isOp("<") || this.isOp("<=") || this.isOp(">") || this.isOp(">=")) {
+      const op = this.next();
+      left = { kind: "binary", op: op.value, left, right: this.parseAdditive() };
+    }
+    return left;
+  }
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (this.isOp("+") || this.isOp("-")) {
+      const op = this.next();
+      left = { kind: "binary", op: op.value, left, right: this.parseMultiplicative() };
+    }
+    return left;
+  }
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    while (this.isOp("*") || this.isOp("/") || this.isOp("%")) {
+      const op = this.next();
+      left = { kind: "binary", op: op.value, left, right: this.parseUnary() };
+    }
+    return left;
+  }
+  parseUnary() {
+    if (this.isOp("-")) {
+      this.enter();
+      this.next();
+      const arg2 = this.parseUnary();
+      this.leave();
+      if (arg2.kind === "literal" && typeof arg2.value === "number") return { kind: "literal", value: -arg2.value };
+      return { kind: "unary", op: "-", arg: arg2 };
+    }
+    return this.parsePostfix();
+  }
+  parsePostfix() {
+    let e = this.parsePrimary();
+    for (; ; ) {
+      if (this.isOp(".")) {
+        this.next();
+        const t = this.next();
+        if (t.type !== "ident") this.fail("Expected a property name after .");
+        e = appendSegment(e, { kind: "prop", name: t.value }, () => this.fail("Property access is only allowed on data paths"));
+      } else if (this.isOp("[")) {
+        this.next();
+        const t = this.next();
+        if (t.type !== "num" || !Number.isInteger(t.value) || t.value < 0) this.fail("Index must be a non-negative integer");
+        this.expectOp("]");
+        e = appendSegment(e, { kind: "index", index: t.value }, () => this.fail("Indexing is only allowed on data paths"));
+      } else return e;
+    }
+  }
+  parsePrimary() {
+    const t = this.next();
+    switch (t.type) {
+      case "num":
+        return { kind: "literal", value: t.value };
+      case "str":
+        return { kind: "literal", value: t.value };
+      case "ident": {
+        if (t.value === "true") return { kind: "literal", value: true };
+        if (t.value === "false") return { kind: "literal", value: false };
+        if (t.value === "null") return { kind: "literal", value: null };
+        if (KEYWORDS.has(t.value)) this.fail(`Unexpected keyword "${t.value}"`);
+        if (this.isOp("(")) {
+          this.enter();
+          this.next();
+          const args = [];
+          if (!this.isOp(")")) {
+            args.push(this.parsePipe());
+            while (this.isOp(",")) {
+              this.next();
+              args.push(this.parsePipe());
+            }
+          }
+          this.expectOp(")");
+          this.leave();
+          return { kind: "call", name: t.value, args };
+        }
+        return { kind: "path", segments: [{ kind: "prop", name: t.value }] };
+      }
+      case "op":
+        if (t.value === "(") {
+          this.enter();
+          const e = this.parsePipe();
+          this.expectOp(")");
+          this.leave();
+          return e;
+        }
+        if (t.value === "[") {
+          this.enter();
+          const items = [];
+          if (!this.isOp("]")) {
+            items.push(this.parsePipe());
+            while (this.isOp(",")) {
+              this.next();
+              items.push(this.parsePipe());
+            }
+          }
+          this.expectOp("]");
+          this.leave();
+          return { kind: "array", items };
+        }
+        this.fail(`Unexpected "${t.value}"`);
+      // eslint-disable-next-line no-fallthrough
+      case "eof":
+        this.fail("Unexpected end of expression");
+    }
+  }
+};
+function appendSegment(e, seg, fail) {
+  if (e.kind !== "path") return fail();
+  return { kind: "path", segments: [...e.segments, seg] };
+}
+var cache = /* @__PURE__ */ new Map();
+function parseExpression(src) {
+  const key = src.trim();
+  const hit = cache.get(key);
+  if (hit) return hit;
+  if (key.length === 0) throw new ExpressionError("Expression is empty", 0, src);
+  const ast = new Parser(tokenize(key), key).parse();
+  if (cache.size > 5e3) cache.clear();
+  cache.set(key, ast);
+  return ast;
+}
+function checkExpressionSyntax(src) {
+  try {
+    parseExpression(src);
+    return null;
+  } catch (e) {
+    return e instanceof ExpressionError ? e : new ExpressionError(String(e), 0, src);
+  }
+}
+
+// src/expr/format.ts
+var intlNumberCache = /* @__PURE__ */ new Map();
+var intlDateCache = /* @__PURE__ */ new Map();
+function numberFormat(locale, opts) {
+  const key = locale + JSON.stringify(opts);
+  let f = intlNumberCache.get(key);
+  if (!f) {
+    try {
+      f = new Intl.NumberFormat(locale, opts);
+    } catch {
+      f = new Intl.NumberFormat("en-GB", { ...opts, currency: opts.currency ?? "GBP" });
+    }
+    intlNumberCache.set(key, f);
+  }
+  return f;
+}
+function dateFormat(locale, opts) {
+  const key = locale + JSON.stringify(opts);
+  let f = intlDateCache.get(key);
+  if (!f) {
+    try {
+      f = new Intl.DateTimeFormat(locale, opts);
+    } catch {
+      f = new Intl.DateTimeFormat("en-GB", opts);
+    }
+    intlDateCache.set(key, f);
+  }
+  return f;
+}
+function toNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value.replace(/[,\s]/g, ""));
+    return Number.isFinite(n) ? n : null;
+  }
+  if (typeof value === "boolean") return value ? 1 : 0;
+  return null;
+}
+function toDate(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value === "number") return new Date(value);
+  if (typeof value === "string" && value.trim()) {
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function toDisplayString(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "";
+  if (typeof value === "boolean") return value ? "Yes" : "No";
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map(toDisplayString).join(", ");
+  return "";
+}
+function formatDatePattern(date, pattern, ctx) {
+  const parts = (opts) => {
+    const o = { ...opts };
+    if (ctx.timeZone) o.timeZone = ctx.timeZone;
+    return dateFormat(ctx.locale, o).formatToParts(date);
+  };
+  const get = (opts, type) => parts(opts).find((p) => p.type === type)?.value ?? "";
+  const pad = (s, n) => s.padStart(n, "0");
+  const numeric = parts({ year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "2-digit", second: "2-digit", hour12: false });
+  const num = (type) => numeric.find((p) => p.type === type)?.value ?? "";
+  const hour24 = Number(num("hour")) % 24;
+  const hour12 = hour24 % 12 === 0 ? 12 : hour24 % 12;
+  return pattern.replace(/yyyy|yy|MMMM|MMM|MM|M|dd|d|EEEE|EEE|HH|H|hh|h|mm|ss|a|'[^']*'/g, (tok) => {
+    switch (tok) {
+      case "yyyy":
+        return num("year");
+      case "yy":
+        return num("year").slice(-2);
+      case "MMMM":
+        return get({ month: "long" }, "month");
+      case "MMM":
+        return get({ month: "short" }, "month");
+      case "MM":
+        return pad(num("month"), 2);
+      case "M":
+        return num("month");
+      case "dd":
+        return pad(num("day"), 2);
+      case "d":
+        return num("day");
+      case "EEEE":
+        return get({ weekday: "long" }, "weekday");
+      case "EEE":
+        return get({ weekday: "short" }, "weekday");
+      case "HH":
+        return pad(String(hour24), 2);
+      case "H":
+        return String(hour24);
+      case "hh":
+        return pad(String(hour12), 2);
+      case "h":
+        return String(hour12);
+      case "mm":
+        return pad(num("minute"), 2);
+      case "ss":
+        return pad(num("second"), 2);
+      case "a":
+        return hour24 < 12 ? "AM" : "PM";
+      default:
+        return tok.startsWith("'") ? tok.slice(1, -1) : tok;
+    }
+  });
+}
+var NAMED_DATE_STYLES = {
+  short: { dateStyle: "short" },
+  medium: { dateStyle: "medium" },
+  long: { dateStyle: "long" },
+  full: { dateStyle: "full" }
+};
+function formatDate(value, pattern, ctx, withTime = false) {
+  const d = toDate(value);
+  if (!d) return toDisplayString(value);
+  if (pattern && NAMED_DATE_STYLES[pattern]) {
+    const opts2 = { ...NAMED_DATE_STYLES[pattern] };
+    if (withTime) opts2.timeStyle = "short";
+    if (ctx.timeZone) opts2.timeZone = ctx.timeZone;
+    return dateFormat(ctx.locale, opts2).format(d);
+  }
+  if (pattern) return formatDatePattern(d, pattern, ctx);
+  const opts = withTime ? { dateStyle: "medium", timeStyle: "short" } : { dateStyle: "medium" };
+  if (ctx.timeZone) opts.timeZone = ctx.timeZone;
+  return dateFormat(ctx.locale, opts).format(d);
+}
+function formatCurrency(value, currency, decimals, ctx) {
+  const n = toNumber(value);
+  if (n === null) return toDisplayString(value);
+  const code = currency && String(currency).toUpperCase() || ctx.currency;
+  const opts = { style: "currency", currency: code };
+  if (decimals !== void 0) {
+    opts.minimumFractionDigits = decimals;
+    opts.maximumFractionDigits = decimals;
+  }
+  return numberFormat(ctx.locale, opts).format(n);
+}
+function formatNumber(value, decimals, ctx) {
+  const n = toNumber(value);
+  if (n === null) return toDisplayString(value);
+  const opts = {};
+  if (decimals !== void 0) {
+    opts.minimumFractionDigits = decimals;
+    opts.maximumFractionDigits = decimals;
+  } else opts.maximumFractionDigits = 2;
+  return numberFormat(ctx.locale, opts).format(n);
+}
+function formatPercent(value, decimals, ctx, alreadyScaled = false) {
+  const n = toNumber(value);
+  if (n === null) return toDisplayString(value);
+  const opts = { style: "percent" };
+  const d = decimals ?? 1;
+  opts.minimumFractionDigits = d;
+  opts.maximumFractionDigits = d;
+  return numberFormat(ctx.locale, opts).format(alreadyScaled ? n / 100 : n);
+}
+function arg(args, i) {
+  return args[i];
+}
+var PIPES = {
+  currency: {
+    name: "currency",
+    description: "Format as money",
+    returns: "string",
+    accepts: ["number", "currency"],
+    args: [
+      { name: "code", type: "string", optional: true, description: "ISO currency code, e.g. GBP" },
+      { name: "decimals", type: "number", optional: true }
+    ],
+    fn: (v, a, ctx) => formatCurrency(v, arg(a, 0), toNumber(a[1]) ?? void 0, ctx)
+  },
+  number: {
+    name: "number",
+    description: "Format with thousands separators",
+    returns: "string",
+    accepts: ["number"],
+    args: [{ name: "decimals", type: "number", optional: true }],
+    fn: (v, a, ctx) => formatNumber(v, toNumber(a[0]) ?? void 0, ctx)
+  },
+  percent: {
+    name: "percent",
+    description: "Format a fraction (0.25) as a percentage (25%)",
+    returns: "string",
+    accepts: ["number", "percent"],
+    args: [
+      { name: "decimals", type: "number", optional: true },
+      { name: "scaled", type: "boolean", optional: true, description: "Set true when the value is already 0\u2013100" }
+    ],
+    fn: (v, a, ctx) => formatPercent(v, toNumber(a[0]) ?? void 0, ctx, a[1] === true)
+  },
+  date: {
+    name: "date",
+    description: "Format a date",
+    returns: "string",
+    accepts: ["date", "datetime"],
+    args: [{ name: "pattern", type: "string", optional: true, description: "e.g. dd MMM yyyy, or short/medium/long/full" }],
+    fn: (v, a, ctx) => formatDate(v, arg(a, 0), ctx, false)
+  },
+  datetime: {
+    name: "datetime",
+    description: "Format a date with time",
+    returns: "string",
+    accepts: ["date", "datetime"],
+    args: [{ name: "pattern", type: "string", optional: true }],
+    fn: (v, a, ctx) => formatDate(v, arg(a, 0), ctx, true)
+  },
+  boolean: {
+    name: "boolean",
+    description: "Show a boolean as text",
+    returns: "string",
+    accepts: ["boolean"],
+    args: [
+      { name: "yes", type: "string", optional: true },
+      { name: "no", type: "string", optional: true }
+    ],
+    fn: (v, a) => v === true || v === "true" || v === 1 ? arg(a, 0) ?? "Yes" : arg(a, 1) ?? "No"
+  },
+  upper: { name: "upper", description: "UPPERCASE", returns: "string", fn: (v) => toDisplayString(v).toUpperCase() },
+  lower: { name: "lower", description: "lowercase", returns: "string", fn: (v) => toDisplayString(v).toLowerCase() },
+  title: {
+    name: "title",
+    description: "Title Case",
+    returns: "string",
+    fn: (v) => toDisplayString(v).replace(/\b\p{L}/gu, (c) => c.toUpperCase())
+  },
+  default: {
+    name: "default",
+    description: "Fallback when the value is empty",
+    returns: "same",
+    args: [{ name: "fallback", type: "any" }],
+    fn: (v, a) => isEmptyValue(v) ? a[0] : v
+  },
+  join: {
+    name: "join",
+    description: "Join a list into text",
+    returns: "string",
+    accepts: ["array"],
+    args: [{ name: "separator", type: "string", optional: true }],
+    fn: (v, a) => Array.isArray(v) ? v.map(toDisplayString).join(arg(a, 0) ?? ", ") : toDisplayString(v)
+  },
+  truncate: {
+    name: "truncate",
+    description: "Limit length with an ellipsis",
+    returns: "string",
+    args: [{ name: "length", type: "number" }],
+    fn: (v, a) => {
+      const s = toDisplayString(v);
+      const n = toNumber(a[0]) ?? 50;
+      return s.length > n ? s.slice(0, Math.max(0, n - 1)).trimEnd() + "\u2026" : s;
+    }
+  },
+  round: {
+    name: "round",
+    description: "Round to N decimals",
+    returns: "number",
+    accepts: ["number"],
+    args: [{ name: "decimals", type: "number", optional: true }],
+    fn: (v, a) => {
+      const n = toNumber(v);
+      if (n === null) return v;
+      const d = toNumber(a[0]) ?? 0;
+      const m = 10 ** d;
+      return Math.round(n * m) / m;
+    }
+  },
+  abs: { name: "abs", description: "Absolute value", returns: "number", accepts: ["number"], fn: (v) => toNumber(v) === null ? v : Math.abs(toNumber(v)) },
+  pluralize: {
+    name: "pluralize",
+    description: "Choose singular/plural word by count",
+    returns: "string",
+    args: [
+      { name: "singular", type: "string" },
+      { name: "plural", type: "string" }
+    ],
+    fn: (v, a) => toNumber(v) === 1 ? arg(a, 0) ?? "" : arg(a, 1) ?? `${arg(a, 0) ?? ""}s`
+  },
+  length: { name: "length", description: "Number of items or characters", returns: "number", fn: (v) => Array.isArray(v) ? v.length : toDisplayString(v).length },
+  first: { name: "first", description: "First item", returns: "same", accepts: ["array"], fn: (v) => Array.isArray(v) ? v[0] : v },
+  last: { name: "last", description: "Last item", returns: "same", accepts: ["array"], fn: (v) => Array.isArray(v) ? v[v.length - 1] : v },
+  sortBy: {
+    name: "sortBy",
+    description: "Sort a list by a field",
+    returns: "array",
+    accepts: ["array"],
+    args: [
+      { name: "field", type: "string" },
+      { name: "direction", type: "string", optional: true, description: "asc or desc" }
+    ],
+    fn: (v, a) => {
+      if (!Array.isArray(v)) return v;
+      const field = arg(a, 0) ?? "";
+      const dir = (arg(a, 1) ?? "asc").toLowerCase() === "desc" ? -1 : 1;
+      return [...v].sort((x, y) => compareValues(getField(x, field), getField(y, field)) * dir);
+    }
+  },
+  take: {
+    name: "take",
+    description: "First N items",
+    returns: "array",
+    accepts: ["array"],
+    args: [{ name: "count", type: "number" }],
+    fn: (v, a) => Array.isArray(v) ? v.slice(0, Math.max(0, toNumber(a[0]) ?? 0)) : v
+  },
+  filter: {
+    name: "filter",
+    description: "Keep items whose field equals a value",
+    returns: "array",
+    accepts: ["array"],
+    args: [
+      { name: "field", type: "string" },
+      { name: "value", type: "any" }
+    ],
+    fn: (v, a) => Array.isArray(v) ? v.filter((x) => looseEquals(getField(x, arg(a, 0) ?? ""), a[1])) : v
+  },
+  pluck: {
+    name: "pluck",
+    description: "Extract one field from each item",
+    returns: "array",
+    accepts: ["array"],
+    args: [{ name: "field", type: "string" }],
+    fn: (v, a) => Array.isArray(v) ? v.map((x) => getField(x, arg(a, 0) ?? "")) : getField(v, arg(a, 0) ?? "")
+  },
+  initials: {
+    name: "initials",
+    description: "Initials of a name",
+    returns: "string",
+    fn: (v) => toDisplayString(v).split(/\s+/).filter(Boolean).map((w) => w[0].toUpperCase()).join("")
+  }
+};
+function getField(obj, path) {
+  if (obj === null || obj === void 0) return void 0;
+  let cur = obj;
+  for (const part of path.split(".")) {
+    if (!part) continue;
+    if (cur === null || cur === void 0 || typeof cur !== "object") return void 0;
+    if (!Object.prototype.hasOwnProperty.call(cur, part)) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function compareValues(a, b) {
+  const na = toNumber(a);
+  const nb = toNumber(b);
+  if (na !== null && nb !== null && typeof a !== "string" && typeof b !== "string") return na - nb;
+  const da = toDate(a);
+  const db = toDate(b);
+  if (da && db && (a instanceof Date || typeof a === "string") && (b instanceof Date || typeof b === "string") && /\d{4}-\d{2}/.test(String(a))) return da.getTime() - db.getTime();
+  const sa = toDisplayString(a);
+  const sb = toDisplayString(b);
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+function looseEquals(a, b) {
+  if (a === b) return true;
+  if (a === null || a === void 0 || b === null || b === void 0) return (a ?? null) === (b ?? null);
+  if (typeof a === "number" || typeof b === "number") {
+    const na = toNumber(a);
+    const nb = toNumber(b);
+    if (na !== null && nb !== null) return na === nb;
+  }
+  if (typeof a === "boolean" || typeof b === "boolean") return String(a) === String(b);
+  return toDisplayString(a) === toDisplayString(b);
+}
+
+// src/expr/evaluate.ts
+var Scope = class _Scope {
+  constructor(vars, parent) {
+    this.vars = vars;
+    this.parent = parent;
+  }
+  vars;
+  parent;
+  lookup(name) {
+    if (Object.prototype.hasOwnProperty.call(this.vars, name)) return { found: true, value: this.vars[name] };
+    if (this.parent) return this.parent.lookup(name);
+    return { found: false, value: void 0 };
+  }
+  child(vars) {
+    return new _Scope(vars, this);
+  }
+  /** Names visible in this scope (innermost first, deduplicated). */
+  names() {
+    const out = [];
+    let s = this;
+    while (s) {
+      for (const k of Object.keys(s.vars)) if (!out.includes(k)) out.push(k);
+      s = s.parent;
+    }
+    return out;
+  }
+};
+var FUNCTIONS = {
+  sum: ([list]) => numbers(list).reduce((a, b) => a + b, 0),
+  count: ([list]) => Array.isArray(list) ? list.length : isEmptyValue(list) ? 0 : 1,
+  avg: ([list]) => {
+    const ns = numbers(list);
+    return ns.length ? ns.reduce((a, b) => a + b, 0) / ns.length : null;
+  },
+  min: ([list, ...rest]) => {
+    const ns = rest.length ? numbers([list, ...rest]) : numbers(list);
+    return ns.length ? Math.min(...ns) : null;
+  },
+  max: ([list, ...rest]) => {
+    const ns = rest.length ? numbers([list, ...rest]) : numbers(list);
+    return ns.length ? Math.max(...ns) : null;
+  },
+  first: ([list]) => Array.isArray(list) ? list[0] : list,
+  last: ([list]) => Array.isArray(list) ? list[list.length - 1] : list,
+  length: ([v]) => Array.isArray(v) ? v.length : toDisplayString(v).length,
+  coalesce: (args) => args.find((a) => !isEmptyValue(a)) ?? null,
+  isEmpty: ([v]) => isEmptyValue(v),
+  isNotEmpty: ([v]) => !isEmptyValue(v),
+  contains: ([hay, needle]) => Array.isArray(hay) ? hay.some((x) => looseEquals(x, needle)) : toDisplayString(hay).toLowerCase().includes(toDisplayString(needle).toLowerCase()),
+  startsWith: ([s, p]) => toDisplayString(s).toLowerCase().startsWith(toDisplayString(p).toLowerCase()),
+  endsWith: ([s, p]) => toDisplayString(s).toLowerCase().endsWith(toDisplayString(p).toLowerCase()),
+  concat: (args) => args.map(toDisplayString).join(""),
+  round: ([v, d]) => {
+    const n = toNumber(v);
+    if (n === null) return null;
+    const m = 10 ** (toNumber(d) ?? 0);
+    return Math.round(n * m) / m;
+  },
+  abs: ([v]) => {
+    const n = toNumber(v);
+    return n === null ? null : Math.abs(n);
+  },
+  number: ([v]) => toNumber(v),
+  string: ([v]) => toDisplayString(v),
+  if: ([c, a, b]) => truthy(c) ? a : b,
+  now: (_args, ctx) => ctx.format.now ?? /* @__PURE__ */ new Date(),
+  year: ([v]) => dateOf(v)?.getFullYear() ?? null,
+  daysBetween: ([a, b]) => {
+    const da = dateOf(a);
+    const db = dateOf(b);
+    return da && db ? Math.round((db.getTime() - da.getTime()) / 864e5) : null;
+  }
+};
+var FUNCTION_NAMES = Object.keys(FUNCTIONS);
+function dateOf(v) {
+  if (v instanceof Date) return v;
+  if (typeof v === "string" || typeof v === "number") {
+    const d = new Date(v);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+function numbers(list) {
+  if (!Array.isArray(list)) {
+    const n = toNumber(list);
+    return n === null ? [] : [n];
+  }
+  const out = [];
+  for (const v of list) {
+    const n = toNumber(v);
+    if (n !== null) out.push(n);
+  }
+  return out;
+}
+function truthy(v) {
+  if (v === null || v === void 0 || v === false || v === 0 || v === "") return false;
+  if (typeof v === "string") return !["false", "no", "0", "off"].includes(v.trim().toLowerCase());
+  if (Array.isArray(v)) return v.length > 0;
+  return true;
+}
+function readProperty(obj, name) {
+  if (obj === null || obj === void 0) return void 0;
+  if (typeof obj === "string" && name === "length") return obj.length;
+  if (typeof obj !== "object") return void 0;
+  if (Array.isArray(obj)) {
+    if (name === "length") return obj.length;
+    const projected = obj.map((x) => readProperty(x, name));
+    return projected.every((v2) => v2 === void 0) ? void 0 : projected;
+  }
+  if (!Object.prototype.hasOwnProperty.call(obj, name)) return void 0;
+  const v = obj[name];
+  return typeof v === "function" ? void 0 : v;
+}
+function resolvePath(segments, scope) {
+  const first = segments[0];
+  if (!first || first.kind !== "prop") return { found: false, value: void 0 };
+  const root = scope.lookup(first.name);
+  if (!root.found) return { found: false, value: void 0 };
+  let cur = root.value;
+  for (let i = 1; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.kind === "prop") cur = readProperty(cur, seg.name);
+    else cur = Array.isArray(cur) ? cur[seg.index] : void 0;
+    if (cur === void 0) return { found: true, value: void 0 };
+  }
+  return { found: true, value: cur };
+}
+function evaluateAst(e, ctx) {
+  switch (e.kind) {
+    case "literal":
+      return e.value;
+    case "path": {
+      const r = resolvePath(e.segments, ctx.scope);
+      return r.value;
+    }
+    case "unary": {
+      const v = evaluateAst(e.arg, ctx);
+      if (e.op === "not") return !truthy(v);
+      const n = toNumber(v);
+      return n === null ? null : -n;
+    }
+    case "binary":
+      return evaluateBinary(e.op, e.left, e.right, ctx);
+    case "conditional":
+      return truthy(evaluateAst(e.test, ctx)) ? evaluateAst(e.then, ctx) : evaluateAst(e.else, ctx);
+    case "call": {
+      const fn = FUNCTIONS[e.name];
+      if (!fn) {
+        ctx.onWarning?.(`Unknown function "${e.name}"`);
+        return null;
+      }
+      return fn(
+        e.args.map((a) => evaluateAst(a, ctx)),
+        ctx
+      );
+    }
+    case "pipe": {
+      const input = evaluateAst(e.input, ctx);
+      const pipe = PIPES[e.name];
+      if (!pipe) {
+        ctx.onWarning?.(`Unknown formatter "${e.name}"`);
+        return input;
+      }
+      return pipe.fn(
+        input,
+        e.args.map((a) => evaluateAst(a, ctx)),
+        ctx.format
+      );
+    }
+    case "array":
+      return e.items.map((i) => evaluateAst(i, ctx));
+  }
+}
+function evaluateBinary(op, leftE, rightE, ctx) {
+  if (op === "and") return truthy(evaluateAst(leftE, ctx)) ? truthy(evaluateAst(rightE, ctx)) : false;
+  if (op === "or") return truthy(evaluateAst(leftE, ctx)) ? true : truthy(evaluateAst(rightE, ctx));
+  const l = evaluateAst(leftE, ctx);
+  const r = evaluateAst(rightE, ctx);
+  switch (op) {
+    case "==":
+      return looseEquals(l, r);
+    case "!=":
+      return !looseEquals(l, r);
+    case "<":
+      return compareOrNull(l, r, (c) => c < 0);
+    case "<=":
+      return compareOrNull(l, r, (c) => c <= 0);
+    case ">":
+      return compareOrNull(l, r, (c) => c > 0);
+    case ">=":
+      return compareOrNull(l, r, (c) => c >= 0);
+    case "in":
+      return Array.isArray(r) ? r.some((x) => looseEquals(x, l)) : toDisplayString(r).includes(toDisplayString(l));
+    case "+": {
+      const nl = toNumber(l);
+      const nr = toNumber(r);
+      if (nl !== null && nr !== null && typeof l !== "string" && typeof r !== "string") return nl + nr;
+      if (typeof l === "string" || typeof r === "string") return toDisplayString(l) + toDisplayString(r);
+      return nl !== null && nr !== null ? nl + nr : null;
+    }
+    case "-":
+    case "*":
+    case "/":
+    case "%": {
+      const nl = toNumber(l);
+      const nr = toNumber(r);
+      if (nl === null || nr === null) return null;
+      if (op === "-") return nl - nr;
+      if (op === "*") return nl * nr;
+      if (op === "/") return nr === 0 ? null : nl / nr;
+      return nr === 0 ? null : nl % nr;
+    }
+  }
+  return null;
+}
+function compareOrNull(l, r, test) {
+  if (l === null || l === void 0 || r === null || r === void 0) return false;
+  return test(compareValues(l, r));
+}
+function evaluate(src, ctx) {
+  return evaluateAst(parseExpression(src), ctx);
+}
+function evaluateCondition(src, ctx) {
+  return truthy(evaluate(src, ctx));
+}
+function evaluateText(src, ctx) {
+  return toDisplayString(evaluate(src, ctx));
+}
+function splitTemplate(template) {
+  const out = [];
+  const re = /\{\{\s*([^}]+?)\s*\}\}/g;
+  let last = 0;
+  let m;
+  while (m = re.exec(template)) {
+    if (m.index > last) out.push({ kind: "text", text: template.slice(last, m.index) });
+    out.push({ kind: "token", text: m[0], expr: m[1] });
+    last = m.index + m[0].length;
+  }
+  if (last < template.length) out.push({ kind: "text", text: template.slice(last) });
+  return out;
+}
+function interpolate(template, ctx) {
+  if (!template.includes("{{")) return template;
+  return splitTemplate(template).map((s) => {
+    if (s.kind === "text") return s.text;
+    try {
+      return evaluateText(s.expr, ctx);
+    } catch {
+      ctx.onWarning?.(`Invalid expression "${s.expr}"`, s.expr);
+      return "";
+    }
+  }).join("");
+}
+
+// src/expr/typecheck.ts
+var SchemaScope = class _SchemaScope {
+  constructor(vars, parent) {
+    this.vars = vars;
+    this.parent = parent;
+  }
+  vars;
+  parent;
+  lookup(name) {
+    if (Object.prototype.hasOwnProperty.call(this.vars, name)) return this.vars[name];
+    return this.parent?.lookup(name);
+  }
+  child(vars) {
+    return new _SchemaScope(vars, this);
+  }
+  entries() {
+    const out = [];
+    let s = this;
+    let depth = 0;
+    while (s) {
+      for (const [name, schema] of Object.entries(s.vars)) if (!out.some((e) => e.name === name)) out.push({ name, schema, depth });
+      s = s.parent;
+      depth++;
+    }
+    return out;
+  }
+};
+var GLOBAL_SCHEMAS = {
+  page: {
+    type: "object",
+    label: "Page",
+    fields: {
+      number: { type: "number", label: "Page number" },
+      total: { type: "number", label: "Total pages" }
+    }
+  },
+  now: { type: "datetime", label: "Generated at" },
+  theme: {
+    type: "object",
+    label: "Theme",
+    fields: {
+      name: { type: "string", label: "Theme name" },
+      logo: { type: "image", label: "Logo" },
+      colors: { type: "object", label: "Colours", fields: {} },
+      typography: { type: "object", label: "Typography", fields: {} },
+      meta: { type: "object", label: "Brand details", fields: {} }
+    }
+  }
+};
+function dataSourceSchemas(sources) {
+  const out = {};
+  for (const s of sources) out[s.id] = { type: "object", label: s.label, description: s.description, fields: s.schema };
+  return out;
+}
+function createSchemaScope(sources, extraGlobals = {}) {
+  return new SchemaScope({ ...GLOBAL_SCHEMAS, ...extraGlobals }).child(dataSourceSchemas(sources));
+}
+function resolvePathSchema(segments, scope) {
+  const first = segments[0];
+  if (!first || first.kind !== "prop") return { issue: { code: "unknown-root", message: "Expression must start with a name" } };
+  const root = scope.lookup(first.name);
+  if (!root) return { issue: { code: "unknown-root", message: `Unknown data source or variable "${first.name}"` } };
+  let cur = root;
+  let projected = false;
+  for (let i = 1; i < segments.length; i++) {
+    const seg = segments[i];
+    const soFar = pathToString(segments.slice(0, i));
+    if (seg.kind === "index") {
+      if (cur.type !== "array") return { issue: { code: "not-a-list", message: `"${soFar}" is not a list and cannot be indexed` } };
+      cur = cur.itemSchema ?? { type: "any" };
+      continue;
+    }
+    if (cur.type === "array") {
+      if (!cur.itemSchema) return { schema: { type: "array" } };
+      if (cur.itemSchema.type !== "object" || !cur.itemSchema.fields) return { issue: { code: "not-an-object", message: `Items of "${soFar}" have no field "${seg.name}"` } };
+      const f2 = cur.itemSchema.fields[seg.name];
+      if (!f2) return { issue: { code: "unknown-field", message: `Items of "${soFar}" have no field "${seg.name}"` } };
+      projected = true;
+      cur = { type: "array", itemSchema: f2, label: f2.label };
+      continue;
+    }
+    if (cur.type === "any") return { schema: { type: "any" } };
+    if (cur.type !== "object") return { issue: { code: "not-an-object", message: `"${soFar}" is a ${cur.type} and has no field "${seg.name}"` } };
+    if (cur.fields && Object.keys(cur.fields).length === 0 && ["colors", "typography", "meta"].includes(segments[i - 1].kind === "prop" ? segments[i - 1].name : "")) {
+      return { schema: { type: "string" } };
+    }
+    const f = cur.fields?.[seg.name];
+    if (!f) return { issue: { code: "unknown-field", message: `"${soFar}" has no field "${seg.name}"` } };
+    cur = f;
+  }
+  void projected;
+  return { schema: cur };
+}
+function typeOfSchema(s) {
+  return s?.type ?? "unknown";
+}
+function typeCheckAst(e, scope) {
+  const issues = [];
+  const type = check(e, scope, issues);
+  return { type: type.type, schema: type.schema, issues };
+}
+function check(e, scope, issues) {
+  switch (e.kind) {
+    case "literal":
+      return { type: e.value === null ? "null" : typeof e.value };
+    case "path": {
+      const r = resolvePathSchema(e.segments, scope);
+      if (r.issue) {
+        issues.push(r.issue);
+        return { type: "unknown" };
+      }
+      return { type: typeOfSchema(r.schema), schema: r.schema };
+    }
+    case "unary": {
+      const t = check(e.arg, scope, issues);
+      return { type: e.op === "not" ? "boolean" : t.type === "unknown" ? "unknown" : "number" };
+    }
+    case "binary": {
+      const l = check(e.left, scope, issues);
+      const r = check(e.right, scope, issues);
+      switch (e.op) {
+        case "and":
+        case "or":
+        case "==":
+        case "!=":
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+        case "in":
+          return { type: "boolean" };
+        case "+":
+          return { type: l.type === "string" || r.type === "string" ? "string" : "number" };
+        default:
+          return { type: "number" };
+      }
+    }
+    case "conditional": {
+      check(e.test, scope, issues);
+      const a = check(e.then, scope, issues);
+      check(e.else, scope, issues);
+      return a;
+    }
+    case "call": {
+      if (!FUNCTION_NAMES.includes(e.name)) issues.push({ code: "unknown-function", message: `Unknown function "${e.name}"` });
+      for (const a of e.args) check(a, scope, issues);
+      const numeric = ["sum", "count", "avg", "min", "max", "length", "round", "abs", "number", "year", "daysBetween"];
+      if (numeric.includes(e.name)) return { type: "number" };
+      if (["isEmpty", "isNotEmpty", "contains", "startsWith", "endsWith"].includes(e.name)) return { type: "boolean" };
+      if (["concat", "string"].includes(e.name)) return { type: "string" };
+      if (e.name === "now") return { type: "datetime" };
+      if (["first", "last"].includes(e.name) && e.args[0]) {
+        const t = check(e.args[0], scope, issues);
+        return t.schema?.type === "array" ? { type: typeOfSchema(t.schema.itemSchema), schema: t.schema.itemSchema } : t;
+      }
+      return { type: "any" };
+    }
+    case "pipe": {
+      const input = check(e.input, scope, issues);
+      for (const a of e.args) check(a, scope, issues);
+      const def = PIPES[e.name];
+      if (!def) {
+        issues.push({ code: "unknown-pipe", message: `Unknown formatter "${e.name}"` });
+        return input;
+      }
+      if (def.returns === "same") return input;
+      if (def.returns === "array") return { type: "array", schema: input.schema?.type === "array" ? input.schema : void 0 };
+      if (def.accepts && input.type !== "unknown" && input.type !== "any" && input.type !== "null" && !def.accepts.includes(input.type)) {
+        const compat = def.accepts.includes("number") && (input.type === "currency" || input.type === "percent") || def.accepts.includes("array") && input.type === "array";
+        if (!compat) issues.push({ code: "type-mismatch", message: `Formatter "${e.name}" expects ${def.accepts.join(" or ")} but received ${input.type}` });
+      }
+      return { type: def.returns };
+    }
+    case "array":
+      for (const i of e.items) check(i, scope, issues);
+      return { type: "array" };
+  }
+}
+function typeCheck(src, scope) {
+  try {
+    return typeCheckAst(parseExpression(src), scope);
+  } catch (err) {
+    const pos = err instanceof ExpressionError ? err.position : void 0;
+    return { type: "unknown", issues: [{ code: "syntax", message: err.message, position: pos }] };
+  }
+}
+
+// src/expr/condition.ts
+function compileCondition(condition) {
+  if (condition === void 0 || condition === null) return null;
+  if (typeof condition === "string") return condition.trim() || null;
+  const src = compileGroup(condition);
+  return src || null;
+}
+function compileGroup(group) {
+  const parts = group.rules.map((r) => "op" in r ? compileGroup(r) : compileRule(r)).filter((s) => !!s);
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  return parts.map((p) => `(${p})`).join(group.op === "and" ? " and " : " or ");
+}
+function literal(v) {
+  if (v === null || v === void 0) return "null";
+  if (typeof v === "string") {
+    const m = /^\{\{\s*(.+?)\s*\}\}$/.exec(v);
+    if (m) return m[1];
+    return JSON.stringify(v);
+  }
+  return String(v);
+}
+function compileRule(rule) {
+  const left = rule.left.trim();
+  if (!left) return "";
+  switch (rule.operator) {
+    case "eq":
+      return `${left} == ${literal(rule.right)}`;
+    case "neq":
+      return `${left} != ${literal(rule.right)}`;
+    case "gt":
+      return `${left} > ${literal(rule.right)}`;
+    case "gte":
+      return `${left} >= ${literal(rule.right)}`;
+    case "lt":
+      return `${left} < ${literal(rule.right)}`;
+    case "lte":
+      return `${left} <= ${literal(rule.right)}`;
+    case "contains":
+      return `contains(${left}, ${literal(rule.right)})`;
+    case "startsWith":
+      return `startsWith(${left}, ${literal(rule.right)})`;
+    case "endsWith":
+      return `endsWith(${left}, ${literal(rule.right)})`;
+    case "in":
+      return `${left} in ${Array.isArray(rule.right) ? JSON.stringify(rule.right) : literal(rule.right)}`;
+    case "isEmpty":
+      return `isEmpty(${left})`;
+    case "isNotEmpty":
+      return `isNotEmpty(${left})`;
+    case "isTrue":
+      return `${left} == true`;
+    case "isFalse":
+      return `not ${left}`;
+  }
+}
+var CONDITION_OPERATORS = [
+  { value: "eq", label: "equals", needsValue: true },
+  { value: "neq", label: "does not equal", needsValue: true },
+  { value: "gt", label: "is greater than", needsValue: true, types: ["number", "currency", "percent", "date", "datetime"] },
+  { value: "gte", label: "is at least", needsValue: true, types: ["number", "currency", "percent", "date", "datetime"] },
+  { value: "lt", label: "is less than", needsValue: true, types: ["number", "currency", "percent", "date", "datetime"] },
+  { value: "lte", label: "is at most", needsValue: true, types: ["number", "currency", "percent", "date", "datetime"] },
+  { value: "contains", label: "contains", needsValue: true, types: ["string", "array"] },
+  { value: "startsWith", label: "starts with", needsValue: true, types: ["string"] },
+  { value: "endsWith", label: "ends with", needsValue: true, types: ["string"] },
+  { value: "isEmpty", label: "is empty", needsValue: false },
+  { value: "isNotEmpty", label: "is not empty", needsValue: false },
+  { value: "isTrue", label: "is true", needsValue: false, types: ["boolean"] },
+  { value: "isFalse", label: "is false", needsValue: false, types: ["boolean"] }
+];
+
+// src/theme/default-theme.ts
+var DEFAULT_THEME = {
+  id: "default",
+  name: "Default",
+  typography: {
+    headingFont: "Inter, system-ui, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif",
+    bodyFont: "Inter, system-ui, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif",
+    monoFont: "'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+    baseFontSize: 11,
+    headingScale: 1.25,
+    headingWeight: 600,
+    bodyWeight: 400,
+    lineHeight: 1.5,
+    headingLetterSpacing: -0.01
+  },
+  colors: {
+    primary: "#1F3A5F",
+    secondary: "#4A6FA5",
+    accent: "#E0B04B",
+    text: "#1A1D21",
+    mutedText: "#6B7280",
+    surface: "#FFFFFF",
+    background: "#F5F6F8",
+    border: "#E2E5EA",
+    success: "#1E8E5A",
+    warning: "#C77D0A",
+    danger: "#C0392B",
+    chart: ["#1F3A5F", "#4A6FA5", "#E0B04B", "#7FB3D5", "#A9CCE3", "#F4D03F", "#6C7A89", "#B0BEC5"]
+  },
+  radius: 6,
+  table: {
+    headerBackground: "#F3F4F6",
+    headerColor: "#1A1D21",
+    zebraBackground: "#FAFAFB",
+    borderColor: "#E2E5EA"
+  }
+};
+function defaultDocumentStyles() {
+  return {
+    text: {
+      h1: { fontFamily: "$typography.headingFont", fontSize: 26, fontWeight: 600, lineHeight: 1.2, letterSpacing: -0.02, color: "$colors.primary", marginTop: 0, marginBottom: 8, keepWithNext: true },
+      h2: { fontFamily: "$typography.headingFont", fontSize: 18, fontWeight: 600, lineHeight: 1.25, letterSpacing: -0.01, color: "$colors.primary", marginTop: 12, marginBottom: 6, keepWithNext: true },
+      h3: { fontFamily: "$typography.headingFont", fontSize: 14, fontWeight: 600, lineHeight: 1.3, color: "$colors.text", marginTop: 8, marginBottom: 4, keepWithNext: true },
+      h4: { fontFamily: "$typography.headingFont", fontSize: 12, fontWeight: 600, lineHeight: 1.35, color: "$colors.text", textTransform: "uppercase", letterSpacing: 0.04, marginTop: 8, marginBottom: 4, keepWithNext: true },
+      body: { fontFamily: "$typography.bodyFont", fontSize: 11, fontWeight: 400, lineHeight: 1.5, color: "$colors.text", marginTop: 0, marginBottom: 0 },
+      lead: { fontFamily: "$typography.bodyFont", fontSize: 13, fontWeight: 400, lineHeight: 1.55, color: "$colors.text", marginTop: 0, marginBottom: 0 },
+      caption: { fontFamily: "$typography.bodyFont", fontSize: 9, fontWeight: 400, lineHeight: 1.4, color: "$colors.mutedText", marginTop: 0, marginBottom: 0 },
+      small: { fontFamily: "$typography.bodyFont", fontSize: 8, fontWeight: 400, lineHeight: 1.4, color: "$colors.mutedText", marginTop: 0, marginBottom: 0 }
+    },
+    table: {
+      fontSize: 10,
+      headerBackground: "$table.headerBackground",
+      headerColor: "$table.headerColor",
+      headerFontWeight: 600,
+      borderColor: "$table.borderColor",
+      borderWidth: 1,
+      borders: "horizontal",
+      zebraBackground: "$table.zebraBackground",
+      cellPaddingX: 8,
+      cellPaddingY: 6
+    },
+    card: {
+      background: "$colors.surface",
+      borderColor: "$colors.border",
+      borderWidth: 1,
+      borderRadius: 6,
+      padding: 16,
+      shadow: false
+    },
+    link: { color: "$colors.secondary", underline: true },
+    spacing: { blockGap: 8, sectionPadding: 0, columnGap: 16 }
+  };
+}
+
+// src/theme/tokens.ts
+function isTokenRef(value) {
+  return typeof value === "string" && value.startsWith("$") && value.length > 1;
+}
+function resolveToken(token, theme) {
+  const path = token.slice(1).split(".");
+  const fromTheme = walk(theme, path);
+  if (typeof fromTheme === "string") return fromTheme;
+  const fromDefault = walk(DEFAULT_THEME, path);
+  return typeof fromDefault === "string" ? fromDefault : void 0;
+}
+function walk(obj, path) {
+  let cur = obj;
+  for (const p of path) {
+    if (cur === null || cur === void 0 || typeof cur !== "object") return void 0;
+    if (!Object.prototype.hasOwnProperty.call(cur, p)) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function resolveValue(value, theme, fallback) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (isTokenRef(value)) return resolveToken(value, theme) ?? fallback;
+  return value;
+}
+function listThemeTokens(theme) {
+  const merged = mergeTheme(theme);
+  const out = [];
+  for (const [k, v] of Object.entries(merged.colors)) if (typeof v === "string") out.push({ token: `$colors.${k}`, label: humanize(k), value: v, group: "colors" });
+  for (const [k, v] of Object.entries(merged.typography)) if (typeof v === "string") out.push({ token: `$typography.${k}`, label: humanize(k), value: v, group: "typography" });
+  for (const [k, v] of Object.entries(merged.table ?? {})) if (typeof v === "string") out.push({ token: `$table.${k}`, label: humanize(k), value: v, group: "table" });
+  if (merged.logo) out.push({ token: "$logo", label: "Logo", value: merged.logo, group: "brand" });
+  if (merged.logoDark) out.push({ token: "$logoDark", label: "Logo (dark)", value: merged.logoDark, group: "brand" });
+  return out;
+}
+function humanize(key) {
+  return key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+}
+function mergeTheme(theme) {
+  if (!theme) return DEFAULT_THEME;
+  return {
+    ...DEFAULT_THEME,
+    ...theme,
+    typography: { ...DEFAULT_THEME.typography, ...theme.typography ?? {} },
+    colors: { ...DEFAULT_THEME.colors, ...theme.colors ?? {}, chart: theme.colors?.chart?.length ? theme.colors.chart : DEFAULT_THEME.colors.chart },
+    table: { ...DEFAULT_THEME.table, ...theme.table ?? {} },
+    fonts: theme.fonts ?? [],
+    meta: theme.meta ?? {}
+  };
+}
+function missingThemeValues(theme) {
+  const missing = [];
+  const required = ["primary", "secondary", "accent", "text", "mutedText", "surface", "background", "border"];
+  for (const k of required) if (!theme.colors?.[k]) missing.push(`colors.${k}`);
+  if (!theme.typography?.headingFont) missing.push("typography.headingFont");
+  if (!theme.typography?.bodyFont) missing.push("typography.bodyFont");
+  return missing;
+}
+function isDarkColor(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return false;
+  const n = parseInt(m[1], 16);
+  const r = n >> 16 & 255;
+  const g2 = n >> 8 & 255;
+  const b = n & 255;
+  const lum = 0.2126 * srgb(r) + 0.7152 * srgb(g2) + 0.0722 * srgb(b);
+  return lum < 0.4;
+}
+function srgb(c) {
+  const v = c / 255;
+  return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+}
+var TEXT_STYLE_NAMES = {
+  h1: "Heading 1",
+  h2: "Heading 2",
+  h3: "Heading 3",
+  h4: "Heading 4",
+  h5: "Heading 5",
+  h6: "Heading 6",
+  body: "Body text",
+  lead: "Lead paragraph",
+  caption: "Caption",
+  small: "Small print"
+};
+function textStyleLabel(id) {
+  return TEXT_STYLE_NAMES[id] ?? humanize(id);
+}
+
+// src/theme/resolve-style.ts
+function spacing(base, ...layers) {
+  const out = { ...base };
+  for (const l of layers) {
+    if (!l) continue;
+    if (l.top !== void 0) out.top = l.top;
+    if (l.right !== void 0) out.right = l.right;
+    if (l.bottom !== void 0) out.bottom = l.bottom;
+    if (l.left !== void 0) out.left = l.left;
+  }
+  return out;
+}
+function resolveStyle(input) {
+  const { theme, styles } = input;
+  const text = styles.text[input.textStyle ?? "body"] ?? styles.text.body ?? {};
+  const d = input.defaults ?? {};
+  const o = input.allowOverrides === false ? {} : input.overrides ?? {};
+  const typo = theme.typography;
+  const fontFamily = resolveValue(o.fontFamily ?? d.fontFamily ?? text.fontFamily, theme, typo.bodyFont);
+  const fontSize = o.fontSize ?? d.fontSize ?? text.fontSize ?? typo.baseFontSize ?? 11;
+  const fontWeight = o.fontWeight ?? d.fontWeight ?? text.fontWeight ?? typo.bodyWeight ?? 400;
+  const lineHeight = o.lineHeight ?? d.lineHeight ?? text.lineHeight ?? typo.lineHeight ?? 1.5;
+  const border = o.border || d.border ? {
+    width: o.border?.width ?? d.border?.width ?? 1,
+    style: o.border?.style ?? d.border?.style ?? "solid",
+    color: resolveValue(o.border?.color ?? d.border?.color, theme, theme.colors.border),
+    radius: o.border?.radius ?? d.border?.radius ?? 0,
+    sides: o.border?.sides ?? d.border?.sides ?? ["top", "right", "bottom", "left"]
+  } : void 0;
+  const background = resolveOptional(o.background ?? d.background, theme);
+  return {
+    fontFamily,
+    fontSize,
+    fontWeight,
+    fontStyle: o.fontStyle ?? d.fontStyle ?? text.fontStyle ?? "normal",
+    lineHeight,
+    letterSpacing: o.letterSpacing ?? d.letterSpacing ?? text.letterSpacing ?? 0,
+    textTransform: o.textTransform ?? d.textTransform ?? text.textTransform ?? "none",
+    textAlign: o.textAlign ?? d.textAlign ?? "left",
+    verticalAlign: o.verticalAlign ?? d.verticalAlign ?? "top",
+    color: resolveValue(o.color ?? d.color ?? text.color, theme, theme.colors.text),
+    background,
+    padding: spacing({ top: 0, right: 0, bottom: 0, left: 0 }, d.padding, o.padding),
+    margin: spacing({ top: text.marginTop ?? 0, right: 0, bottom: text.marginBottom ?? 0, left: 0 }, d.margin, o.margin),
+    border,
+    width: o.width ?? d.width,
+    height: o.height ?? d.height,
+    align: o.align ?? d.align,
+    opacity: o.opacity ?? d.opacity
+  };
+}
+function resolveOptional(value, theme) {
+  if (!value || value === "transparent" || value === "none") return void 0;
+  return resolveValue(value, theme, "");
+}
+function styleToCss(s, opts = { text: true, box: true }) {
+  const css = {};
+  if (opts.text !== false) {
+    css["font-family"] = s.fontFamily;
+    css["font-size"] = `${s.fontSize}px`;
+    css["font-weight"] = String(s.fontWeight);
+    css["font-style"] = s.fontStyle;
+    css["line-height"] = String(s.lineHeight);
+    if (s.letterSpacing) css["letter-spacing"] = `${s.letterSpacing}em`;
+    if (s.textTransform !== "none") css["text-transform"] = s.textTransform;
+    css["text-align"] = s.textAlign;
+    css["color"] = s.color;
+  }
+  if (opts.box !== false) {
+    if (s.background) css["background"] = s.background;
+    const p = s.padding;
+    if (p.top || p.right || p.bottom || p.left) css["padding"] = `${p.top}px ${p.right}px ${p.bottom}px ${p.left}px`;
+    const m = s.margin;
+    if (m.top || m.right || m.bottom || m.left) css["margin"] = `${m.top}px ${m.right}px ${m.bottom}px ${m.left}px`;
+    if (s.border && s.border.width > 0 && s.border.style !== "none") {
+      const decl = `${s.border.width}px ${s.border.style} ${s.border.color}`;
+      if (s.border.sides.length === 4) css["border"] = decl;
+      else for (const side of s.border.sides) css[`border-${side}`] = decl;
+    }
+    if (s.border?.radius) css["border-radius"] = `${s.border.radius}px`;
+    if (s.width !== void 0) css["width"] = typeof s.width === "number" ? `${s.width}px` : s.width;
+    if (s.height !== void 0) css["height"] = `${s.height}px`;
+    if (s.opacity !== void 0 && s.opacity < 1) css["opacity"] = String(s.opacity);
+  }
+  return css;
+}
+function cssText(css) {
+  return Object.entries(css).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${k}:${v}`).join(";");
+}
+
+// src/vnode/h.ts
+var SVG_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "g",
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "defs",
+  "clipPath",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "use",
+  "symbol",
+  "mask",
+  "pattern",
+  "title",
+  "desc",
+  "foreignObject"
+]);
+function h(tag, props, ...children) {
+  const node = { tag, props: props ?? {}, children: [] };
+  if (SVG_TAGS.has(tag)) node.ns = "svg";
+  appendChildren(node.children, children);
+  return node;
+}
+function appendChildren(out, children) {
+  for (const c of children) {
+    if (c === null || c === void 0 || c === false || c === "") continue;
+    if (Array.isArray(c)) appendChildren(out, c);
+    else if (typeof c === "number") out.push(String(c));
+    else out.push(c);
+  }
+}
+function isVNode(v) {
+  return !!v && typeof v === "object" && typeof v.tag === "string" && Array.isArray(v.children);
+}
+function classNames(value) {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  return value.filter(Boolean).join(" ");
+}
+function styleString(value) {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  return Object.entries(value).filter(([, v]) => v !== void 0 && v !== "" && v !== null).map(([k, v]) => `${k}:${v}`).join(";");
+}
+var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+function escapeHtml(s) {
+  return s.replace(/[&<>"']/g, (c) => ESC[c]);
+}
+var VOID = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
+function toHtml(node) {
+  if (Array.isArray(node)) return node.map(toHtml).join("");
+  if (typeof node === "string") return escapeHtml(node);
+  const attrs = [];
+  for (const [k, v] of Object.entries(node.props)) {
+    if (v === void 0 || v === null || v === false) continue;
+    if (k === "class") {
+      const c = classNames(v);
+      if (c) attrs.push(`class="${escapeHtml(c)}"`);
+    } else if (k === "style") {
+      const s = styleString(v);
+      if (s) attrs.push(`style="${escapeHtml(s)}"`);
+    } else if (v === true) attrs.push(escapeHtml(k));
+    else attrs.push(`${escapeHtml(k)}="${escapeHtml(String(v))}"`);
+  }
+  const open = `<${node.tag}${attrs.length ? " " + attrs.join(" ") : ""}>`;
+  if (VOID.has(node.tag)) return open;
+  return `${open}${node.children.map(toHtml).join("")}</${node.tag}>`;
+}
+function walkVNodes(node, visit) {
+  if (visit(node) === false) return;
+  for (const c of node.children) if (typeof c !== "string") walkVNodes(c, visit);
+}
+
+// src/registry/block-definition.ts
+function defineBlock(def) {
+  if (!def.type || !/^[a-z0-9][a-z0-9._-]*$/i.test(def.type)) {
+    throw new Error(`Invalid block type "${def.type}". Use letters, digits, dots, dashes and underscores.`);
+  }
+  return def;
+}
+function resolveDefaultProps(def) {
+  const d = def.defaultProps;
+  return typeof d === "function" ? structuredClone(d()) : structuredClone(d);
+}
+
+// src/registry/registry.ts
+var TIER_RANK = { community: 0, pro: 1, enterprise: 2 };
+var BlockRegistry = class {
+  defs = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  enabledTiers;
+  constructor(defs = [], opts = {}) {
+    this.enabledTiers = new Set(opts.enabledTiers ?? ["community", "pro", "enterprise"]);
+    for (const d of defs) this.register(d);
+  }
+  register(def) {
+    if (this.defs.has(def.type)) throw new Error(`Block type "${def.type}" is already registered`);
+    this.defs.set(def.type, def);
+    this.emit();
+    return this;
+  }
+  /** Replaces an existing definition (used for hot-swapping custom blocks in dev). */
+  replace(def) {
+    this.defs.set(def.type, def);
+    this.emit();
+    return this;
+  }
+  unregister(type) {
+    this.defs.delete(type);
+    this.emit();
+    return this;
+  }
+  get(type) {
+    return this.defs.get(type);
+  }
+  has(type) {
+    return this.defs.has(type);
+  }
+  require(type) {
+    const d = this.defs.get(type);
+    if (!d) throw new Error(`Unknown block type "${type}"`);
+    return d;
+  }
+  list() {
+    return [...this.defs.values()];
+  }
+  /** Blocks shown in the palette, grouped by category, honouring `hidden`. */
+  palette() {
+    return this.list().filter((d) => !d.hidden && d.category !== "structure");
+  }
+  isTierEnabled(tier) {
+    return this.enabledTiers.has(tier ?? "community");
+  }
+  /** The highest tier required by a set of block types. */
+  requiredTier(types) {
+    let best = "community";
+    for (const t of types) {
+      const tier = this.defs.get(t)?.license ?? "community";
+      if (TIER_RANK[tier] > TIER_RANK[best]) best = tier;
+    }
+    return best;
+  }
+  /** Effective binding specs for a block: explicit `bindings`, else derived from the inspector. */
+  bindingsOf(type) {
+    const def = this.defs.get(type);
+    if (!def) return [];
+    return bindingSpecsFor(def);
+  }
+  /** Whether `childType` may be placed inside `parentType`. */
+  accepts(parentType, childType) {
+    const parent = this.defs.get(parentType);
+    const child = this.defs.get(childType);
+    if (!parent?.container) return false;
+    for (const rule of parent.container.accepts) {
+      if (rule === childType) return true;
+      if (rule === "@blocks" && child && child.category !== "structure") return true;
+      if (rule === "@rows" && childType === "row") return true;
+      if (rule === "@columns" && childType === "column") return true;
+      if (rule === "@sections" && childType === "section") return true;
+    }
+    return false;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  emit() {
+    for (const l of this.listeners) l();
+  }
+};
+var bindingCache = /* @__PURE__ */ new WeakMap();
+function bindingSpecsFor(def) {
+  const hit = bindingCache.get(def);
+  if (hit) return hit;
+  let specs;
+  if (def.bindings) specs = def.bindings;
+  else {
+    specs = [];
+    const visit = (fields) => {
+      for (const f of fields) {
+        switch (f.kind) {
+          case "binding":
+            specs.push({ prop: f.prop, kind: "value", valueType: f.valueType });
+            break;
+          case "collection":
+            specs.push({ prop: f.prop, kind: "collection" });
+            break;
+          case "expression":
+            specs.push({ prop: f.prop, kind: "value" });
+            break;
+          case "richtext":
+            specs.push({ prop: f.prop, kind: "richtext" });
+            break;
+          case "condition":
+            specs.push({ prop: f.prop, kind: "condition" });
+            break;
+          case "text":
+          case "textarea":
+            if (f.allowTokens !== false) specs.push({ prop: f.prop, kind: "template" });
+            break;
+          case "image":
+            if (f.allowBinding !== false) specs.push({ prop: f.prop, kind: "template" });
+            break;
+          case "list":
+            visit(f.fields);
+            break;
+          default:
+            break;
+        }
+      }
+    };
+    for (const s of def.inspector ?? []) visit(s.fields);
+  }
+  bindingCache.set(def, specs);
+  return specs;
+}
+
+// src/schema/template.schema.ts
+import { z } from "zod";
+var color = z.string().min(1);
+var spacing2 = z.object({ top: z.number().optional(), right: z.number().optional(), bottom: z.number().optional(), left: z.number().optional() }).partial();
+var borderSpec = z.object({
+  width: z.number().min(0).optional(),
+  style: z.enum(["solid", "dashed", "dotted", "none"]).optional(),
+  color: color.optional(),
+  radius: z.number().min(0).optional(),
+  sides: z.array(z.enum(["top", "right", "bottom", "left"])).optional()
+}).partial();
+var blockStyleSchema = z.object({
+  textStyle: z.string().optional(),
+  fontFamily: z.string().optional(),
+  fontSize: z.number().positive().optional(),
+  fontWeight: z.union([z.number(), z.enum(["normal", "bold"])]).optional(),
+  fontStyle: z.enum(["normal", "italic"]).optional(),
+  lineHeight: z.number().positive().optional(),
+  letterSpacing: z.number().optional(),
+  textTransform: z.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
+  textAlign: z.enum(["left", "center", "right", "justify"]).optional(),
+  verticalAlign: z.enum(["top", "middle", "bottom"]).optional(),
+  color: color.optional(),
+  background: color.optional(),
+  padding: spacing2.optional(),
+  margin: spacing2.optional(),
+  border: borderSpec.optional(),
+  width: z.union([z.number(), z.string()]).optional(),
+  height: z.number().optional(),
+  align: z.enum(["left", "center", "right"]).optional(),
+  opacity: z.number().min(0).max(1).optional()
+}).partial();
+var conditionRule = z.object({
+  left: z.string(),
+  operator: z.enum(["eq", "neq", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "in", "isEmpty", "isNotEmpty", "isTrue", "isFalse"]),
+  right: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional()
+});
+var conditionGroupSchema = z.lazy(
+  () => z.object({ op: z.enum(["and", "or"]), rules: z.array(z.union([conditionRule, conditionGroupSchema])) })
+);
+var conditionSchema = z.union([z.string(), conditionGroupSchema]);
+var flowSchema = z.object({
+  breakBefore: z.enum(["auto", "page"]).optional(),
+  breakAfter: z.enum(["auto", "page"]).optional(),
+  keepTogether: z.boolean().optional(),
+  keepWithNext: z.boolean().optional(),
+  minOrphans: z.number().int().min(0).optional(),
+  minWidows: z.number().int().min(0).optional()
+}).partial();
+var nodeSchema = z.lazy(
+  () => z.object({
+    id: z.string().min(1),
+    type: z.string().min(1),
+    props: z.record(z.unknown()),
+    style: blockStyleSchema.optional(),
+    children: z.array(nodeSchema).optional(),
+    visibleWhen: conditionSchema.optional(),
+    flow: flowSchema.optional(),
+    name: z.string().optional(),
+    locked: z.boolean().optional()
+  })
+);
+var textStyleSchema = z.object({
+  fontFamily: z.string().optional(),
+  fontSize: z.number().positive().optional(),
+  fontWeight: z.union([z.number(), z.enum(["normal", "bold"])]).optional(),
+  fontStyle: z.enum(["normal", "italic"]).optional(),
+  lineHeight: z.number().positive().optional(),
+  letterSpacing: z.number().optional(),
+  textTransform: z.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
+  color: color.optional(),
+  marginTop: z.number().optional(),
+  marginBottom: z.number().optional(),
+  keepWithNext: z.boolean().optional()
+}).partial();
+var pageRegion = z.object({ height: z.number().min(0), differentFirstPage: z.boolean() });
+var pageSettingsSchema = z.object({
+  size: z.union([z.enum(["A4", "A3", "A5", "Letter", "Legal", "Tabloid"]), z.object({ width: z.number().positive(), height: z.number().positive() })]),
+  orientation: z.enum(["portrait", "landscape"]),
+  margins: z.object({ top: z.number().min(0), right: z.number().min(0), bottom: z.number().min(0), left: z.number().min(0) }),
+  header: pageRegion,
+  footer: pageRegion,
+  background: color.optional(),
+  minPages: z.number().int().min(1).optional()
+});
+var documentStylesSchema = z.object({
+  text: z.record(textStyleSchema),
+  table: z.object({
+    fontSize: z.number().optional(),
+    headerBackground: color.optional(),
+    headerColor: color.optional(),
+    headerFontWeight: z.union([z.number(), z.enum(["normal", "bold"])]).optional(),
+    borderColor: color.optional(),
+    borderWidth: z.number().optional(),
+    borders: z.enum(["all", "horizontal", "outer", "none"]).optional(),
+    zebraBackground: color.optional(),
+    cellPaddingX: z.number().optional(),
+    cellPaddingY: z.number().optional()
+  }).partial(),
+  card: z.object({
+    background: color.optional(),
+    borderColor: color.optional(),
+    borderWidth: z.number().optional(),
+    borderRadius: z.number().optional(),
+    padding: z.number().optional(),
+    shadow: z.boolean().optional()
+  }).partial(),
+  link: z.object({ color: color.optional(), underline: z.boolean().optional() }).partial(),
+  spacing: z.object({ blockGap: z.number(), sectionPadding: z.number(), columnGap: z.number() })
+});
+var regionContent = z.object({ default: z.array(nodeSchema), firstPage: z.array(nodeSchema).optional() });
+var templateSchema = z.object({
+  schemaVersion: z.literal(CURRENT_SCHEMA_VERSION),
+  id: z.string().min(1),
+  name: z.string(),
+  meta: z.object({
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+    author: z.string().optional(),
+    description: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    custom: z.record(z.unknown()).optional()
+  }).partial().optional(),
+  page: pageSettingsSchema,
+  styles: documentStylesSchema,
+  header: regionContent,
+  footer: regionContent,
+  body: z.array(nodeSchema),
+  library: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      description: z.string().optional(),
+      category: z.string().optional(),
+      node: nodeSchema,
+      thumbnail: z.string().optional()
+    })
+  ).optional(),
+  settings: z.object({
+    locale: z.string().optional(),
+    currency: z.string().optional(),
+    timeZone: z.string().optional(),
+    dataSources: z.array(z.string()).optional()
+  }).partial().optional()
+});
+function parseTemplate(json) {
+  const r = templateSchema.safeParse(json);
+  if (r.success) return { ok: true, template: r.data, errors: [] };
+  return { ok: false, errors: r.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })) };
+}
+
+// src/schema/ids.ts
+var ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function randomBytes(n) {
+  const out = new Uint8Array(n);
+  const c = globalThis.crypto;
+  if (c?.getRandomValues) c.getRandomValues(out);
+  else for (let i = 0; i < n; i++) out[i] = Math.floor(Math.random() * 256);
+  return out;
+}
+var counter = 0;
+var deterministic = null;
+function createId(prefix = "n") {
+  if (deterministic !== null) return `${prefix}_${deterministic}${(++counter).toString(36)}`;
+  const bytes = randomBytes(10);
+  let s = "";
+  for (const b of bytes) s += ALPHABET[b % ALPHABET.length];
+  return `${prefix}_${s}`;
+}
+function setDeterministicIds(seed) {
+  deterministic = seed;
+  counter = 0;
+}
+
+// src/schema/migrate.ts
+var MIGRATIONS = [
+  {
+    from: 0,
+    to: 1,
+    description: "Pre-release drafts: normalise `content` \u2192 `body`, add page regions and styles",
+    migrate(t) {
+      const out = { ...t, schemaVersion: 1 };
+      if (Array.isArray(t.content) && !t.body) {
+        out.body = t.content;
+        delete out.content;
+      }
+      out.header ??= { default: [] };
+      out.footer ??= { default: [] };
+      return out;
+    }
+  }
+];
+var MigrationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+  }
+};
+function migrateTemplate(input) {
+  const fromVersion = typeof input.schemaVersion === "number" ? input.schemaVersion : 0;
+  if (fromVersion > CURRENT_SCHEMA_VERSION) {
+    throw new MigrationError(`Template schemaVersion ${fromVersion} is newer than this version of BroadPaper supports (${CURRENT_SCHEMA_VERSION}). Upgrade the SDK.`);
+  }
+  let current2 = structuredClone(input);
+  const applied = [];
+  let v = fromVersion;
+  while (v < CURRENT_SCHEMA_VERSION) {
+    const step = MIGRATIONS.find((m) => m.from === v);
+    if (!step) throw new MigrationError(`No migration from schemaVersion ${v} to ${v + 1}`);
+    current2 = step.migrate(current2);
+    current2.schemaVersion = step.to;
+    applied.push(step);
+    v = step.to;
+  }
+  return { template: current2, applied, fromVersion };
+}
+function needsMigration(input) {
+  return (input.schemaVersion ?? 0) < CURRENT_SCHEMA_VERSION;
+}
+
+// src/schema/create.ts
+function defaultPageSettings(overrides = {}) {
+  return {
+    size: "A4",
+    orientation: "portrait",
+    margins: { top: 18, right: 18, bottom: 18, left: 18 },
+    header: { height: 14, differentFirstPage: false },
+    footer: { height: 12, differentFirstPage: false },
+    ...overrides
+  };
+}
+function createTemplate(opts = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    id: opts.id ?? createId("tpl"),
+    name: opts.name ?? "Untitled report",
+    meta: { createdAt: now, updatedAt: now },
+    page: defaultPageSettings(opts.page),
+    styles: defaultDocumentStyles(),
+    header: { default: [] },
+    footer: { default: [] },
+    body: opts.withEmptySection === false ? [] : [createSection()],
+    settings: { locale: opts.locale ?? "en-GB", currency: opts.currency ?? "GBP" }
+  };
+}
+function createNode(registry, type, opts = {}) {
+  const def = registry.get(type);
+  const props = { ...def ? resolveDefaultProps(def) : {}, ...opts.props ?? {} };
+  const node = { id: opts.id ?? createId(), type, props };
+  if (opts.style) node.style = opts.style;
+  if (def?.container || opts.children) node.children = opts.children ?? [];
+  if (opts.flow) node.flow = opts.flow;
+  if (opts.visibleWhen !== void 0) node.visibleWhen = opts.visibleWhen;
+  if (opts.name) node.name = opts.name;
+  return node;
+}
+function createSection(opts = {}) {
+  return { id: opts.id ?? createId("sec"), type: "section", props: { padding: 0, ...opts.props ?? {} }, children: opts.children ?? [], ...opts.style ? { style: opts.style } : {}, ...opts.flow ? { flow: opts.flow } : {}, ...opts.name ? { name: opts.name } : {} };
+}
+function createColumn(span, children = [], id) {
+  return { id: id ?? createId("col"), type: "column", props: { span }, children };
+}
+function createRow(layout, columns, opts = {}) {
+  const total = layout.reduce((a, b) => a + b, 0);
+  if (total !== 12) throw new Error(`Row layout must sum to 12, got ${total} from [${layout.join(", ")}]`);
+  return {
+    id: opts.id ?? createId("row"),
+    type: "row",
+    props: { layout, ...opts.props ?? {} },
+    children: layout.map((span, i) => createColumn(span, columns?.[i] ?? [])),
+    ...opts.style ? { style: opts.style } : {},
+    ...opts.flow ? { flow: opts.flow } : {},
+    ...opts.name ? { name: opts.name } : {}
+  };
+}
+var ROW_LAYOUTS = [
+  { id: "12", label: "Full width", layout: [12] },
+  { id: "6-6", label: "Two columns", layout: [6, 6] },
+  { id: "4-4-4", label: "Three columns", layout: [4, 4, 4] },
+  { id: "3-3-3-3", label: "Four columns", layout: [3, 3, 3, 3] },
+  { id: "8-4", label: "Wide left", layout: [8, 4] },
+  { id: "4-8", label: "Wide right", layout: [4, 8] },
+  { id: "9-3", label: "Sidebar right", layout: [9, 3] },
+  { id: "3-9", label: "Sidebar left", layout: [3, 9] }
+];
+function cloneWithNewIds(node) {
+  const prefix = node.type === "section" ? "sec" : node.type === "row" ? "row" : node.type === "column" ? "col" : "n";
+  return {
+    ...structuredClone(node),
+    id: createId(prefix),
+    children: node.children?.map(cloneWithNewIds)
+  };
+}
+
+// src/data/sample.ts
+function synthesizeSampleData(sources, opts = {}) {
+  const out = {};
+  for (const s of sources) out[s.id] = synthesizeObject(s.schema, opts, 0);
+  return out;
+}
+function synthesizeValue(schema, opts = {}, depth = 0, index = 0) {
+  if (schema.example !== void 0) return schema.example;
+  if (schema.enum?.length) return schema.enum[index % schema.enum.length];
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  switch (schema.type) {
+    case "string":
+      return schema.label ?? "Sample text";
+    case "number":
+      return [1240, 875, 2310, 1580, 990, 1870][index % 6];
+    case "currency":
+      return [125e3, 48200.5, 231e3, 15800, 99e3, 187500][index % 6];
+    case "percent":
+      return [0.125, 0.082, 0.31, 0.058, 0.196, 0.229][index % 6];
+    case "date":
+    case "datetime": {
+      const d = new Date(now);
+      d.setMonth(d.getMonth() - index);
+      return d.toISOString();
+    }
+    case "boolean":
+      return index % 2 === 0;
+    case "image":
+      return void 0;
+    case "url":
+      return "https://example.com";
+    case "richtext":
+      return "Sample rich text";
+    case "object":
+      return depth > 6 ? {} : synthesizeObject(schema.fields ?? {}, opts, depth + 1);
+    case "array": {
+      const n = opts.arrayLength ?? 4;
+      const item = schema.itemSchema ?? { type: "string" };
+      return depth > 6 ? [] : Array.from({ length: n }, (_, i) => synthesizeValue(item, opts, depth + 1, i));
+    }
+    default:
+      return void 0;
+  }
+}
+function synthesizeObject(fields, opts, depth) {
+  const o = {};
+  let i = 0;
+  for (const [k, f] of Object.entries(fields)) o[k] = synthesizeValue(f, opts, depth, i++);
+  return o;
+}
+function labelForPath(segments, scope) {
+  const parts = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.kind === "index") {
+      parts[parts.length - 1] = `${parts[parts.length - 1] ?? ""} #${seg.index + 1}`;
+      continue;
+    }
+    const r = resolvePathSchema(segments.slice(0, i + 1), scope);
+    parts.push(r.schema?.label ?? humanizeKey(seg.name));
+  }
+  return parts.join(" \u203A ");
+}
+function humanizeKey(key) {
+  return key.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+}
+
+// src/resolve/describe.ts
+function describeExpression(expr, scope) {
+  try {
+    const ast = parseExpression(expr);
+    const tc = typeCheckAst(ast, scope);
+    const type = tc.issues.length ? "unknown" : tc.type;
+    const paths = collectPaths(ast);
+    if (ast.kind === "path") return { label: labelForPath(ast.segments, scope), type };
+    if (ast.kind === "pipe" && ast.input.kind === "path") return { label: `${labelForPath(ast.input.segments, scope)} \xB7 ${ast.name}`, type };
+    const names = [...new Set(paths.map((p) => labelForPath(p, scope)))];
+    if (names.length === 1) return { label: `\u0192 ${names[0]}`, type };
+    if (names.length > 1) return { label: `\u0192 ${names.slice(0, 2).join(", ")}${names.length > 2 ? "\u2026" : ""}`, type };
+    return { label: expr, type };
+  } catch {
+    return { label: expr, type: "unknown" };
+  }
+}
+function humaniseLabel(text, scope) {
+  const described = (expr) => {
+    const { label } = describeExpression(expr.trim(), scope);
+    return label;
+  };
+  return text.replace(/\{\{([^}]+)\}\}/g, (_, expr) => described(expr)).replace(/\b[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+\b/g, (path) => {
+    const label = described(path);
+    return label === path ? path : label;
+  });
+}
+
+// src/resolve/resolve.ts
+var display = toDisplayString;
+function resolveTemplate(opts) {
+  const mode = opts.mode ?? "preview";
+  const theme = mergeTheme(opts.theme);
+  const template = opts.template;
+  const dataSources = opts.dataSources ?? [];
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const format = {
+    locale: opts.locale ?? template.settings?.locale ?? "en-GB",
+    currency: opts.currency ?? template.settings?.currency ?? "GBP",
+    timeZone: opts.timeZone ?? template.settings?.timeZone,
+    now
+  };
+  const warnings = [];
+  let data;
+  if (mode === "preview") data = opts.data ?? opts.sampleData ?? {};
+  else data = opts.data ?? opts.sampleData ?? synthesizeSampleData(dataSources, { now });
+  if (mode === "design") {
+    const synth = synthesizeSampleData(dataSources, { now });
+    data = { ...synth, ...data };
+  }
+  const globals = {
+    page: { number: 1, total: 1 },
+    now,
+    theme: { name: theme.name, logo: theme.logo, logoDark: theme.logoDark, colors: theme.colors, typography: theme.typography, meta: theme.meta ?? {} }
+  };
+  const scope = new Scope(globals).child(data);
+  const schemaScope = createSchemaScope(dataSources);
+  const ctx = {
+    registry: opts.registry,
+    theme,
+    template,
+    mode,
+    format,
+    warnings,
+    designIterations: Math.max(1, opts.designIterations ?? 1),
+    maxIterations: opts.maxIterations ?? 5e3,
+    allowStyleOverrides: opts.allowStyleOverrides ?? true,
+    designShowHidden: opts.designShowHidden ?? true,
+    dataSources
+  };
+  const resolveList = (nodes) => (nodes ?? []).flatMap((n) => resolveNode(ctx, n, scope, schemaScope, "", "section"));
+  const header = { default: resolveList(template.header?.default) };
+  if (template.page.header.differentFirstPage) header.firstPage = resolveList(template.header?.firstPage);
+  const footer = { default: resolveList(template.footer?.default) };
+  if (template.page.footer.differentFirstPage) footer.firstPage = resolveList(template.footer?.firstPage);
+  return { body: resolveList(template.body), header, footer, warnings, mode };
+}
+function isPageDependent(expr) {
+  try {
+    return collectPaths(parseExpression(expr)).some((p) => p[0]?.kind === "prop" && p[0].name === "page");
+  } catch {
+    return false;
+  }
+}
+function evalCtx(ctx, scope, nodeId) {
+  return {
+    scope,
+    format: ctx.format,
+    onWarning: (message, expr) => ctx.warnings.push({ message, nodeId, expr })
+  };
+}
+function safeEvaluate(ctx, scope, nodeId, expr) {
+  try {
+    return evaluate(expr, evalCtx(ctx, scope, nodeId));
+  } catch (e) {
+    ctx.warnings.push({ message: `Invalid expression: ${e.message}`, nodeId, expr });
+    return void 0;
+  }
+}
+var labelFor = describeExpression;
+function resolveSegments(ctx, scope, schemaScope, nodeId, value) {
+  const segments = [];
+  let pageDependent = false;
+  for (const s of splitTemplate(value)) {
+    if (s.kind === "text") {
+      segments.push(s);
+      continue;
+    }
+    const expr = s.expr;
+    const { label } = labelFor(expr, schemaScope);
+    if (isPageDependent(expr)) {
+      pageDependent = true;
+      segments.push({ ...s, label, deferred: true });
+      continue;
+    }
+    const v = safeEvaluate(ctx, scope, nodeId, expr);
+    segments.push({ ...s, label, value: display(v) });
+  }
+  const text = segments.map((s) => s.kind === "text" ? s.text : s.value ?? "").join("");
+  return { segments, text, pageDependent };
+}
+function resolveRichText(ctx, scope, schemaScope, nodeId, doc) {
+  let pageDependent = false;
+  const inline = (content) => content.map((n) => {
+    if (n.type !== "token") {
+      if (n.type === "text" && n.marks?.link?.includes("{{")) {
+        const r = resolveSegments(ctx, scope, schemaScope, nodeId, n.marks.link);
+        return { ...n, marks: { ...n.marks, link: r.text } };
+      }
+      return n;
+    }
+    const { label } = labelFor(n.expr, schemaScope);
+    if (isPageDependent(n.expr)) {
+      pageDependent = true;
+      return { ...n, label, deferred: true };
+    }
+    return { ...n, label, value: display(safeEvaluate(ctx, scope, nodeId, n.expr)) };
+  });
+  const para = (p) => ({ ...p, content: inline(p.content) });
+  const out = {
+    type: "doc",
+    content: doc.content.map((b) => b.type === "paragraph" ? para(b) : { ...b, content: b.content.map((li) => ({ ...li, content: li.content.map(para) })) })
+  };
+  return { doc: out, pageDependent };
+}
+function getPath(obj, path) {
+  const parts = path.split(".");
+  let cur = obj;
+  for (const p of parts) {
+    if (cur === null || cur === void 0 || typeof cur !== "object") return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function setPath(obj, path, value) {
+  const parts = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const p = parts[i];
+    if (typeof cur[p] !== "object" || cur[p] === null) cur[p] = {};
+    cur = cur[p];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+function resolveFlow(def, node, textStyleKeepWithNext) {
+  const d = def?.defaultFlow ?? {};
+  const n = node.flow ?? {};
+  const isContainer = !!def?.container;
+  const split = def?.split ?? (isContainer ? "children" : "none");
+  return {
+    breakBefore: n.breakBefore ?? d.breakBefore ?? "auto",
+    breakAfter: n.breakAfter ?? d.breakAfter ?? "auto",
+    keepTogether: n.keepTogether ?? d.keepTogether ?? false,
+    keepWithNext: n.keepWithNext ?? d.keepWithNext ?? textStyleKeepWithNext ?? false,
+    split,
+    minOrphans: n.minOrphans ?? d.minOrphans ?? 2,
+    minWidows: n.minWidows ?? d.minWidows ?? 2
+  };
+}
+function roleOf(type) {
+  return type === "section" || type === "row" || type === "column" ? type : "block";
+}
+function resolveNode(ctx, node, scope, schemaScope, keyPrefix, _parentRole) {
+  const def = ctx.registry.get(node.type);
+  const key = keyPrefix + node.id;
+  const nodeId = node.id;
+  let hiddenByCondition = false;
+  const cond = compileCondition(node.visibleWhen);
+  if (cond) {
+    const syntax = checkExpressionSyntax(cond);
+    if (syntax) ctx.warnings.push({ message: `Invalid condition: ${syntax.message}`, nodeId, expr: cond });
+    else {
+      let visible = true;
+      try {
+        visible = evaluateCondition(cond, evalCtx(ctx, scope, nodeId));
+      } catch (e) {
+        ctx.warnings.push({ message: `Condition failed: ${e.message}`, nodeId, expr: cond });
+      }
+      if (!visible) {
+        if (ctx.mode === "preview" || !ctx.designShowHidden) return [];
+        hiddenByCondition = true;
+      }
+    }
+  }
+  if (!def) {
+    ctx.warnings.push({ message: `Unknown block type "${node.type}"`, nodeId });
+    return [
+      {
+        key,
+        nodeId,
+        type: node.type,
+        role: roleOf(node.type),
+        props: { ...node.props, __unknown: true },
+        raw: node.props,
+        style: resolveStyle({ theme: ctx.theme, styles: ctx.template.styles }),
+        flow: resolveFlow(void 0, node, void 0),
+        children: [],
+        bindings: {},
+        textSegments: {},
+        richText: {},
+        label: node.name ?? node.type,
+        locked: node.locked
+      }
+    ];
+  }
+  const defaults = resolveDefaultProps(def);
+  const raw = { ...defaults, ...node.props };
+  const props = structuredClone(raw);
+  const bindings = {};
+  const textSegments = {};
+  const richText = {};
+  let pageDependent = false;
+  const applySpec = (spec, target, propPrefix) => {
+    const propPath = propPrefix + spec.prop;
+    const value = getPath(target, spec.prop);
+    switch (spec.kind) {
+      case "value": {
+        if (typeof value !== "string" || value.trim() === "") return;
+        const { label, type } = labelFor(value, schemaScope);
+        bindings[propPath] = { prop: propPath, kind: "value", expr: value, label, type };
+        if (isPageDependent(value)) {
+          pageDependent = true;
+          setPath(target, spec.prop, void 0);
+          return;
+        }
+        setPath(target, spec.prop, safeEvaluate(ctx, scope, nodeId, value));
+        return;
+      }
+      case "collection": {
+        if (typeof value !== "string" || value.trim() === "") {
+          setPath(target, spec.prop, []);
+          return;
+        }
+        const { label, type } = labelFor(value, schemaScope);
+        bindings[propPath] = { prop: propPath, kind: "collection", expr: value, label, type };
+        const v = safeEvaluate(ctx, scope, nodeId, value);
+        setPath(target, spec.prop, Array.isArray(v) ? v : v === void 0 || v === null ? [] : [v]);
+        return;
+      }
+      case "template": {
+        if (typeof value !== "string") return;
+        if (!value.includes("{{")) {
+          textSegments[propPath] = [{ kind: "text", text: value }];
+          return;
+        }
+        const r = resolveSegments(ctx, scope, schemaScope, nodeId, value);
+        if (r.pageDependent) pageDependent = true;
+        textSegments[propPath] = r.segments;
+        const tokens = r.segments.filter((s) => s.kind === "token");
+        if (tokens.length === 1 && r.segments.length === 1) {
+          const { label, type } = labelFor(tokens[0].expr, schemaScope);
+          bindings[propPath] = { prop: propPath, kind: "template", expr: tokens[0].expr, label, type };
+        }
+        setPath(target, spec.prop, r.text);
+        return;
+      }
+      case "richtext": {
+        if (!isRichTextDoc(value)) return;
+        const r = resolveRichText(ctx, scope, schemaScope, nodeId, value);
+        if (r.pageDependent) pageDependent = true;
+        richText[propPath] = r.doc;
+        return;
+      }
+      case "condition":
+      case "list":
+        return;
+    }
+  };
+  for (const spec of bindingSpecsFor(def)) {
+    if (spec.perItem) continue;
+    if (spec.items) {
+      const list = getPath(props, spec.prop);
+      if (Array.isArray(list)) list.forEach((item, i) => item && typeof item === "object" && spec.items.forEach((s) => !s.perItem && applySpec(s, item, `${spec.prop}.${i}.`)));
+      continue;
+    }
+    applySpec(spec, props, "");
+  }
+  if (def.resolve) {
+    const hookCtx = {
+      props,
+      node,
+      scope,
+      mode: ctx.mode,
+      theme: ctx.theme,
+      format: ctx.format,
+      evaluate: (expr) => safeEvaluate(ctx, scope, nodeId, expr),
+      evaluateIn: (expr, vars) => safeEvaluate(ctx, scope.child(vars), nodeId, expr),
+      warn: (message) => ctx.warnings.push({ message, nodeId })
+    };
+    try {
+      const out = def.resolve(hookCtx);
+      if (out && typeof out === "object") Object.assign(props, out);
+    } catch (e) {
+      ctx.warnings.push({ message: `Block "${def.name}" failed to resolve: ${e.message}`, nodeId });
+    }
+  }
+  const textStyleId = node.style?.textStyle ?? def.defaultTextStyle;
+  const style = resolveStyle({
+    theme: ctx.theme,
+    styles: ctx.template.styles,
+    textStyle: textStyleId,
+    defaults: def.defaultStyle,
+    overrides: node.style,
+    allowOverrides: ctx.allowStyleOverrides
+  });
+  const textStyleDef = textStyleId ? ctx.template.styles.text[textStyleId] : void 0;
+  const flow = resolveFlow(def, node, textStyleDef?.keepWithNext);
+  let children = [];
+  let iterationInfo;
+  let placeholder = false;
+  const c = def.container;
+  if (c?.repeat) {
+    const listValue = props[c.repeat.collectionProp];
+    const alias = props[c.repeat.aliasProp ?? "alias"] || "item";
+    const collectionExpr = raw[c.repeat.collectionProp];
+    let items = Array.isArray(listValue) ? listValue : [];
+    const limit = c.repeat.limitProp ? Number(props[c.repeat.limitProp]) || void 0 : void 0;
+    if (limit) items = items.slice(0, limit);
+    if (items.length > ctx.maxIterations) {
+      ctx.warnings.push({ message: `Repeater truncated to ${ctx.maxIterations} items`, nodeId });
+      items = items.slice(0, ctx.maxIterations);
+    }
+    let itemSchema;
+    if (typeof collectionExpr === "string" && collectionExpr.trim()) {
+      try {
+        let ast = parseExpression(collectionExpr);
+        while (ast.kind === "pipe") ast = ast.input;
+        const r = ast.kind === "path" ? resolvePathSchema(ast.segments, schemaScope) : {};
+        itemSchema = r.schema?.type === "array" ? r.schema.itemSchema : void 0;
+      } catch {
+        itemSchema = void 0;
+      }
+    }
+    if (ctx.mode === "design") {
+      if (items.length === 0) {
+        items = itemSchema ? [synthesizeValue(itemSchema, { now: ctx.format.now }, 0, 0)] : [{}];
+        placeholder = true;
+      }
+      items = items.slice(0, ctx.designIterations);
+    }
+    const keepItem = c.repeat.keepItemTogetherProp ? !!props[c.repeat.keepItemTogetherProp] : false;
+    const count = items.length;
+    const childSchemaScope = schemaScope.child({
+      [alias]: itemSchema ?? { type: "object", label: alias, fields: {} },
+      index: { type: "number", label: "Index" },
+      first: { type: "boolean", label: "Is first" },
+      last: { type: "boolean", label: "Is last" },
+      count: { type: "number", label: "Count" }
+    });
+    children = items.map((item, index) => {
+      const iterScope = scope.child({ [alias]: item, item, index: index + 1, first: index === 0, last: index === count - 1, count });
+      const iterKey = `${key}@${index}`;
+      const iterChildren = (node.children ?? []).flatMap((ch) => resolveNode(ctx, ch, iterScope, childSchemaScope, `${iterKey}/`, "block"));
+      const iteration = {
+        key: iterKey,
+        nodeId,
+        type: "repeater-item",
+        role: "block",
+        props: { index, count },
+        raw: {},
+        style: resolveStyle({ theme: ctx.theme, styles: ctx.template.styles }),
+        flow: { breakBefore: "auto", breakAfter: "auto", keepTogether: keepItem, keepWithNext: false, split: "children", minOrphans: 1, minWidows: 1 },
+        children: iterChildren,
+        bindings: {},
+        textSegments: {},
+        richText: {},
+        iteration: { index, count, alias },
+        label: `${alias} ${index + 1}`
+      };
+      return iteration;
+    });
+    iterationInfo = void 0;
+    props.__itemCount = Array.isArray(listValue) ? listValue.length : 0;
+  } else if (c?.conditional) {
+    const condValue = compileCondition(raw[c.conditional.conditionProp]);
+    let show = true;
+    if (condValue) {
+      const syntax = checkExpressionSyntax(condValue);
+      if (syntax) ctx.warnings.push({ message: `Invalid condition: ${syntax.message}`, nodeId, expr: condValue });
+      else {
+        try {
+          show = evaluateCondition(condValue, evalCtx(ctx, scope, nodeId));
+        } catch (e) {
+          ctx.warnings.push({ message: `Condition failed: ${e.message}`, nodeId, expr: condValue });
+        }
+      }
+    }
+    props.__conditionResult = show;
+    if (show || ctx.mode === "design") {
+      children = (node.children ?? []).flatMap((ch) => resolveNode(ctx, ch, scope, schemaScope, keyPrefix, "block"));
+    }
+  } else if (c) {
+    children = (node.children ?? []).flatMap((ch) => resolveNode(ctx, ch, scope, schemaScope, keyPrefix, roleOf(node.type)));
+  }
+  const resolved = {
+    key,
+    nodeId,
+    type: node.type,
+    role: roleOf(node.type),
+    props,
+    raw,
+    style,
+    flow,
+    children,
+    bindings,
+    textSegments,
+    richText,
+    label: node.name ?? def.canvas?.label?.(props) ?? def.name,
+    locked: node.locked,
+    pageDependent: pageDependent || void 0,
+    placeholder: placeholder || void 0,
+    iteration: iterationInfo
+  };
+  if (hiddenByCondition) resolved.props.__hiddenByCondition = true;
+  if (node.type === "row") {
+    const layout = Array.isArray(props.layout) ? props.layout : children.map(() => 12 / Math.max(1, children.length));
+    resolved.layout = { columns: layout };
+    children.forEach((col, i) => {
+      col.span = layout[i] ?? 12 / Math.max(1, children.length);
+    });
+  }
+  return [resolved];
+}
+function evaluateToText(expr, data, format) {
+  const scope = new Scope({ now: format?.now ?? /* @__PURE__ */ new Date() }).child(data);
+  return toDisplayString(
+    evaluate(expr, {
+      scope,
+      format: { locale: "en-GB", currency: "GBP", ...format }
+    })
+  );
+}
+
+// src/resolve/resolved.ts
+var DEFAULT_PAGE_CONTEXT = { number: 1, total: 1 };
+
+// src/layout/page-geometry.ts
+var PX_PER_MM = 96 / 25.4;
+var PAGE_SIZES_MM = {
+  A3: { width: 297, height: 420 },
+  A4: { width: 210, height: 297 },
+  A5: { width: 148, height: 210 },
+  Letter: { width: 215.9, height: 279.4 },
+  Legal: { width: 215.9, height: 355.6 },
+  Tabloid: { width: 279.4, height: 431.8 }
+};
+function mmToPx(mm) {
+  return Math.round(mm * PX_PER_MM * 100) / 100;
+}
+function pxToMm(px) {
+  return Math.round(px / PX_PER_MM * 100) / 100;
+}
+function pageSizeMm(size) {
+  return typeof size === "string" ? PAGE_SIZES_MM[size] ?? PAGE_SIZES_MM.A4 : size;
+}
+function computePageGeometry(page) {
+  const size = pageSizeMm(page.size);
+  const portrait = page.orientation !== "landscape";
+  const width = mmToPx(portrait ? size.width : size.height);
+  const height = mmToPx(portrait ? size.height : size.width);
+  const margins = {
+    top: mmToPx(page.margins.top),
+    right: mmToPx(page.margins.right),
+    bottom: mmToPx(page.margins.bottom),
+    left: mmToPx(page.margins.left)
+  };
+  const headerHeight = mmToPx(Math.max(0, page.header.height));
+  const footerHeight = mmToPx(Math.max(0, page.footer.height));
+  const contentTop = margins.top + headerHeight;
+  const footerTop = height - margins.bottom - footerHeight;
+  return {
+    width,
+    height,
+    margins,
+    headerHeight,
+    footerHeight,
+    contentWidth: Math.max(0, width - margins.left - margins.right),
+    contentHeight: Math.max(0, footerTop - contentTop),
+    contentTop,
+    headerTop: margins.top,
+    footerTop
+  };
+}
+
+// src/layout/paginate.ts
+function g(ctx, node) {
+  return ctx.geom.nodes[node.key] ?? { top: 0, height: 0, left: 0, width: 0 };
+}
+var EPS = 0.01;
+function bestBreak(ctx, list, limit, minY) {
+  const visible = (from, step) => {
+    for (let j = from; j >= 0 && j < list.length; j += step) {
+      const s = list[j];
+      if (g(ctx, s).height > EPS) return s;
+    }
+    return void 0;
+  };
+  for (let i = list.length - 1; i >= 0; i--) {
+    const child = list[i];
+    const cg = g(ctx, child);
+    const top = cg.top;
+    const bottom = cg.top + cg.height;
+    if (top > limit + EPS) continue;
+    if (cg.height <= EPS) continue;
+    const next = visible(i + 1, 1);
+    if (bottom > limit + EPS) {
+      const inner = breakInside(ctx, child, limit, minY);
+      if (inner !== null && inner > minY + EPS && inner > top + EPS) return inner;
+    } else {
+      const candidate = next ? Math.min(g(ctx, next).top, limit) : Math.min(bottom, limit);
+      const blocked = child.flow.keepWithNext && !!next;
+      if (!blocked && candidate > minY + EPS) return candidate;
+      if (!blocked) return null;
+    }
+    const prev = visible(i - 1, -1);
+    const prevBlocks = !!prev && prev.flow.keepWithNext;
+    if (!prevBlocks && top > minY + EPS) return top;
+    if (!prevBlocks) return null;
+  }
+  return null;
+}
+function breakInside(ctx, node, limit, minY) {
+  const ng = g(ctx, node);
+  const fitsOnFreshPage = ng.height <= ctx.pageHeight + EPS;
+  if (node.flow.keepTogether && fitsOnFreshPage) return null;
+  if (node.role === "row" && node.children.length > 1) {
+    const allowSplit = node.props.allowSplit === true;
+    if (!allowSplit && fitsOnFreshPage) return null;
+    return columnsAgree(ctx, node.children, limit, minY);
+  }
+  switch (node.flow.split) {
+    case "none":
+      return null;
+    case "lines": {
+      const lines = ng.lines;
+      if (!lines || lines.length < 2) return null;
+      const minOrphans = Math.max(1, node.flow.minOrphans);
+      const minWidows = Math.max(1, node.flow.minWidows);
+      for (let i = lines.length - 2; i >= 0; i--) {
+        const y = lines[i];
+        if (y > limit + EPS) continue;
+        const before = i + 1;
+        const after = lines.length - before;
+        if (before < minOrphans) return null;
+        if (after < minWidows) continue;
+        return y > minY + EPS ? y : null;
+      }
+      return null;
+    }
+    case "rows": {
+      const rows = ng.rows;
+      if (!rows || rows.length === 0) return null;
+      const body = rows.filter((r) => r.kind === "body");
+      if (body.length < 2) return null;
+      const minOrphans = Math.max(1, node.flow.minOrphans);
+      const minWidows = Math.max(1, node.flow.minWidows);
+      for (let i = body.length - 2; i >= 0; i--) {
+        const r = body[i];
+        const y = r.top + r.height;
+        if (y > limit + EPS) continue;
+        const before = i + 1;
+        const after = body.length - before;
+        if (before < minOrphans) return null;
+        if (after < minWidows) continue;
+        return y > minY + EPS ? y : null;
+      }
+      return null;
+    }
+    case "children":
+      return bestBreak(ctx, node.children, limit, minY);
+  }
+}
+function columnsAgree(ctx, columns, limit, minY) {
+  let y = limit;
+  for (let iter = 0; iter < 64; iter++) {
+    let yNext = y;
+    for (const col of columns) {
+      const kids = col.children;
+      if (kids.length === 0) continue;
+      const first = g(ctx, kids[0]).top;
+      const lastG = g(ctx, kids[kids.length - 1]);
+      const last = lastG.top + lastG.height;
+      if (y <= first + EPS || y >= last - EPS) continue;
+      const b = bestBreak(ctx, kids, y, minY);
+      if (b === null) return null;
+      if (b < yNext) yNext = b;
+    }
+    if (Math.abs(yNext - y) < EPS) return y > minY + EPS ? y : null;
+    y = yNext;
+  }
+  return null;
+}
+function collectTables(node, out = []) {
+  if (node.flow.split === "rows") out.push(node);
+  for (const c of node.children) collectTables(c, out);
+  return out;
+}
+function repeatedHeadersAt(geom, tables, from) {
+  const out = [];
+  for (const t of tables) {
+    const tg = geom.nodes[t.key];
+    if (!tg?.rows) continue;
+    const headerRows = tg.rows.filter((r) => r.kind === "header");
+    if (headerRows.length === 0) continue;
+    const bottom = tg.top + tg.height;
+    if (tg.top < from - EPS && from < bottom - EPS) {
+      const height = headerRows.reduce((a, r) => a + r.height, 0);
+      out.push({ tableKey: t.key, height, left: tg.left, width: tg.width });
+    }
+  }
+  return out;
+}
+function forcedBreaks(section, geom) {
+  const offsets = /* @__PURE__ */ new Set();
+  let contentTop = Number.POSITIVE_INFINITY;
+  let contentBottom = 0;
+  const visit = (n) => {
+    const g2 = geom.nodes[n.key];
+    if (g2) {
+      if (n.flow.breakBefore === "page") offsets.add(g2.top);
+      if (n.flow.breakAfter === "page") offsets.add(g2.top + g2.height);
+    }
+    n.children.forEach(visit);
+  };
+  for (const child of section.children) {
+    const g2 = geom.nodes[child.key];
+    if (g2) {
+      contentTop = Math.min(contentTop, g2.top);
+      contentBottom = Math.max(contentBottom, g2.top + g2.height);
+    }
+    visit(child);
+  }
+  if (!Number.isFinite(contentTop)) contentTop = 0;
+  return {
+    inside: [...offsets].filter((y) => y > contentTop + EPS && y < contentBottom - EPS).sort((a, b) => a - b),
+    atStart: [...offsets].some((y) => y <= contentTop + EPS),
+    atEnd: [...offsets].some((y) => y >= contentBottom - EPS)
+  };
+}
+function paginate(opts) {
+  const { document, geometry, page } = opts;
+  const pageHeight = page.contentHeight;
+  const warnings = [];
+  const pages = [];
+  let current2 = { index: 0, number: 1, fragments: [], first: true };
+  let y = 0;
+  let pendingBreak = false;
+  const newPage = () => {
+    pages.push(current2);
+    current2 = { index: pages.length, number: pages.length + 1, fragments: [], first: false };
+    y = 0;
+    pendingBreak = false;
+  };
+  for (const section of document.body) {
+    const geom = geometry[section.key];
+    if (!geom) {
+      warnings.push({ code: "forced-split", message: "Section was not measured", sectionKey: section.key, nodeId: section.nodeId });
+      continue;
+    }
+    const H = geom.height;
+    const ctx = { geom, pageHeight };
+    const tables = collectTables(section);
+    const forced = forcedBreaks(section, geom);
+    const contentBottom = section.children.reduce((m, c) => {
+      const cg = geom.nodes[c.key];
+      return cg ? Math.max(m, cg.top + cg.height) : m;
+    }, 0);
+    if ((pendingBreak || section.flow.breakBefore === "page" || forced.atStart) && y > 0) newPage();
+    if (section.flow.keepTogether && H > pageHeight - y + EPS && H <= pageHeight + EPS && y > 0) newPage();
+    if (H <= EPS) {
+      continue;
+    }
+    let from = 0;
+    let guard = 0;
+    while (from < H - EPS) {
+      if (++guard > 1e4) {
+        warnings.push({ code: "forced-split", message: "Pagination aborted after too many fragments", sectionKey: section.key, nodeId: section.nodeId });
+        break;
+      }
+      const avail = pageHeight - y;
+      const headers = repeatedHeadersAt(geom, tables, from);
+      const extra = headers.reduce((a, h2) => a + h2.height, 0);
+      const stop = forced.inside.find((f) => f > from + EPS) ?? H;
+      const lastPass = stop >= H - EPS;
+      const remaining = stop - from;
+      if (remaining + extra <= avail + EPS) {
+        current2.fragments.push({ sectionKey: section.key, from, to: stop, repeatHeaders: headers, y, height: remaining + extra, continued: from > 0, continues: !lastPass });
+        y += remaining + extra;
+        from = stop;
+        if (lastPass) break;
+        newPage();
+        continue;
+      }
+      const limit = Math.min(from + avail - extra, stop);
+      let to = null;
+      if (limit > from + EPS) {
+        to = section.flow.split === "children" ? bestBreak(ctx, section.children, limit, from) : null;
+        if (to !== null && to <= from + EPS) to = null;
+        if (to !== null && to > limit + EPS) to = null;
+        if (lastPass && to !== null && to >= contentBottom - EPS) {
+          current2.fragments.push({ sectionKey: section.key, from, to: H, repeatHeaders: headers, y, height: Math.min(H - from + extra, avail), continued: from > 0, continues: false });
+          y += Math.min(H - from + extra, avail);
+          from = H;
+          break;
+        }
+      }
+      if (to === null) {
+        if (y > 0 || current2.fragments.length > 0) {
+          newPage();
+          continue;
+        }
+        if (limit <= from + EPS) {
+          warnings.push({ code: "oversized-header", message: "A repeated table header is taller than the page", sectionKey: section.key, nodeId: section.nodeId, page: current2.number });
+          to = Math.min(H, from + Math.max(1, pageHeight));
+        } else {
+          to = Math.min(H, limit);
+          warnings.push({ code: "forced-split", message: "Content taller than a page had to be cut at an arbitrary position", sectionKey: section.key, nodeId: section.nodeId, page: current2.number });
+        }
+      }
+      current2.fragments.push({ sectionKey: section.key, from, to, repeatHeaders: headers, y, height: to - from + extra, continued: from > 0, continues: true });
+      from = to;
+      newPage();
+    }
+    if (section.flow.breakAfter === "page" || forced.atEnd) pendingBreak = true;
+  }
+  pages.push(current2);
+  while (pages.length > 1 && pages[pages.length - 1].fragments.length === 0) pages.pop();
+  if (pendingBreak) {
+    warnings.push({ code: "no-op-break", message: "A page break after the last content has nothing to move to a new page", page: pages.length });
+  }
+  const minPages = Math.max(1, opts.minPages ?? 1);
+  while (pages.length < minPages) pages.push({ index: pages.length, number: pages.length + 1, fragments: [], first: pages.length === 0 });
+  if (document.body.length === 0) warnings.push({ code: "empty-document", message: "The document has no content" });
+  if (opts.regionGeometry) {
+    const check2 = (sections, limit, region) => {
+      if (!sections) return;
+      const total = sections.reduce((a, s) => a + (opts.regionGeometry[s.key]?.height ?? 0), 0);
+      if (total > limit + 0.5) warnings.push({ code: "region-overflow", message: `${region} content (${Math.round(total)}px) is taller than the ${region.toLowerCase()} region (${Math.round(limit)}px) and will be clipped` });
+    };
+    check2(document.header.default, page.headerHeight, "Header");
+    check2(document.header.firstPage, page.headerHeight, "First-page header");
+    check2(document.footer.default, page.footerHeight, "Footer");
+    check2(document.footer.firstPage, page.footerHeight, "First-page footer");
+  }
+  return { pages, totalPages: pages.length, geometry: page, warnings };
+}
+
+// src/validate/issues.ts
+function issue(severity, code, message, extra = {}) {
+  return { severity, code, message, ...extra };
+}
+
+// src/validate/validate.ts
+function validateTemplate(opts) {
+  const issues = [];
+  const { template, registry } = opts;
+  const dataSources = opts.dataSources ?? [];
+  const theme = mergeTheme(opts.theme);
+  if (!opts.skipSchema) {
+    const parsed = parseTemplate(template);
+    for (const e of parsed.errors) issues.push(issue("error", "schema-invalid", `${e.path}: ${e.message}`, { region: "document" }));
+  }
+  if (opts.theme) for (const m of missingThemeValues(opts.theme)) issues.push(issue("warning", "missing-theme-value", `Theme "${opts.theme.name ?? opts.theme.id ?? ""}" has no value for ${m}; the default is used`, { region: "document" }));
+  const rootScope = createSchemaScope(dataSources);
+  const sourceIds = new Set(dataSources.map((s) => s.id));
+  for (const id of template.settings?.dataSources ?? []) if (!sourceIds.has(id)) issues.push(issue("warning", "unknown-binding", `Template was designed against data source "${id}" which is not provided`, { region: "document" }));
+  const fonts = /* @__PURE__ */ new Set([...opts.availableFonts ?? [], ...(theme.fonts ?? []).map((f) => f.family), ...splitFonts(theme.typography.headingFont), ...splitFonts(theme.typography.bodyFont), ...splitFonts(theme.typography.monoFont ?? "")]);
+  const checkFont = (value, where) => {
+    if (!value || isTokenRef(value) || !opts.availableFonts) return;
+    const families = splitFonts(value);
+    if (!families.some((f) => fonts.has(f) || GENERIC_FONTS.has(f.toLowerCase()))) issues.push(issue("warning", "unsupported-font", `Font "${value}" is not available; the theme body font will be used`, where));
+  };
+  const checkColor = (value, where) => {
+    if (!value || !isTokenRef(value)) return;
+    if (resolveToken(value, theme) === void 0) issues.push(issue("warning", "missing-theme-token", `Theme token "${value}" does not exist`, where));
+  };
+  for (const [id, ts] of Object.entries(template.styles.text)) {
+    checkFont(ts.fontFamily, { region: "document", prop: `styles.text.${id}.fontFamily` });
+    checkColor(ts.color, { region: "document", prop: `styles.text.${id}.color` });
+  }
+  const geometry = computePageGeometry(template.page);
+  if (geometry.contentHeight < 100) issues.push(issue("error", "layout-invalid", "Page margins, header and footer leave less than 100px for content", { region: "document" }));
+  if (geometry.contentWidth < 100) issues.push(issue("error", "layout-invalid", "Page margins leave less than 100px of width for content", { region: "document" }));
+  const regionOf = (r) => r === "body" ? "body" : r.startsWith("header") ? "header" : "footer";
+  const visitNode = (node, region, parent, scope) => {
+    const where = { nodeId: node.id, region: regionOf(region) };
+    const def = registry.get(node.type);
+    if (!def) {
+      issues.push(issue("error", "unknown-block", `Block type "${node.type}" is not registered${node.type.includes(".") ? " (custom block unavailable)" : ""}`, where));
+      return;
+    }
+    if (!registry.isTierEnabled(def.license)) issues.push(issue("warning", "license-required", `"${def.name}" requires the ${def.license} tier`, where));
+    if (parent) {
+      if (!registry.accepts(parent.type, node.type)) issues.push(issue("error", "layout-invalid", `"${def.name}" cannot be placed inside "${registry.get(parent.type)?.name ?? parent.type}"`, where));
+    } else if (node.type !== "section") issues.push(issue("error", "layout-invalid", `Top-level nodes must be sections, found "${node.type}"`, where));
+    if (node.type === "row") {
+      const layout = node.props.layout;
+      const total = (layout ?? []).reduce((a, b) => a + b, 0);
+      if (!layout || total !== 12) issues.push(issue("error", "layout-invalid", `Row layout must sum to 12 (got ${total})`, where));
+      else if ((node.children?.length ?? 0) !== layout.length) issues.push(issue("error", "layout-invalid", `Row has ${node.children?.length ?? 0} columns but a ${layout.length}-column layout`, where));
+    }
+    if (node.style) {
+      checkFont(node.style.fontFamily, { ...where, prop: "style.fontFamily" });
+      checkColor(node.style.color, { ...where, prop: "style.color" });
+      checkColor(node.style.background, { ...where, prop: "style.background" });
+      checkColor(node.style.border?.color, { ...where, prop: "style.border.color" });
+      if (node.style.textStyle && !template.styles.text[node.style.textStyle]) issues.push(issue("warning", "missing-theme-token", `Text style "${node.style.textStyle}" is not defined in the document styles`, { ...where, prop: "style.textStyle" }));
+    }
+    const cond = compileCondition(node.visibleWhen);
+    if (cond) checkExpr(cond, "visibleWhen", "condition");
+    const props = { ...typeof def.defaultProps === "function" ? def.defaultProps() : def.defaultProps, ...node.props };
+    function checkExpr(expr, prop, kind, s = scope, expected) {
+      const out = [];
+      const r = typeCheck(expr, s);
+      for (const i of r.issues) {
+        const code = i.code === "syntax" ? "invalid-expression" : i.code === "type-mismatch" ? "type-mismatch" : "unknown-binding";
+        out.push(issue(i.code === "syntax" ? "error" : "warning", kind === "condition" && code !== "unknown-binding" ? "invalid-condition" : code, `${i.message} in "${expr}"`, { ...where, prop }));
+      }
+      if (kind === "collection" && r.issues.length === 0 && r.type !== "array" && r.type !== "any" && r.type !== "unknown") out.push(issue("error", "missing-collection", `"${expr}" is a ${r.type}, not a list`, { ...where, prop }));
+      if (expected && r.issues.length === 0 && r.type !== "unknown" && r.type !== "any" && r.type !== "null") {
+        const list = Array.isArray(expected) ? expected : [expected];
+        const numeric = ["number", "currency", "percent"];
+        const compatible = list.includes(r.type) || list.some((t) => numeric.includes(t)) && numeric.includes(r.type) || list.includes("string") && r.type !== "array" && r.type !== "object";
+        if (!compatible) out.push(issue("warning", "type-mismatch", `"${expr}" is a ${r.type}; expected ${list.join(" or ")}`, { ...where, prop }));
+      }
+      issues.push(...out);
+      return out;
+    }
+    const runSpec = (spec, target, prefix, s) => {
+      const value = getPath2(target, spec.prop);
+      const prop = prefix + spec.prop;
+      switch (spec.kind) {
+        case "value":
+          if (typeof value === "string" && value.trim()) checkExpr(value, prop, "value", s, spec.valueType);
+          break;
+        case "collection":
+          if (typeof value === "string" && value.trim()) checkExpr(value, prop, "collection", s);
+          else if (def.container?.repeat?.collectionProp === spec.prop) issues.push(issue("warning", "missing-collection", `"${def.name}" has no list to repeat over`, { ...where, prop }));
+          else if (def.type === "table" || def.type === "chart") issues.push(issue("warning", "missing-collection", `"${def.name}" is not bound to a list`, { ...where, prop }));
+          break;
+        case "template":
+          if (typeof value === "string") for (const e of extractTemplateTokens(value)) checkExpr(e, prop, "value", s);
+          break;
+        case "richtext":
+          if (isRichTextDoc(value)) for (const e of richTextTokens(value)) checkExpr(e, prop, "value", s);
+          break;
+        case "condition": {
+          const c = compileCondition(value);
+          if (c) checkExpr(c, prop, "condition", s);
+          break;
+        }
+        case "list":
+          break;
+      }
+    };
+    let itemScope = scope;
+    let childScope = scope;
+    const specs = bindingSpecsFor(def);
+    for (const spec of specs) {
+      if (spec.kind !== "collection") continue;
+      const collectionExpr = props[spec.prop];
+      const itemSchema = typeof collectionExpr === "string" && collectionExpr.trim() ? itemSchemaOf(collectionExpr, scope) : void 0;
+      const alias = spec.alias && props[spec.alias] || "item";
+      if (dataSources.some((d) => d.id === alias)) issues.push(issue("warning", "scope-shadowing", `Repeater alias "${alias}" hides the data source with the same name`, where));
+      const vars = {
+        [alias]: itemSchema ?? { type: "object", label: alias, fields: {} },
+        item: itemSchema ?? { type: "object", label: "Item", fields: {} },
+        row: itemSchema ?? { type: "object", label: "Row", fields: {} },
+        index: { type: "number" },
+        first: { type: "boolean" },
+        last: { type: "boolean" },
+        count: { type: "number" }
+      };
+      itemScope = scope.child(vars);
+      if (def.container?.repeat?.collectionProp === spec.prop) childScope = itemScope;
+    }
+    for (const spec of specs) {
+      if (spec.perItem) {
+        runSpec(spec, props, "", itemScope);
+        continue;
+      }
+      if (spec.items) {
+        const list = getPath2(props, spec.prop);
+        if (Array.isArray(list)) list.forEach((item, i) => item && typeof item === "object" && spec.items.forEach((sub) => runSpec(sub, item, `${spec.prop}.${i}.`, sub.perItem ? itemScope : scope)));
+        continue;
+      }
+      runSpec(spec, props, "", scope);
+      if (spec.kind === "collection") for (const sub of spec.scoped ?? []) runSpec(sub, props, "", itemScope);
+    }
+    if (def.validate) {
+      const vctx = {
+        props,
+        node,
+        schemaScope: itemScope,
+        dataSources,
+        theme,
+        checkExpression: (expr, prop) => checkExpr(expr, prop, "value", itemScope)
+      };
+      try {
+        const extra = def.validate(vctx);
+        for (const i of extra) issues.push({ ...i, nodeId: i.nodeId ?? node.id, region: i.region ?? where.region });
+      } catch (e) {
+        issues.push(issue("warning", "custom", `Validation for "${def.name}" failed: ${e.message}`, where));
+      }
+    }
+    for (const child of node.children ?? []) visitNode(child, region, node, childScope);
+  };
+  const visitRegion = (nodes, region) => nodes.forEach((n) => visitNode(n, region, null, rootScope));
+  visitRegion(template.body, "body");
+  visitRegion(template.header.default, "header");
+  visitRegion(template.header.firstPage ?? [], "header:first");
+  visitRegion(template.footer.default, "footer");
+  visitRegion(template.footer.firstPage ?? [], "footer:first");
+  if (template.body.every((s) => (s.children?.length ?? 0) === 0)) issues.push(issue("info", "empty-content", "The document has no content yet", { region: "body" }));
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  return { ok: errors.length === 0, issues, errors, warnings };
+}
+var GENERIC_FONTS = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "system-ui", "ui-sans-serif", "ui-serif", "ui-monospace", "cursive", "fantasy", "inherit"]);
+function splitFonts(value) {
+  return value.split(",").map((f) => f.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+function getPath2(obj, path) {
+  let cur = obj;
+  for (const p of path.split(".")) {
+    if (cur === null || cur === void 0 || typeof cur !== "object") return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function itemSchemaOf(collectionExpr, scope) {
+  try {
+    const ast = parseExpression(collectionExpr);
+    const base = ast.kind === "pipe" ? unwrapPipes(ast) : ast;
+    if (base.kind !== "path") return void 0;
+    const r = resolvePathSchema(base.segments, scope);
+    return r.schema?.type === "array" ? r.schema.itemSchema : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function unwrapPipes(e) {
+  let cur = e;
+  while (cur.kind === "pipe") cur = cur.input;
+  return cur;
+}
+function isSafeUrl(url, opts = {}) {
+  if (!url) return false;
+  const u = url.trim();
+  if (/^https?:\/\//i.test(u)) return true;
+  if (/^mailto:/i.test(u)) return true;
+  if (u.startsWith("/") && !u.startsWith("//")) return true;
+  if (u.startsWith("./") || u.startsWith("../")) return true;
+  if (opts.allowData && /^data:image\/(png|jpe?g|gif|webp|svg\+xml)[;,]/i.test(u)) {
+    if (!/^data:image\/svg\+xml/i.test(u)) return true;
+    const comma = u.indexOf(",");
+    const payload = comma === -1 ? "" : u.slice(comma + 1);
+    let decoded;
+    if (/;base64/i.test(u.slice(0, comma === -1 ? u.length : comma))) {
+      decoded = decodeBase64(payload);
+    } else {
+      try {
+        decoded = decodeURIComponent(payload);
+      } catch {
+        decoded = payload;
+      }
+    }
+    return !/<script|javascript:|on[a-z]+\s*=|<foreignObject/i.test(decoded);
+  }
+  return false;
+}
+function decodeBase64(value) {
+  const b64 = value.trim();
+  try {
+    const g2 = globalThis;
+    if (typeof g2.atob === "function") return g2.atob(b64);
+    if (g2.Buffer) return g2.Buffer.from(b64, "base64").toString("utf8");
+  } catch {
+  }
+  return "<script";
+}
+
+// src/validate/output.ts
+function checkOutput(opts) {
+  const { resolved, registry } = opts;
+  const limit = opts.limit ?? 60;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const suffix = opts.dataLabel ? ` in \u201C${opts.dataLabel}\u201D` : " in this data set";
+  const push = (i) => {
+    const key = `${i.nodeId ?? ""}|${i.prop ?? ""}|${i.message}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(i);
+  };
+  const blankDocument = resolved.body.every((s) => s.children.length === 0);
+  const regions = [
+    [resolved.body, "body"],
+    [resolved.header.default, "header"],
+    [resolved.header.firstPage ?? [], "header"],
+    [resolved.footer.default, "footer"],
+    [resolved.footer.firstPage ?? [], "footer"]
+  ];
+  for (const [nodes, region] of regions) for (const n of nodes) visit(n, region);
+  return out.slice(0, limit);
+  function visit(node, region) {
+    if (!node.placeholder) inspect(node, region);
+    for (const c of node.children) visit(c, region);
+  }
+  function inspect(node, region) {
+    const def = registry.get(node.type);
+    const name = node.label || def?.name || node.type;
+    const where = { nodeId: node.nodeId, region, source: "output" };
+    for (const [prop, b] of Object.entries(node.bindings)) {
+      if (b.kind !== "value" && b.kind !== "template") continue;
+      if (node.textSegments[prop]?.some((s) => s.deferred)) continue;
+      if (handlesEmpty(b.expr)) continue;
+      const value = getPath3(node.props, prop);
+      if (!isBlank(value)) continue;
+      const blank = !drawsWithout(node, prop);
+      push(
+        issue(
+          "warning",
+          "empty-value",
+          blank ? `\u201C${b.label}\u201D has no value${suffix}, so ${name} renders blank` : `\u201C${b.label}\u201D has no value${suffix} and is left out of ${name}`,
+          { ...where, prop }
+        )
+      );
+    }
+    for (const [prop, segments] of Object.entries(node.textSegments)) {
+      if (node.bindings[prop]) continue;
+      for (const s of segments) {
+        if (s.kind !== "token" || s.deferred || !s.expr) continue;
+        if (s.value === void 0 || !isBlank(s.value)) continue;
+        if (handlesEmpty(s.expr)) continue;
+        push(issue("warning", "empty-value", `\u201C${s.label ?? short(s.expr)}\u201D is empty${suffix}, leaving a gap in ${name}`, { ...where, prop }));
+      }
+    }
+    for (const [prop, doc] of Object.entries(node.richText)) {
+      for (const inline of inlinesOf(doc)) {
+        if (inline.type !== "token" || inline.deferred) continue;
+        if (inline.value === void 0 || !isBlank(inline.value)) continue;
+        if (handlesEmpty(inline.expr)) continue;
+        push(issue("warning", "empty-value", `\u201C${inline.label ?? short(inline.expr)}\u201D is empty${suffix}, leaving a gap in ${name}`, { ...where, prop }));
+      }
+    }
+    if (node.children.length === 0 && !hasOwnContent(node) && carriesText(node)) {
+      push(issue("warning", "empty-content", `${name} renders nothing${suffix}`, where));
+    }
+    if (node.role === "section" && !blankDocument && !subtreeHasContent(node)) {
+      push(issue("warning", "empty-content", `Section \u201C${name}\u201D has no visible content${suffix}`, where));
+    }
+  }
+  function ownText(node, skip) {
+    let text = "";
+    for (const [prop, segments] of Object.entries(node.textSegments)) {
+      if (prop === skip) continue;
+      for (const s of segments) text += s.kind === "text" ? s.text : s.deferred ? "1" : s.value ?? "";
+    }
+    for (const [prop, doc] of Object.entries(node.richText)) {
+      if (prop === skip) continue;
+      for (const inline of inlinesOf(doc)) text += inline.type === "token" ? inline.deferred ? "1" : inline.value ?? "" : inline.type === "text" ? inline.text : "";
+    }
+    for (const [prop, b] of Object.entries(node.bindings)) {
+      if (prop === skip) continue;
+      if (b.kind === "value") text += String(getPath3(node.props, prop) ?? "");
+      else if (b.kind === "collection") {
+        const v = getPath3(node.props, prop);
+        if (Array.isArray(v) && v.length) text += "1";
+      }
+    }
+    return text.trim();
+  }
+  function drawsWithout(node, prop) {
+    if (ownText(node, prop) !== "") return true;
+    return node.children.some(subtreeHasContent) || staticProps(node, prop);
+  }
+  function staticProps(node, skip) {
+    for (const [prop, value] of Object.entries(node.props)) {
+      if (prop === skip || prop.startsWith("__")) continue;
+      if (node.bindings[prop]) continue;
+      if (typeof value === "string" && value.trim() !== "") return true;
+    }
+    return false;
+  }
+  function hasOwnContent(node) {
+    return ownText(node) !== "";
+  }
+  function carriesText(node) {
+    return Object.keys(node.textSegments).length > 0 || Object.keys(node.richText).length > 0;
+  }
+  function subtreeHasContent(node) {
+    if (DECORATION.has(node.type)) return false;
+    const def = registry.get(node.type);
+    if (def?.category === "visualisation" && !DECORATION.has(node.type)) return true;
+    if (node.type === "image" || node.type === "logo" || node.type === "signature") return true;
+    if (hasOwnContent(node)) return true;
+    return node.children.some(subtreeHasContent);
+  }
+}
+function inlinesOf(doc) {
+  const out = [];
+  for (const block of doc.content) {
+    const paras = block.type === "paragraph" ? [block] : block.content.flatMap((li) => li.content);
+    for (const p of paras) out.push(...p.content);
+  }
+  return out;
+}
+var DECORATION = /* @__PURE__ */ new Set(["spacer", "divider", "pageBreak"]);
+function handlesEmpty(expr) {
+  try {
+    return guards(parseExpression(expr));
+  } catch {
+    return false;
+  }
+}
+function guards(node) {
+  switch (node.kind) {
+    case "conditional":
+      return true;
+    case "pipe":
+      return node.name === "default" || guards(node.input);
+    case "binary":
+      return node.op === "or" || node.op === "and" || guards(node.left) || guards(node.right);
+    case "call":
+      return node.name === "coalesce" || node.name === "default";
+    default:
+      return false;
+  }
+}
+function short(expr) {
+  return expr.length > 48 ? `${expr.slice(0, 47)}\u2026` : expr;
+}
+function isBlank(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  return false;
+}
+function getPath3(obj, path) {
+  let cur = obj;
+  for (const p of path.split(".")) {
+    if (cur === null || cur === void 0 || typeof cur !== "object") return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+// src/editor/tree.ts
+var REGION_IDS = ["body", "header", "header:first", "footer", "footer:first"];
+function getRegion(template, region) {
+  switch (region) {
+    case "body":
+      return template.body;
+    case "header":
+      return template.header.default;
+    case "header:first":
+      return template.header.firstPage ??= [];
+    case "footer":
+      return template.footer.default;
+    case "footer:first":
+      return template.footer.firstPage ??= [];
+  }
+}
+function readRegion(template, region) {
+  switch (region) {
+    case "body":
+      return template.body;
+    case "header":
+      return template.header.default;
+    case "header:first":
+      return template.header.firstPage ?? [];
+    case "footer":
+      return template.footer.default;
+    case "footer:first":
+      return template.footer.firstPage ?? [];
+  }
+}
+function indexTemplate(template) {
+  const index = /* @__PURE__ */ new Map();
+  const visit = (nodes, parent, region, path) => {
+    nodes.forEach((node, i) => {
+      const p = [...path, i];
+      index.set(node.id, { node, parent, region, path: p, depth: p.length - 1, index: i });
+      if (node.children) visit(node.children, node, region, p);
+    });
+  };
+  for (const r of REGION_IDS) visit(readRegion(template, r), null, r, []);
+  return index;
+}
+function findNode(template, id) {
+  return indexTemplate(template).get(id);
+}
+function listAt(template, location) {
+  let list = getRegion(template, location.region);
+  for (let i = 0; i < location.path.length - 1; i++) {
+    const n = list[location.path[i]];
+    if (!n) throw new Error("Invalid node path");
+    n.children ??= [];
+    list = n.children;
+  }
+  return { list, index: location.path[location.path.length - 1] ?? 0 };
+}
+function nodeAt(template, location) {
+  const { list, index } = listAt(template, location);
+  return list[index];
+}
+function ancestors(index, id) {
+  const chain = [];
+  let cur = index.get(id);
+  while (cur) {
+    chain.unshift(cur);
+    cur = cur.parent ? index.get(cur.parent.id) : void 0;
+  }
+  return chain;
+}
+function isDescendant(index, ancestorId, id) {
+  let cur = index.get(id);
+  while (cur?.parent) {
+    if (cur.parent.id === ancestorId) return true;
+    cur = index.get(cur.parent.id);
+  }
+  return false;
+}
+function walkTemplate(template, visit) {
+  const rec = (nodes, region, parent) => {
+    for (const n of nodes) {
+      visit(n, region, parent);
+      if (n.children) rec(n.children, region, n);
+    }
+  };
+  for (const r of REGION_IDS) rec(readRegion(template, r), r, null);
+}
+function countNodes(template) {
+  let n = 0;
+  walkTemplate(template, () => n++);
+  return n;
+}
+function usedBlockTypes(template) {
+  const s = /* @__PURE__ */ new Set();
+  walkTemplate(template, (n) => s.add(n.type));
+  return s;
+}
+
+// src/editor/commands.ts
+import { current, isDraft } from "immer";
+var CommandError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CommandError";
+  }
+};
+function setDeep(obj, path, value) {
+  const parts = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const p = parts[i];
+    const next = cur[p];
+    if (Array.isArray(next)) cur = next;
+    else if (next && typeof next === "object") cur = next;
+    else {
+      cur[p] = {};
+      cur = cur[p];
+    }
+  }
+  const last = parts[parts.length - 1];
+  if (value === void 0) delete cur[last];
+  else cur[last] = value;
+}
+function applyCommand(draft, cmd) {
+  const t = draft;
+  switch (cmd.type) {
+    case "insertNode": {
+      const { list, index } = listAt(t, cmd.at);
+      list.splice(Math.min(index, list.length), 0, cmd.node);
+      return;
+    }
+    case "insertNodes": {
+      const { list, index } = listAt(t, cmd.at);
+      list.splice(Math.min(index, list.length), 0, ...cmd.nodes);
+      return;
+    }
+    case "removeNodes": {
+      const index = indexTemplate(t);
+      const entries = cmd.ids.map((id) => index.get(id)).filter((e) => !!e);
+      entries.sort((a, b) => b.depth - a.depth || b.index - a.index);
+      for (const e of entries) {
+        const list = e.parent ? e.parent.children ??= [] : getRegion(t, e.region);
+        const i = list.findIndex((n) => n.id === e.node.id);
+        if (i >= 0) list.splice(i, 1);
+      }
+      return;
+    }
+    case "moveNode": {
+      const index = indexTemplate(t);
+      const entry = index.get(cmd.id);
+      if (!entry) throw new CommandError(`Node ${cmd.id} not found`);
+      const target = listAt(t, cmd.to);
+      let probe = target.list === entry.node.children ? entry.node : void 0;
+      if (probe) throw new CommandError("Cannot move a node inside itself");
+      const containerPath = cmd.to.path.slice(0, -1);
+      let cur = getRegion(t, cmd.to.region);
+      for (const i of containerPath) {
+        const n = cur[i];
+        if (!n) break;
+        if (n.id === cmd.id) throw new CommandError("Cannot move a node inside itself");
+        cur = n.children ?? [];
+      }
+      void probe;
+      const sourceList = entry.parent ? entry.parent.children ??= [] : getRegion(t, entry.region);
+      const sourceIndex = sourceList.indexOf(entry.node);
+      const [node] = sourceList.splice(sourceIndex, 1);
+      const dest = listAt(t, cmd.to);
+      let destIndex = dest.index;
+      if (dest.list === sourceList && sourceIndex < destIndex) destIndex--;
+      dest.list.splice(Math.min(destIndex, dest.list.length), 0, node);
+      return;
+    }
+    case "duplicateNode": {
+      const index = indexTemplate(t);
+      const entry = index.get(cmd.id);
+      if (!entry) throw new CommandError(`Node ${cmd.id} not found`);
+      const list = entry.parent ? entry.parent.children ??= [] : getRegion(t, entry.region);
+      const copy = cloneWithNewIds(isDraft(entry.node) ? current(entry.node) : entry.node);
+      if (cmd.newId) copy.id = cmd.newId;
+      list.splice(entry.index + 1, 0, copy);
+      return;
+    }
+    case "setProps": {
+      const n = requireNode(t, cmd.id);
+      for (const [k, v] of Object.entries(cmd.patch)) {
+        if (v === void 0) delete n.props[k];
+        else n.props[k] = v;
+      }
+      return;
+    }
+    case "setProp": {
+      const n = requireNode(t, cmd.id);
+      setDeep(n.props, cmd.path, cmd.value);
+      return;
+    }
+    case "setStyle": {
+      const n = requireNode(t, cmd.id);
+      if (cmd.patch === null) {
+        delete n.style;
+        return;
+      }
+      n.style ??= {};
+      mergeStyle(n.style, cmd.patch);
+      if (Object.keys(n.style).length === 0) delete n.style;
+      return;
+    }
+    case "setFlow": {
+      const n = requireNode(t, cmd.id);
+      n.flow = { ...n.flow ?? {}, ...cmd.patch };
+      for (const k of Object.keys(n.flow)) if (n.flow[k] === void 0) delete n.flow[k];
+      if (Object.keys(n.flow).length === 0) delete n.flow;
+      return;
+    }
+    case "setVisibleWhen": {
+      const n = requireNode(t, cmd.id);
+      if (cmd.condition === void 0 || cmd.condition === "") delete n.visibleWhen;
+      else n.visibleWhen = cmd.condition;
+      return;
+    }
+    case "setName": {
+      const n = requireNode(t, cmd.id);
+      if (cmd.name) n.name = cmd.name;
+      else delete n.name;
+      return;
+    }
+    case "setLocked": {
+      const n = requireNode(t, cmd.id);
+      if (cmd.locked) n.locked = true;
+      else delete n.locked;
+      return;
+    }
+    case "setRowLayout": {
+      const row = requireNode(t, cmd.id);
+      if (row.type !== "row") throw new CommandError("setRowLayout requires a row");
+      const total = cmd.layout.reduce((a, b) => a + b, 0);
+      if (total !== 12) throw new CommandError("Row layout must sum to 12");
+      row.children ??= [];
+      const columns = row.children;
+      while (columns.length > cmd.layout.length) {
+        const removed = columns.pop();
+        const target = columns[columns.length - 1];
+        target.children ??= [];
+        target.children.push(...removed.children ?? []);
+      }
+      while (columns.length < cmd.layout.length) columns.push(createColumn(cmd.layout[columns.length]));
+      columns.forEach((c, i) => {
+        c.props.span = cmd.layout[i];
+      });
+      row.props.layout = [...cmd.layout];
+      return;
+    }
+    case "wrapNodes": {
+      const index = indexTemplate(t);
+      const entries = cmd.ids.map((id) => index.get(id)).filter((e) => !!e);
+      if (entries.length === 0) return;
+      const first = entries[0];
+      const list = first.parent ? first.parent.children ??= [] : getRegion(t, first.region);
+      const nodes = entries.map((e) => e.node);
+      const startIndex = list.indexOf(first.node);
+      for (const n of nodes) {
+        const i = list.indexOf(n);
+        if (i >= 0) list.splice(i, 1);
+      }
+      const wrapper = { ...cmd.wrapper, children: [...cmd.wrapper.children ?? [], ...nodes.map((n) => isDraft(n) ? current(n) : n)] };
+      list.splice(Math.min(startIndex, list.length), 0, wrapper);
+      return;
+    }
+    case "replaceNode": {
+      const index = indexTemplate(t);
+      const entry = index.get(cmd.id);
+      if (!entry) throw new CommandError(`Node ${cmd.id} not found`);
+      const list = entry.parent ? entry.parent.children ??= [] : getRegion(t, entry.region);
+      list[entry.index] = cmd.node;
+      return;
+    }
+    case "setPage": {
+      Object.assign(t.page, structuredClone(cmd.patch));
+      return;
+    }
+    case "setDocumentStyles": {
+      const p = cmd.patch;
+      if (p.text) for (const [id, s] of Object.entries(p.text)) t.styles.text[id] = { ...t.styles.text[id] ?? {}, ...s };
+      if (p.table) Object.assign(t.styles.table, p.table);
+      if (p.card) Object.assign(t.styles.card, p.card);
+      if (p.link) Object.assign(t.styles.link, p.link);
+      if (p.spacing) Object.assign(t.styles.spacing, p.spacing);
+      return;
+    }
+    case "setTextStyle": {
+      if (cmd.patch === null) {
+        delete t.styles.text[cmd.id];
+        return;
+      }
+      const existing = t.styles.text[cmd.id] ?? {};
+      for (const [k, v] of Object.entries(cmd.patch)) {
+        if (v === void 0) delete existing[k];
+        else existing[k] = v;
+      }
+      t.styles.text[cmd.id] = existing;
+      return;
+    }
+    case "setTemplateName": {
+      t.name = cmd.name;
+      return;
+    }
+    case "setSettings": {
+      t.settings = { ...t.settings ?? {}, ...cmd.patch };
+      return;
+    }
+    case "setRegionFirstPage": {
+      t.page[cmd.region].differentFirstPage = cmd.enabled;
+      if (cmd.enabled && !t[cmd.region].firstPage) t[cmd.region].firstPage = (isDraft(t[cmd.region].default) ? current(t[cmd.region].default) : t[cmd.region].default).map(cloneWithNewIds);
+      return;
+    }
+    case "addLibraryItem": {
+      t.library ??= [];
+      t.library.push({ ...cmd.item, id: cmd.item.id || createId("lib") });
+      return;
+    }
+    case "removeLibraryItem": {
+      t.library = (t.library ?? []).filter((l) => l.id !== cmd.id);
+      return;
+    }
+    case "replaceTemplate": {
+      const fresh = structuredClone(cmd.template);
+      for (const k of Object.keys(t)) delete t[k];
+      Object.assign(t, fresh);
+      return;
+    }
+  }
+}
+function requireNode(t, id) {
+  const e = indexTemplate(t).get(id);
+  if (!e) throw new CommandError(`Node ${id} not found`);
+  return e.node;
+}
+function mergeStyle(target, patch) {
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === void 0 || v === null) {
+      delete target[k];
+      continue;
+    }
+    if ((k === "padding" || k === "margin" || k === "border") && typeof v === "object") {
+      const merged = { ...target[k] ?? {}, ...v };
+      for (const key of Object.keys(merged)) if (merged[key] === void 0) delete merged[key];
+      if (Object.keys(merged).length === 0) delete target[k];
+      else target[k] = merged;
+      continue;
+    }
+    target[k] = v;
+  }
+}
+
+// src/editor/store.ts
+import { produceWithPatches, applyPatches, enablePatches } from "immer";
+enablePatches();
+var EditorStore = class {
+  state;
+  undoStack = [];
+  redoStack = [];
+  listeners = /* @__PURE__ */ new Set();
+  txDepth = 0;
+  txPatches = [];
+  txInverse = [];
+  txLabel = "";
+  txSelectionBefore = [];
+  txSkipHistory = false;
+  indexCache = null;
+  /**
+   * The history entry that was on top of the undo stack when the document was
+   * last saved, so that undoing back to it reports clean again. Identity is the
+   * whole test: undo pops, redo pushes, and a new edit pushes something else.
+   */
+  savedEntry = null;
+  /** A change that bypassed history, which no amount of undoing can take back. */
+  unhistoried = false;
+  maxHistory;
+  mergeWindowMs;
+  onChange;
+  constructor(opts) {
+    this.state = {
+      template: opts.template,
+      selection: [],
+      hoverId: null,
+      editingId: null,
+      mode: "design",
+      zoom: 1,
+      activeRegion: "body",
+      dirty: false,
+      version: 0
+    };
+    this.maxHistory = opts.maxHistory ?? 200;
+    this.mergeWindowMs = opts.mergeWindowMs ?? 800;
+    this.onChange = opts.onChange;
+  }
+  /* ----------------------------- reading ----------------------------- */
+  getState() {
+    return this.state;
+  }
+  get template() {
+    return this.state.template;
+  }
+  /** Cached id → node index for the current document version. */
+  index() {
+    if (!this.indexCache || this.indexCache.version !== this.state.version) {
+      this.indexCache = { version: this.state.version, index: indexTemplate(this.state.template) };
+    }
+    return this.indexCache.index;
+  }
+  getNode(id) {
+    return this.index().get(id)?.node;
+  }
+  locationOf(id) {
+    const e = this.index().get(id);
+    return e ? { region: e.region, path: e.path } : void 0;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setState(next) {
+    const prev = this.state;
+    this.state = { ...prev, ...next };
+    for (const l of this.listeners) l(this.state, prev);
+  }
+  /* ------------------------------ UI state --------------------------- */
+  select(ids) {
+    const selection = ids === null ? [] : Array.isArray(ids) ? ids : [ids];
+    if (sameIds(selection, this.state.selection)) return;
+    this.setState({ selection, editingId: selection.length === 1 && this.state.editingId === selection[0] ? this.state.editingId : null });
+  }
+  toggleSelect(id) {
+    const has = this.state.selection.includes(id);
+    this.select(has ? this.state.selection.filter((s) => s !== id) : [...this.state.selection, id]);
+  }
+  hover(id) {
+    if (id !== this.state.hoverId) this.setState({ hoverId: id });
+  }
+  setEditing(id) {
+    if (id !== this.state.editingId) this.setState({ editingId: id, selection: id ? [id] : this.state.selection });
+  }
+  setMode(mode) {
+    if (mode !== this.state.mode) this.setState({ mode, editingId: null });
+  }
+  setZoom(zoom) {
+    const z2 = Math.min(3, Math.max(0.25, Math.round(zoom * 100) / 100));
+    if (z2 !== this.state.zoom) this.setState({ zoom: z2 });
+  }
+  setActiveRegion(region) {
+    if (region !== this.state.activeRegion) this.setState({ activeRegion: region });
+  }
+  markClean() {
+    this.savedEntry = this.undoStack[this.undoStack.length - 1] ?? null;
+    this.unhistoried = false;
+    if (this.state.dirty) this.setState({ dirty: false });
+  }
+  /** Whether the document differs from the last saved state. */
+  isDirty() {
+    if (this.unhistoried) return true;
+    return (this.undoStack[this.undoStack.length - 1] ?? null) !== this.savedEntry;
+  }
+  /* ------------------------------ commands --------------------------- */
+  /** Applies one command. Inside a transaction, patches accumulate into one history entry. */
+  dispatch(command, opts = {}) {
+    const [next, patches, inverse] = produceWithPatches(this.state.template, (draft) => {
+      applyCommand(draft, command);
+    });
+    if (patches.length === 0) return;
+    if (this.txDepth > 0) {
+      this.txPatches.push(...patches);
+      this.txInverse.unshift(...inverse);
+      if (opts.skipHistory) this.txSkipHistory = true;
+      this.commitTemplate(next, null);
+      return;
+    }
+    const selectionBefore = this.state.selection;
+    const entry = {
+      label: opts.label ?? labelFor2(command),
+      patches,
+      inversePatches: inverse,
+      selectionBefore,
+      selectionAfter: selectionBefore,
+      at: Date.now(),
+      mergeKey: opts.mergeKey
+    };
+    if (opts.skipHistory) this.unhistoried = true;
+    else this.pushHistory(entry);
+    this.commitTemplate(next, opts.skipHistory ? null : entry);
+  }
+  /**
+   * Groups every dispatch inside `fn` into a single undo step. Nested
+   * transactions join the outermost one. If `fn` throws, all changes roll back.
+   */
+  transaction(label, fn) {
+    if (this.txDepth === 0) {
+      this.txPatches = [];
+      this.txInverse = [];
+      this.txLabel = label;
+      this.txSelectionBefore = this.state.selection;
+      this.txSkipHistory = false;
+    }
+    this.txDepth++;
+    const before = this.state.template;
+    let result;
+    try {
+      result = fn();
+    } catch (e) {
+      this.txDepth--;
+      if (this.txDepth === 0) {
+        this.commitTemplate(before, null);
+        this.txPatches = [];
+        this.txInverse = [];
+      }
+      throw e;
+    }
+    this.txDepth--;
+    if (this.txDepth === 0 && this.txPatches.length > 0) {
+      const entry = {
+        label: this.txLabel,
+        patches: this.txPatches,
+        inversePatches: this.txInverse,
+        selectionBefore: this.txSelectionBefore,
+        selectionAfter: this.state.selection,
+        at: Date.now()
+      };
+      if (this.txSkipHistory) this.unhistoried = true;
+      else this.pushHistory(entry);
+      this.setState({ dirty: this.isDirty() });
+      this.onChange?.(this.state.template, entry);
+      this.txPatches = [];
+      this.txInverse = [];
+    }
+    return result;
+  }
+  commitTemplate(template, entry) {
+    if (template === this.state.template) return;
+    this.setState({ template, dirty: this.txDepth > 0 ? true : this.isDirty(), version: this.state.version + 1 });
+    if (this.txDepth === 0) this.onChange?.(template, entry);
+  }
+  pushHistory(entry) {
+    const last = this.undoStack[this.undoStack.length - 1];
+    if (entry.mergeKey && last && last.mergeKey === entry.mergeKey && entry.at - last.at < this.mergeWindowMs) {
+      if (last === this.savedEntry) this.savedEntry = null;
+      last.patches.push(...entry.patches);
+      last.inversePatches.unshift(...entry.inversePatches);
+      last.at = entry.at;
+      last.selectionAfter = entry.selectionAfter;
+    } else {
+      this.undoStack.push(entry);
+      if (this.undoStack.length > this.maxHistory) this.undoStack.shift();
+    }
+    this.redoStack = [];
+  }
+  /* ------------------------------ history ---------------------------- */
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+  undoLabel() {
+    return this.undoStack[this.undoStack.length - 1]?.label;
+  }
+  redoLabel() {
+    return this.redoStack[this.redoStack.length - 1]?.label;
+  }
+  undo() {
+    const entry = this.undoStack.pop();
+    if (!entry) return false;
+    const template = applyPatches(this.state.template, entry.inversePatches);
+    this.redoStack.push(entry);
+    this.setState({ template, selection: entry.selectionBefore.filter((id) => !!findIn(template, id)), editingId: null, dirty: this.isDirty(), version: this.state.version + 1 });
+    this.onChange?.(template, null);
+    return true;
+  }
+  redo() {
+    const entry = this.redoStack.pop();
+    if (!entry) return false;
+    const template = applyPatches(this.state.template, entry.patches);
+    this.undoStack.push(entry);
+    this.setState({ template, selection: entry.selectionAfter.filter((id) => !!findIn(template, id)), editingId: null, dirty: this.isDirty(), version: this.state.version + 1 });
+    this.onChange?.(template, null);
+    return true;
+  }
+  /** Replaces the document and clears history (loading a template). */
+  load(template) {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.savedEntry = null;
+    this.unhistoried = false;
+    this.setState({ template, selection: [], hoverId: null, editingId: null, dirty: false, version: this.state.version + 1 });
+  }
+  history() {
+    return { undo: this.undoStack, redo: this.redoStack };
+  }
+};
+function findIn(template, id) {
+  return indexTemplate(template).get(id)?.node;
+}
+function sameIds(a, b) {
+  return a.length === b.length && a.every((x, i) => x === b[i]);
+}
+function labelFor2(cmd) {
+  switch (cmd.type) {
+    case "insertNode":
+    case "insertNodes":
+      return "Insert";
+    case "removeNodes":
+      return "Delete";
+    case "moveNode":
+      return "Move";
+    case "duplicateNode":
+      return "Duplicate";
+    case "setProps":
+    case "setProp":
+      return "Edit properties";
+    case "setStyle":
+      return "Edit style";
+    case "setFlow":
+      return "Edit page flow";
+    case "setVisibleWhen":
+      return "Edit visibility";
+    case "setName":
+      return "Rename";
+    case "setLocked":
+      return cmd.locked ? "Lock" : "Unlock";
+    case "setRowLayout":
+      return "Change columns";
+    case "wrapNodes":
+      return "Wrap";
+    case "replaceNode":
+      return "Replace";
+    case "setPage":
+      return "Page settings";
+    case "setDocumentStyles":
+    case "setTextStyle":
+      return "Document styles";
+    case "setTemplateName":
+      return "Rename report";
+    case "setSettings":
+      return "Settings";
+    case "setRegionFirstPage":
+      return "First page header/footer";
+    case "addLibraryItem":
+      return "Save to library";
+    case "removeLibraryItem":
+      return "Remove from library";
+    case "replaceTemplate":
+      return "Load";
+  }
+}
+
+// src/render/render-node.ts
+function deferredScope(opts) {
+  return new Scope({
+    page: opts.page,
+    now: opts.format.now ?? /* @__PURE__ */ new Date(),
+    theme: { name: opts.theme.name, logo: opts.theme.logo, colors: opts.theme.colors, typography: opts.theme.typography, meta: opts.theme.meta ?? {} }
+  });
+}
+function evalDeferred(expr, opts) {
+  try {
+    return toDisplayString(evaluate(expr, { scope: deferredScope(opts), format: opts.format }));
+  } catch {
+    return "";
+  }
+}
+function tokenChip(expr, label, value) {
+  return h("span", { class: "bp-token", "data-expr": expr, title: expr, contenteditable: "false" }, label ?? expr, value !== void 0 && value !== "" ? h("span", { class: "bp-token__value" }, value) : null);
+}
+function renderSegments(segments, fallback, opts) {
+  if (!segments) return fallback !== void 0 ? [fallback] : [];
+  return segments.map((s) => {
+    if (s.kind === "text") return s.text;
+    const value = s.deferred ? evalDeferred(s.expr, opts) : s.value ?? "";
+    if (opts.mode === "design") return tokenChip(s.expr, s.label, s.deferred ? value : void 0);
+    return value;
+  });
+}
+function markWrap(children, marks, opts) {
+  if (!marks) return children;
+  let out = children;
+  if (marks.code) out = h("code", { class: "bp-code" }, out);
+  if (marks.bold) out = h("strong", null, out);
+  if (marks.italic) out = h("em", null, out);
+  if (marks.underline) out = h("u", null, out);
+  if (marks.strike) out = h("s", null, out);
+  if (marks.color) out = h("span", { style: { color: resolveValue(marks.color, opts.theme, "inherit") } }, out);
+  if (marks.link) {
+    const href = marks.link;
+    const safe = isSafeUrl(href);
+    const linkColor = resolveValue(opts.styles.link.color, opts.theme, opts.theme.colors.secondary);
+    out = h("a", { class: "bp-link", href: safe ? href : void 0, rel: "noopener", style: { color: linkColor, "text-decoration": opts.styles.link.underline === false ? "none" : "underline" } }, out);
+  }
+  return out;
+}
+function renderInline(content, opts) {
+  return content.map((n) => {
+    if (n.type === "break") return h("br");
+    if (n.type === "text") return markWrap([n.text], n.marks, opts);
+    const value = n.deferred ? evalDeferred(n.expr, opts) : n.value ?? "";
+    const inner = opts.mode === "design" ? tokenChip(n.expr, n.label, n.deferred ? value : void 0) : value;
+    return markWrap([inner], n.marks, opts);
+  });
+}
+function renderParagraph(p, opts) {
+  const empty = p.content.length === 0;
+  return h("p", { class: ["bp-p", empty && "bp-p--empty"], style: p.align ? { "text-align": p.align } : void 0 }, empty ? h("br") : renderInline(p.content, opts));
+}
+function renderRichText(doc, opts) {
+  if (!doc) return [];
+  return doc.content.map((b) => {
+    if (b.type === "paragraph") return renderParagraph(b, opts);
+    return h(
+      b.type === "bulletList" ? "ul" : "ol",
+      { class: "bp-list" },
+      b.content.map((li) => h("li", null, li.content.map((p) => renderParagraph(p, opts))))
+    );
+  });
+}
+function nodeAttrs(node, extra = {}) {
+  return {
+    "data-key": node.key,
+    "data-node": node.nodeId,
+    "data-type": node.type,
+    ...extra
+  };
+}
+function columnWidth(rowWidth, span, gap, columns) {
+  const inner = rowWidth - gap * Math.max(0, columns - 1);
+  return Math.max(0, inner * span / 12);
+}
+function renderNode(node, opts, width = opts.width) {
+  const def = opts.registry.get(node.type);
+  const gap = opts.styles.spacing.blockGap;
+  const columnGap = opts.styles.spacing.columnGap;
+  let childWidth = width;
+  if (def?.container) {
+    const pad = node.style.padding;
+    const bw = node.style.border ? node.style.border.width : 0;
+    childWidth = Math.max(0, width - pad.left - pad.right - 2 * bw);
+  }
+  const children = [];
+  if (node.role === "row") {
+    const count = node.children.length;
+    for (const col of node.children) {
+      const w = columnWidth(childWidth, col.span ?? 12 / Math.max(1, count), columnGap, count);
+      const v = renderNode(col, opts, w);
+      if (v) children.push(v);
+    }
+  } else {
+    for (const c of node.children) {
+      const v = renderNode(c, opts, childWidth);
+      if (v) children.push(v);
+    }
+  }
+  const s = node.style;
+  const css = styleToCss(s);
+  delete css["margin"];
+  delete css["width"];
+  delete css["height"];
+  const wrapperStyle = {};
+  const m = s.margin;
+  if (m.top || m.right || m.bottom || m.left) wrapperStyle["margin"] = `${m.top}px ${m.right}px ${m.bottom}px ${m.left}px`;
+  if (s.width !== void 0 && node.role === "block") {
+    wrapperStyle["width"] = typeof s.width === "number" ? `${s.width}px` : s.width;
+    wrapperStyle["max-width"] = "100%";
+    if (s.align === "center") wrapperStyle["margin-left"] = wrapperStyle["margin-right"] = "auto";
+    else if (s.align === "right") wrapperStyle["margin-left"] = "auto";
+  }
+  if (s.height !== void 0 && node.role === "block") wrapperStyle["height"] = `${s.height}px`;
+  if (node.role === "column") {
+    wrapperStyle["grid-column"] = `span ${node.span ?? 12}`;
+    wrapperStyle["min-width"] = "0";
+  }
+  const classes = ["bp-node", `bp-node--${node.type}`, `bp-${node.role}`];
+  if (node.props.__hiddenByCondition) classes.push("bp-node--hidden");
+  if (node.placeholder) classes.push("bp-node--placeholder");
+  if (node.locked) classes.push("bp-node--locked");
+  if (node.iteration) classes.push("bp-repeater-item");
+  if (node.flow.keepTogether) classes.push("bp-node--keep");
+  let attrs = nodeAttrs(node, { class: classes, style: wrapperStyle });
+  if (opts.decorate) attrs = opts.decorate(node, attrs);
+  if (!def) {
+    return h("div", attrs, h("div", { class: "bp-unknown-block", style: cssText(css) }, `Unavailable block: ${node.type}`));
+  }
+  const ctx = {
+    node,
+    props: node.props,
+    style: s,
+    css,
+    theme: opts.theme,
+    styles: opts.styles,
+    mode: opts.mode,
+    h,
+    children,
+    page: opts.page,
+    width,
+    format: opts.format,
+    registry: opts.registry,
+    text: (prop, fallback) => renderSegments(node.textSegments[prop], fallback ?? (typeof node.props[prop] === "string" ? node.props[prop] : void 0), opts),
+    richText: (prop) => renderRichText(node.richText[prop] ?? node.props[prop], opts),
+    textValue: (value) => value === void 0 ? [] : [value],
+    binding: (prop) => node.bindings[prop],
+    partAttrs: (part, extra = {}) => ({ "data-part": part, "data-node": node.nodeId, ...extra }),
+    placeholder: (text, extra = {}) => h("div", { class: "bp-placeholder", ...extra }, text)
+  };
+  let inner;
+  try {
+    inner = def.render(ctx);
+  } catch (e) {
+    inner = h("div", { class: "bp-block-error" }, `${def.name} failed to render: ${e.message}`);
+  }
+  if (!inner) return null;
+  if (def.container && node.role !== "row" && node.role !== "column" && def.container.direction !== "row") {
+  }
+  void gap;
+  return h("div", attrs, inner);
+}
+function renderSections(sections, opts) {
+  const out = [];
+  for (const s of sections) {
+    const v = renderNode(s, opts, opts.width);
+    if (v) out.push(v);
+  }
+  return out;
+}
+export {
+  BlockRegistry,
+  CONDITION_OPERATORS,
+  CURRENT_SCHEMA_VERSION,
+  CommandError,
+  DEFAULT_PAGE_CONTEXT,
+  DEFAULT_THEME,
+  EditorStore,
+  ExpressionError,
+  FUNCTION_NAMES,
+  GLOBAL_SCHEMAS,
+  MIGRATIONS,
+  MigrationError,
+  PAGE_SIZES_MM,
+  PIPES,
+  PX_PER_MM,
+  REGION_IDS,
+  ROW_LAYOUTS,
+  SchemaScope,
+  Scope,
+  ancestors,
+  applyCommand,
+  bestBreak,
+  bindingSpecsFor,
+  blockStyleSchema,
+  checkExpressionSyntax,
+  checkOutput,
+  classNames,
+  cloneWithNewIds,
+  collectPaths,
+  columnWidth,
+  compareValues,
+  compileCondition,
+  computePageGeometry,
+  countNodes,
+  createColumn,
+  createId,
+  createNode,
+  createParagraph,
+  createRichText,
+  createRow,
+  createSchemaScope,
+  createSection,
+  createTemplate,
+  cssText,
+  dataSourceSchemas,
+  defaultDocumentStyles,
+  defaultPageSettings,
+  defineBlock,
+  describeExpression,
+  documentStylesSchema,
+  escapeHtml,
+  evaluate,
+  evaluateAst,
+  evaluateCondition,
+  evaluateText,
+  evaluateToText,
+  exprToString,
+  extractTemplateTokens,
+  findNode,
+  formatCurrency,
+  formatDate,
+  formatDatePattern,
+  formatNumber,
+  formatPercent,
+  getField,
+  getRegion,
+  h,
+  humaniseLabel,
+  humanize,
+  humanizeKey,
+  indexTemplate,
+  inlineFromTemplate,
+  inlineToPlain,
+  interpolate,
+  isDarkColor,
+  isDescendant,
+  isEmptyValue,
+  isRichTextDoc,
+  isSafeUrl,
+  isTokenRef,
+  isVNode,
+  issue,
+  itemSchemaOf,
+  labelForPath,
+  listAt,
+  listThemeTokens,
+  looseEquals,
+  mergeTheme,
+  migrateTemplate,
+  missingThemeValues,
+  mmToPx,
+  needsMigration,
+  nodeAt,
+  nodeAttrs,
+  nodeSchema,
+  pageSettingsSchema,
+  pageSizeMm,
+  paginate,
+  parseExpression,
+  parseTemplate,
+  pathToString,
+  pxToMm,
+  readProperty,
+  readRegion,
+  renderInline,
+  renderNode,
+  renderRichText,
+  renderSections,
+  renderSegments,
+  resolveDefaultProps,
+  resolvePath,
+  resolvePathSchema,
+  resolveStyle,
+  resolveTemplate,
+  resolveToken,
+  resolveValue,
+  richTextFromTemplate,
+  richTextToPlain,
+  richTextTokens,
+  setDeterministicIds,
+  splitTemplate,
+  styleString,
+  styleToCss,
+  synthesizeSampleData,
+  synthesizeValue,
+  templateSchema,
+  textStyleLabel,
+  toDate,
+  toDisplayString,
+  toHtml,
+  toNumber,
+  tokenChip,
+  tokenize,
+  truthy,
+  typeCheck,
+  typeCheckAst,
+  usedBlockTypes,
+  validateTemplate,
+  walkTemplate,
+  walkVNodes
+};
+//# sourceMappingURL=index.js.map