@12ui/design 0.2.71 → 0.2.73

package/runtime/layerdoc-validator.mjs

@@ -0,0 +1,1860 @@
+// GENERATED from the canonical LayerDoc parser by scripts/layerdoc-validator-bundle.mjs. Do not edit.
+
+// packages/layerdoc/src/core/css-shape.ts
+var MAX_STYLE_PROPERTIES = 100;
+var MAX_PROPERTY_LENGTH = 128;
+var MAX_VALUE_LENGTH = 2048;
+var UNSAFE_DECLARATION_BOUNDARY = /[<>{};\u0000-\u001f\u007f]/;
+var EXTERNAL_OR_EXECUTABLE_CSS = /(?:@import\b|javascript\s*:|vbscript\s*:|-moz-binding\b|behavior\s*:|(?:url|src|image-set|-webkit-image-set|expression)\s*\()/i;
+var UNSAFE_PROPERTY = /^(?:behavior|javascript|mozBinding|vbscript)$/i;
+var UNITLESS_PROPERTIES = /* @__PURE__ */ new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "columnCount",
+  "columns",
+  "fillOpacity",
+  "flex",
+  "flexGrow",
+  "flexShrink",
+  "fontWeight",
+  "gridArea",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnStart",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowStart",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "stopOpacity",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom"
+]);
+var LENGTH_PROPERTY = /(?:block|blur|bottom|basis|gap|height|indent|inset|left|margin|offset|padding|radius|right|size|spacing|spread|thickness|top|width)$/i;
+var camelTail = (value) => value.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+var SCALAR_LENGTH_ALIASES = {
+  borderRadiusPx: "borderRadius",
+  borderWidthPx: "borderWidth",
+  fontSizePx: "fontSize"
+};
+var allowedProperty = (value) => UNSAFE_PROPERTY.test(value) ? null : SCALAR_LENGTH_ALIASES[value] ?? value;
+function normalizeCssPropertyName(value) {
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (!raw || raw.length > MAX_PROPERTY_LENGTH || UNSAFE_DECLARATION_BOUNDARY.test(raw)) return null;
+  if (raw.startsWith("--")) return /^--[A-Za-z0-9_-]+$/.test(raw) ? raw : null;
+  const cssLike = raw.replace(/[\s_]+/g, "-").replace(/[^A-Za-z0-9-]+/g, "-");
+  if (/^-webkit-/i.test(cssLike)) return allowedProperty(`Webkit${camelTail(cssLike.slice(8))}`);
+  if (/^-moz-/i.test(cssLike)) return allowedProperty(`Moz${camelTail(cssLike.slice(5))}`);
+  if (/^-o-/i.test(cssLike)) return allowedProperty(`O${camelTail(cssLike.slice(3))}`);
+  if (/^-ms-/i.test(cssLike)) return allowedProperty(`ms${camelTail(cssLike.slice(4))}`);
+  if (!/^[A-Za-z][A-Za-z0-9-]*$/.test(cssLike)) return null;
+  if (!cssLike.includes("-")) {
+    return allowedProperty(/^[A-Z]+$/.test(cssLike) ? cssLike.toLowerCase() : cssLike.charAt(0).toLowerCase() + cssLike.slice(1));
+  }
+  const [first, ...rest] = cssLike.split("-").filter(Boolean);
+  return allowedProperty(`${first.toLowerCase()}${rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("")}`);
+}
+var numericCssValue = (property, value) => {
+  if (!Number.isFinite(value)) return null;
+  const normalized = Object.is(value, -0) ? 0 : value;
+  if (normalized === 0 || UNITLESS_PROPERTIES.has(property) || property.startsWith("--")) return String(normalized);
+  return LENGTH_PROPERTY.test(property) ? `${normalized}px` : String(normalized);
+};
+function normalizeCssPropertyValue(property, value) {
+  if (typeof value === "number") return numericCssValue(property, value);
+  if (Array.isArray(value)) {
+    const parts = value.map((part) => normalizeCssPropertyValue(property, part));
+    return parts.length && parts.every((part) => part !== null) ? parts.join(" ") : null;
+  }
+  if (value && typeof value === "object") {
+    const source = value;
+    if (source.css !== void 0) return normalizeCssPropertyValue(property, source.css);
+    if (source.value !== void 0) return normalizeCssPropertyValue(property, source.value);
+    return null;
+  }
+  if (typeof value !== "string") return null;
+  const candidate = value.trim();
+  if (!candidate || candidate.length > MAX_VALUE_LENGTH) return null;
+  if (UNSAFE_DECLARATION_BOUNDARY.test(candidate) || EXTERNAL_OR_EXECUTABLE_CSS.test(candidate)) return null;
+  if (/^-?(?:\d+(?:\.\d+)?|\.\d+)$/.test(candidate)) {
+    return numericCssValue(property, Number(candidate));
+  }
+  return candidate;
+}
+function normalizeCssStyleShape(value) {
+  const output = {};
+  for (const [rawProperty, rawValue] of Object.entries(value).slice(0, MAX_STYLE_PROPERTIES)) {
+    const property = normalizeCssPropertyName(rawProperty);
+    if (!property || UNSAFE_PROPERTY.test(property)) continue;
+    const normalized = normalizeCssPropertyValue(property, rawValue);
+    if (normalized !== null) output[property] = normalized;
+  }
+  return output;
+}
+
+// packages/layerdoc/src/core/css-named-colors.ts
+var NAMED_CSS_COLORS = new Map(Object.entries({
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkgrey: "#a9a9a9",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  grey: "#808080",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightgrey: "#d3d3d3",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+}));
+
+// packages/layerdoc/src/core/css-values.ts
+var SAFE_COLOR = /^(?:#[0-9a-fA-F]{3,8}|rgba?\(\s*\d+(?:\.\d+)?\s*,\s*\d+(?:\.\d+)?\s*,\s*\d+(?:\.\d+)?(?:\s*,\s*(?:0|1|0?\.\d+))?\s*\))$/;
+var UNSAFE_STYLE_BOUNDARY = /[<>{};\u0000-\u001f\u007f]/;
+function sanitizeCssColor(value) {
+  const color2 = String(value ?? "").trim();
+  return SAFE_COLOR.test(color2) ? color2 : null;
+}
+function resolveDeclaredCssColor(value) {
+  const exact = sanitizeCssColor(value);
+  if (exact) return exact;
+  return NAMED_CSS_COLORS.get(String(value ?? "").trim().toLowerCase()) ?? null;
+}
+function isSafeStyleDescription(value) {
+  return !UNSAFE_STYLE_BOUNDARY.test(value);
+}
+var SURFACE_CSS_EDGE_BORDERS = Object.freeze([
+  "borderTop",
+  "borderRight",
+  "borderBottom",
+  "borderLeft"
+]);
+var finiteCssNumber = String.raw`-?(?:\d+(?:\.\d+)?|\.\d+)`;
+var cssLength = new RegExp(`^${finiteCssNumber}px$`);
+var cssPercentage = new RegExp(`^${finiteCssNumber}%$`);
+var cssShadowLength = String.raw`(?:0|${finiteCssNumber}px)`;
+function parseSurfaceCss(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("style must be an object");
+  }
+  return normalizeCssStyleShape(value);
+}
+
+// packages/layerdoc/src/core/clip-path-coordinate-frame.ts
+var PUBLIC_CLIP_PATH_FRAME = "canvas-px";
+var COMMAND_AXES = Object.freeze({
+  M: ["x", "y"],
+  L: ["x", "y"],
+  H: ["x"],
+  V: ["y"],
+  C: ["x", "y", "x", "y", "x", "y"],
+  S: ["x", "y", "x", "y"],
+  Q: ["x", "y", "x", "y"],
+  T: ["x", "y"],
+  A: ["x", "y", "angle", "flag", "flag", "x", "y"],
+  Z: []
+});
+
+// packages/layerdoc/src/core/control-text-anchor.ts
+var CONTROL_TEXT_VERTICAL_ANCHORS = [
+  "center",
+  "source-offset",
+  "top",
+  "baseline",
+  "bottom"
+];
+var CONTROL_TEXT_HORIZONTAL_ANCHORS = [
+  "center",
+  "start",
+  "end",
+  "source-offset"
+];
+var CONTROL_TEXT_ANCHOR_KEYS = /* @__PURE__ */ new Set(["vertical", "horizontal"]);
+var parseControlTextAnchor = (value, path, issues) => {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    issues.push(`${path} must be an object`);
+    return void 0;
+  }
+  const input = value;
+  for (const key of Object.keys(input)) {
+    if (!CONTROL_TEXT_ANCHOR_KEYS.has(key)) issues.push(`${path}.${key} is not a control-text anchor key`);
+  }
+  const output = {};
+  if (input.vertical !== void 0) {
+    if (!CONTROL_TEXT_VERTICAL_ANCHORS.includes(input.vertical)) {
+      issues.push(`${path}.vertical must be one of ${CONTROL_TEXT_VERTICAL_ANCHORS.join(", ")}`);
+    } else output.vertical = input.vertical;
+  }
+  if (input.horizontal !== void 0) {
+    if (!CONTROL_TEXT_HORIZONTAL_ANCHORS.includes(input.horizontal)) {
+      issues.push(`${path}.horizontal must be one of ${CONTROL_TEXT_HORIZONTAL_ANCHORS.join(", ")}`);
+    } else output.horizontal = input.horizontal;
+  }
+  if (output.vertical === void 0 && output.horizontal === void 0) {
+    issues.push(`${path} must declare vertical or horizontal`);
+    return void 0;
+  }
+  return output;
+};
+
+// packages/layerdoc/src/core/public-layerdoc-forward-compat.ts
+var PROTOTYPE_MUTATING_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var forwardUnknownKeys = (value, allowed, path, issues, options = {}) => {
+  let forwarded = null;
+  for (const key of Object.keys(value)) {
+    if (allowed.has(key)) continue;
+    if (options.reserved?.has(key) || PROTOTYPE_MUTATING_KEYS.has(key)) {
+      issues.push(`${path}.${key} is not allowed`);
+      continue;
+    }
+    (forwarded ??= {})[key] = value[key];
+  }
+  return forwarded;
+};
+var carryUnknownKeys = (output, forwarded) => {
+  if (forwarded) Object.assign(output, forwarded);
+  return output;
+};
+var refuseUnknownKeys = (value, allowed, path, issues) => {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) issues.push(`${path}.${key} is not allowed`);
+  }
+};
+
+// packages/layerdoc/src/core/extraction-contract.ts
+var EXTRACTION_CONTRACT_KEYS = /* @__PURE__ */ new Set([
+  "revision",
+  "promptRevision",
+  "schemaRevision"
+]);
+var isSha256 = (value) => typeof value === "string" && /^[a-f0-9]{64}$/u.test(value);
+var parseExtractionContract = (value, path, issues) => {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    issues.push(`${path} must be an object`);
+    return void 0;
+  }
+  const input = value;
+  const forwarded = forwardUnknownKeys(input, EXTRACTION_CONTRACT_KEYS, path, issues);
+  if (!Number.isSafeInteger(input.revision) || Number(input.revision) < 1) {
+    issues.push(`${path}.revision must be a positive safe integer`);
+  }
+  if (!isSha256(input.promptRevision)) {
+    issues.push(`${path}.promptRevision must be a lowercase sha256`);
+  }
+  if (!isSha256(input.schemaRevision)) {
+    issues.push(`${path}.schemaRevision must be a lowercase sha256`);
+  }
+  if (!Number.isSafeInteger(input.revision) || Number(input.revision) < 1 || !isSha256(input.promptRevision) || !isSha256(input.schemaRevision)) return void 0;
+  return carryUnknownKeys({
+    revision: Number(input.revision),
+    promptRevision: input.promptRevision,
+    schemaRevision: input.schemaRevision
+  }, forwarded);
+};
+
+// packages/layerdoc/src/snap-text-ink.ts
+var TEXT_INK_REFUSALS = [
+  "busy-background",
+  "no-credible-ink",
+  "mask-flooded",
+  "no-row-segments",
+  "declared-line-count",
+  "no-column-segments",
+  "no-move",
+  "area",
+  "single-line-allowance",
+  "ink-loss"
+];
+var TEXT_INK_BASES = ["declared-color", "contrast"];
+
+// packages/layerdoc/src/core/icon-svg.ts
+var ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "circle",
+  "ellipse",
+  "g",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect",
+  "svg"
+]);
+var DRAWING_TAGS = /* @__PURE__ */ new Set([
+  "circle",
+  "ellipse",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect"
+]);
+var ALLOWED_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "clip-rule",
+  "cx",
+  "cy",
+  "d",
+  "fill",
+  "fill-rule",
+  "height",
+  "opacity",
+  "points",
+  "preserveAspectRatio",
+  "r",
+  "rx",
+  "ry",
+  "stroke",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-width",
+  "transform",
+  "viewBox",
+  "width",
+  "x",
+  "x1",
+  "x2",
+  "xmlns",
+  "y",
+  "y1",
+  "y2"
+]);
+var OPENING_TAG = /<([a-zA-Z][\w:-]*)([^<>]*)>/g;
+var ATTRIBUTE = /([a-zA-Z_:][\w:.-]*)\s*=\s*(?:"[^"]*"|'[^']*')/g;
+var parseIconSvg = (input, path = "iconSvg") => {
+  if (typeof input !== "string" || !input.trim()) throw new Error(`${path} must be a non-empty SVG string`);
+  const svg = input.trim();
+  if (!/^<svg\b[\s\S]*<\/svg>$/.test(svg)) throw new Error(`${path} must have one svg root`);
+  if (/<!|<\?|&(?:#\d+|#x[a-f\d]+|[a-z][\w.-]*);|\b(?:href|style)\s*=|\bon[a-z]+\s*=|\burl\s*\(/i.test(svg)) {
+    throw new Error(`${path} contains executable or external SVG markup`);
+  }
+  const seenTags = [...svg.matchAll(/<\/?([a-zA-Z][\w:-]*)\b/g)];
+  for (const match of seenTags) {
+    if (!ALLOWED_TAGS.has(match[1])) throw new Error(`${path} contains unsupported <${match[1]}> markup`);
+  }
+  if (!seenTags.some((match) => DRAWING_TAGS.has(match[1]))) {
+    throw new Error(`${path} contains no drawing element`);
+  }
+  for (const tag of svg.matchAll(OPENING_TAG)) {
+    const attributes = tag[2];
+    const stripped = attributes.replace(ATTRIBUTE, "").replace(/\s|\//g, "");
+    if (stripped) throw new Error(`${path} contains malformed SVG attributes`);
+    for (const attribute of attributes.matchAll(ATTRIBUTE)) {
+      if (!ALLOWED_ATTRIBUTES.has(attribute[1])) {
+        throw new Error(`${path} contains unsupported ${attribute[1]} attribute`);
+      }
+    }
+  }
+  return svg;
+};
+
+// packages/layerdoc/src/core/repeated-rules.ts
+var REPEATED_RULE_ORIENTATIONS = ["horizontal", "vertical"];
+var MAX_REPEATED_RULE_SETS = 2;
+var MAX_REPEATED_RULE_POSITIONS = 64;
+var MAX_REPEATED_RULE_STROKE_RATIO = 0.1;
+var ruleRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+var parseRepeatedRules = (value, path, issues) => {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length < 1 || value.length > MAX_REPEATED_RULE_SETS) {
+    issues.push(`${path} must contain 1..${MAX_REPEATED_RULE_SETS} rule sets`);
+    return void 0;
+  }
+  const output = [];
+  const orientations = /* @__PURE__ */ new Set();
+  for (const [index, candidate] of value.entries()) {
+    const itemPath = `${path}[${index}]`;
+    const rule = ruleRecord(candidate);
+    if (!rule) {
+      issues.push(`${itemPath} must be an object`);
+      continue;
+    }
+    if (Object.keys(rule).some((key) => !["orientation", "positions", "stroke"].includes(key))) {
+      issues.push(`${itemPath} has an unknown repeated-rule key`);
+      continue;
+    }
+    const orientation = rule.orientation;
+    if (!REPEATED_RULE_ORIENTATIONS.includes(orientation)) {
+      issues.push(`${itemPath}.orientation must be horizontal or vertical`);
+      continue;
+    }
+    if (orientations.has(orientation)) {
+      issues.push(`${path} must not repeat a rule orientation`);
+      continue;
+    }
+    if (!Array.isArray(rule.positions) || rule.positions.length < 1 || rule.positions.length > MAX_REPEATED_RULE_POSITIONS || !rule.positions.every((position) => typeof position === "number" && Number.isFinite(position) && position > 0 && position < 1)) {
+      issues.push(`${itemPath}.positions must contain 1..${MAX_REPEATED_RULE_POSITIONS} interior fractions`);
+      continue;
+    }
+    const positions = [...rule.positions];
+    if (positions.some((position, at) => at > 0 && position <= positions[at - 1])) {
+      issues.push(`${itemPath}.positions must be strictly ascending`);
+      continue;
+    }
+    const stroke = ruleRecord(rule.stroke);
+    if (!stroke || Object.keys(stroke).some((key) => !["width", "color"].includes(key))) {
+      issues.push(`${itemPath}.stroke must contain width and color`);
+      continue;
+    }
+    const width = stroke.width;
+    const color2 = typeof stroke.color === "string" ? sanitizeCssColor(stroke.color) : null;
+    if (typeof width !== "number" || !Number.isFinite(width) || width <= 0 || width > MAX_REPEATED_RULE_STROKE_RATIO || !color2) {
+      issues.push(`${itemPath}.stroke must have a safe width and literal color`);
+      continue;
+    }
+    orientations.add(orientation);
+    output.push({
+      orientation,
+      positions,
+      stroke: { width, color: color2 }
+    });
+  }
+  return output.length === value.length ? output : void 0;
+};
+
+// packages/layerdoc/src/core/selection-control.ts
+var SELECTION_CONTROL_KINDS = [
+  "checkbox",
+  "radio",
+  "toggle"
+];
+var KIND_SET = new Set(SELECTION_CONTROL_KINDS);
+var isSelectionControlKind = (value) => KIND_SET.has(String(value ?? "").trim().toLowerCase());
+var finiteBox = (value) => {
+  if (!value || value.length !== 4) return null;
+  const box = value.map(Number);
+  return box.every(Number.isFinite) && box[2] > 0 && box[3] > 0 ? box : null;
+};
+var boxContains = (outer, inner) => inner[0] >= outer[0] && inner[1] >= outer[1] && inner[0] + inner[2] <= outer[0] + outer[2] && inner[1] + inner[3] <= outer[1] + outer[3];
+var selectionControlDeclaration = (layer) => {
+  const normalizedKind2 = String(layer.checkableKind ?? "").trim().toLowerCase();
+  if (!isSelectionControlKind(normalizedKind2)) return null;
+  const box = finiteBox(layer.box);
+  const markerBox = finiteBox(layer.markerBox);
+  if (!box) throw new Error(`${normalizedKind2}.box must be a finite positive box`);
+  if (!markerBox) throw new Error(`${normalizedKind2}.markerBox must be a finite positive box`);
+  if (!boxContains(box, markerBox)) {
+    throw new Error(`${normalizedKind2}.markerBox must stay inside its control box`);
+  }
+  if (typeof layer.checked !== "boolean") {
+    throw new Error(`${normalizedKind2}.checked must be boolean`);
+  }
+  const markerColor = resolveDeclaredCssColor(layer.markerColor);
+  if (!markerColor) throw new Error(`${normalizedKind2}.markerColor must be a declared CSS color`);
+  return {
+    kind: normalizedKind2,
+    content: String(layer.content ?? ""),
+    group: String(layer.group ?? ""),
+    box,
+    markerBox,
+    markerColor,
+    checked: layer.checked
+  };
+};
+
+// packages/layerdoc/src/core/layer-representation.ts
+var MIN_TEXT_AXIS_SCALE = 0.5;
+var MAX_TEXT_AXIS_SCALE = 2;
+var isValidTextAxisScale = (value) => typeof value === "number" && Number.isFinite(value) && Math.abs(value) >= MIN_TEXT_AXIS_SCALE && Math.abs(value) <= MAX_TEXT_AXIS_SCALE;
+var TEXT_LAYER_KINDS = [
+  "text",
+  "heading",
+  "title",
+  "subtitle",
+  "paragraph",
+  "caption",
+  "label",
+  "link",
+  "textarea",
+  "button",
+  "input",
+  "badge"
+];
+var NON_TEXT_LAYER_KINDS = [
+  "background",
+  "photo",
+  "texture",
+  "panel",
+  "card",
+  "icon",
+  "logo",
+  "divider",
+  "decoration",
+  "illustration",
+  "image",
+  "graphic",
+  "chart"
+];
+var COMPLETE_RECTANGULAR_RASTER_LAYER_KINDS = [
+  "illustration",
+  "image",
+  "graphic",
+  "chart"
+];
+var TEXT_KINDS = new Set(TEXT_LAYER_KINDS);
+var NON_TEXT_KINDS = new Set(NON_TEXT_LAYER_KINDS);
+var COMPLETE_RECTANGULAR_RASTER_KINDS = new Set(
+  COMPLETE_RECTANGULAR_RASTER_LAYER_KINDS
+);
+var isValidGoogleFontFamily = (value) => {
+  const family = String(value ?? "").trim();
+  return Boolean(family) && /^[\p{L}\p{N} _-]+$/u.test(family);
+};
+
+// packages/layerdoc/src/core/text-color-ranges.ts
+var TEXT_COLOR_RANGE_KEYS = /* @__PURE__ */ new Set(["start", "end", "color"]);
+var MAX_TEXT_COLOR_RANGES = 64;
+var parseTextColorRanges = (value, content, path, issues) => {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    issues.push(`${path} must be an array`);
+    return void 0;
+  }
+  if (value.length > MAX_TEXT_COLOR_RANGES) {
+    issues.push(`${path} must not contain more than ${MAX_TEXT_COLOR_RANGES} entries`);
+  }
+  const output = [];
+  let previousEnd = 0;
+  value.slice(0, MAX_TEXT_COLOR_RANGES).forEach((candidate, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+      issues.push(`${itemPath} must be an object`);
+      return;
+    }
+    const input = candidate;
+    const forwarded = forwardUnknownKeys(input, TEXT_COLOR_RANGE_KEYS, itemPath, issues);
+    const start = input.start;
+    const end = input.end;
+    if (!Number.isSafeInteger(start) || start < 0) {
+      issues.push(`${itemPath}.start must be a non-negative integer`);
+    }
+    if (!Number.isSafeInteger(end) || end <= 0) {
+      issues.push(`${itemPath}.end must be a positive integer`);
+    }
+    const color2 = typeof input.color === "string" ? sanitizeCssColor(input.color) : null;
+    if (!color2) issues.push(`${itemPath}.color must be a literal CSS color`);
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end <= start || end > content.length || !color2) {
+      if (Number.isSafeInteger(start) && Number.isSafeInteger(end) && end <= start) issues.push(`${itemPath}.end must be greater than start`);
+      if (Number.isSafeInteger(end) && end > content.length) {
+        issues.push(`${itemPath}.end must not exceed content length`);
+      }
+      return;
+    }
+    if (start < previousEnd) {
+      issues.push(`${itemPath} must not overlap or precede the previous range`);
+      return;
+    }
+    if (!content.slice(start, end).trim()) {
+      issues.push(`${itemPath} must include visible text`);
+      return;
+    }
+    output.push(carryUnknownKeys({ start, end, color: color2 }, forwarded));
+    previousEnd = end;
+  });
+  return output.length > 0 ? output : void 0;
+};
+
+// packages/layerdoc/src/core/typographic-lockup.ts
+var LOCKUP_KEYS = /* @__PURE__ */ new Set(["lines"]);
+var LINE_KEYS = /* @__PURE__ */ new Set([
+  "content",
+  "relativeBox",
+  "fontSizeRatio",
+  "letterSpacingEm",
+  "lineHeight",
+  "fontWeight",
+  "fontStyle",
+  "googleFontFamily",
+  "color",
+  "align"
+]);
+var record = (value, path, issues) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    issues.push(`${path} must be an object`);
+    return null;
+  }
+  return value;
+};
+var finite = (value, path, issues) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    issues.push(`${path} must be a finite number`);
+    return null;
+  }
+  return value;
+};
+var bounded = (value, path, issues, predicate, description) => {
+  const parsed = finite(value, path, issues);
+  if (parsed !== null && !predicate(parsed)) {
+    issues.push(`${path} ${description}`);
+    return null;
+  }
+  return parsed;
+};
+var parseRelativeBox = (value, path, issues) => {
+  if (!Array.isArray(value) || value.length !== 4) {
+    issues.push(`${path} must be a four-number relative box`);
+    return null;
+  }
+  const coordinates = value.map((coordinate, index) => finite(coordinate, `${path}[${index}]`, issues));
+  if (coordinates.some((coordinate) => coordinate === null)) return null;
+  const [x, y, width, height] = coordinates;
+  if (x < 0 || y < 0 || width <= 0 || height <= 0 || x + width > 1 || y + height > 1) {
+    issues.push(`${path} must stay within the owning logo's 0..1 box`);
+    return null;
+  }
+  return [x, y, width, height];
+};
+var exactKeys = (value, keys, path, issues) => {
+  for (const key of Object.keys(value)) {
+    if (!keys.has(key)) issues.push(`${path}.${key} is not permitted`);
+  }
+};
+var parseLine = (value, path, issues) => {
+  const input = record(value, path, issues);
+  if (!input) return null;
+  exactKeys(input, LINE_KEYS, path, issues);
+  const content = typeof input.content === "string" ? input.content : null;
+  if (content === null || !content.trim()) issues.push(`${path}.content must be non-empty text`);
+  else if (content.includes("\n") || content.length > 4096) {
+    issues.push(`${path}.content must be one visual row of at most 4096 characters`);
+  }
+  const relativeBox = parseRelativeBox(input.relativeBox, `${path}.relativeBox`, issues);
+  const fontSizeRatio = bounded(
+    input.fontSizeRatio,
+    `${path}.fontSizeRatio`,
+    issues,
+    (candidate) => candidate > 0 && candidate <= 1,
+    "must be greater than 0 and at most 1"
+  );
+  const letterSpacingEm = bounded(
+    input.letterSpacingEm,
+    `${path}.letterSpacingEm`,
+    issues,
+    (candidate) => candidate >= -0.5 && candidate <= 1,
+    "must be between -0.5 and 1"
+  );
+  const lineHeight = bounded(
+    input.lineHeight,
+    `${path}.lineHeight`,
+    issues,
+    (candidate) => candidate >= 0.5 && candidate <= 3,
+    "must be between 0.5 and 3"
+  );
+  const fontWeight = bounded(
+    input.fontWeight,
+    `${path}.fontWeight`,
+    issues,
+    (candidate) => Number.isInteger(candidate) && candidate >= 100 && candidate <= 900,
+    "must be an integer from 100 to 900"
+  );
+  const fontStyle = input.fontStyle === void 0 || input.fontStyle === null ? void 0 : input.fontStyle === "italic" ? "italic" : null;
+  if (fontStyle === null) issues.push(`${path}.fontStyle must be italic when present`);
+  const googleFontFamily = typeof input.googleFontFamily === "string" ? input.googleFontFamily.trim() : "";
+  if (!isValidGoogleFontFamily(googleFontFamily)) {
+    issues.push(`${path}.googleFontFamily must be a safe non-empty font family`);
+  }
+  const color2 = typeof input.color === "string" && resolveDeclaredCssColor(input.color) !== null ? input.color : null;
+  if (color2 === null) issues.push(`${path}.color must be one declared CSS colour`);
+  const align = ["left", "center", "right"].includes(String(input.align)) ? input.align : null;
+  if (align === null) issues.push(`${path}.align must be left, center, or right`);
+  if (content === null || !content.trim() || content.includes("\n") || content.length > 4096 || !relativeBox || fontSizeRatio === null || letterSpacingEm === null || lineHeight === null || fontWeight === null || fontStyle === null || !googleFontFamily || color2 === null || align === null) {
+    return null;
+  }
+  return {
+    content,
+    relativeBox,
+    fontSizeRatio,
+    letterSpacingEm,
+    lineHeight,
+    fontWeight,
+    ...fontStyle ? { fontStyle } : {},
+    googleFontFamily,
+    color: color2,
+    align
+  };
+};
+var parseTypographicLockup = (value, path, issues) => {
+  if (value === void 0) return void 0;
+  const input = record(value, path, issues);
+  if (!input) return void 0;
+  exactKeys(input, LOCKUP_KEYS, path, issues);
+  if (!Array.isArray(input.lines) || input.lines.length < 2 || input.lines.length > 8) {
+    issues.push(`${path}.lines must contain 2 to 8 rows`);
+    return void 0;
+  }
+  const lines = input.lines.map((line, index) => parseLine(line, `${path}.lines[${index}]`, issues));
+  if (lines.some((line) => line === null)) return void 0;
+  return { lines };
+};
+var validateTypographicLockupOwner = (args) => {
+  const { lockup } = args;
+  if (!lockup) return;
+  if (String(args.kind).trim().toLowerCase() !== "logo") {
+    args.issues.push(`${args.path}.typographicLockup requires kind logo`);
+  }
+  if (String(args.surface ?? "").trim().toLowerCase() === "raster") {
+    args.issues.push(`${args.path}.typographicLockup cannot own raster pixels`);
+  }
+  const expectedContent = lockup.lines.map((line) => line.content).join("\n");
+  if (args.content !== expectedContent) {
+    args.issues.push(`${args.path}.content must equal typographicLockup rows joined by newlines`);
+  }
+};
+
+// packages/layerdoc/src/core/surface-pattern.ts
+var SURFACE_PATTERN_KEYS = /* @__PURE__ */ new Set([
+  "kind",
+  "stroke",
+  "spacingPx",
+  "angleDeg",
+  "crossAngleDeg",
+  "backgroundColor"
+]);
+var SURFACE_PATTERN_STROKE_KEYS = /* @__PURE__ */ new Set(["color", "widthPx"]);
+var MAX_PATTERN_SPACING_PX = 1e4;
+var MAX_PATTERN_STROKE_WIDTH_PX = 1e4;
+var MAX_PATTERN_ANGLE_DEG = 360;
+var object = (value, path) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  return value;
+};
+var number = (value, path, minimum, maximum) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < minimum || parsed > maximum) {
+    throw new Error(`${path} must be a finite number from ${minimum} to ${maximum}`);
+  }
+  return parsed;
+};
+var color = (value, path) => {
+  const normalized = normalizeCssPropertyValue("color", value);
+  if (!normalized) throw new Error(`${path} must be a safe CSS color`);
+  return normalized;
+};
+var normalizedKind = (value, path) => {
+  const raw = String(value ?? "").trim().toLowerCase().replace(/[\s_-]+/g, "");
+  const aliases = {
+    hatch: "hatch",
+    crosshatch: "crosshatch",
+    stripes: "stripes",
+    stripe: "stripes",
+    dots: "dots",
+    dot: "dots"
+  };
+  const kind = aliases[raw];
+  if (!kind) throw new Error(`${path} must be hatch, crosshatch, stripes, or dots`);
+  return kind;
+};
+var normalizedAngle = (value, path) => {
+  const raw = number(value, path, -MAX_PATTERN_ANGLE_DEG, MAX_PATTERN_ANGLE_DEG);
+  const normalized = (raw % MAX_PATTERN_ANGLE_DEG + MAX_PATTERN_ANGLE_DEG) % MAX_PATTERN_ANGLE_DEG;
+  return Number(normalized.toFixed(6));
+};
+function parseSurfacePattern(value, path = "surfacePattern") {
+  const input = object(value, path);
+  for (const key of Object.keys(input)) {
+    if (!SURFACE_PATTERN_KEYS.has(key)) throw new Error(`${path}.${key} is not allowed`);
+  }
+  const kind = normalizedKind(input.kind, `${path}.kind`);
+  const strokeInput = object(input.stroke, `${path}.stroke`);
+  for (const key of Object.keys(strokeInput)) {
+    if (!SURFACE_PATTERN_STROKE_KEYS.has(key)) throw new Error(`${path}.stroke.${key} is not allowed`);
+  }
+  const stroke = {
+    color: color(strokeInput.color, `${path}.stroke.color`),
+    widthPx: number(strokeInput.widthPx, `${path}.stroke.widthPx`, 0.125, MAX_PATTERN_STROKE_WIDTH_PX)
+  };
+  const spacingPx = number(input.spacingPx, `${path}.spacingPx`, 1, MAX_PATTERN_SPACING_PX);
+  const angleDeg = normalizedAngle(input.angleDeg, `${path}.angleDeg`);
+  const backgroundColor = color(input.backgroundColor, `${path}.backgroundColor`);
+  const crossAngleDeg = input.crossAngleDeg === void 0 || input.crossAngleDeg === null ? void 0 : normalizedAngle(input.crossAngleDeg, `${path}.crossAngleDeg`);
+  if (kind === "crosshatch") {
+    if (crossAngleDeg === void 0) throw new Error(`${path}.crossAngleDeg is required for crosshatch`);
+    if (Math.abs((crossAngleDeg - angleDeg + 180) % 180) < 1e-6) {
+      throw new Error(`${path}.crossAngleDeg must differ from angleDeg for crosshatch`);
+    }
+  } else if (crossAngleDeg !== void 0) {
+    throw new Error(`${path}.crossAngleDeg is only valid for crosshatch`);
+  }
+  return {
+    kind,
+    stroke,
+    spacingPx,
+    angleDeg,
+    ...crossAngleDeg === void 0 ? {} : { crossAngleDeg },
+    backgroundColor
+  };
+}
+
+// packages/layerdoc/src/core/public-layerdoc.ts
+var PUBLIC_LAYERDOC_MAX_CANVAS_SIDE = 1e4;
+var PUBLIC_LAYERDOC_MAX_LAYERS = 2e3;
+var PUBLIC_LAYERDOC_MAX_CONTENT_LENGTH = 2e4;
+var PUBLIC_LAYERDOC_MAX_GROUP_LENGTH = 1024;
+var PUBLIC_LAYERDOC_MAX_OPTIONAL_STRING_LENGTH = 4096;
+var PUBLIC_LAYERDOC_MAX_KIND_LENGTH = 128;
+var UNSUPPORTED_RENDER_CONTROL = /\u0000|[\u0001-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
+var PUBLIC_LAYER_GROUND_INK = ["erased", "carried"];
+var PUBLIC_LAYER_GROUND_REGISTRATION = ["positioned-scene", "featureless-texture"];
+var GROUND_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "fill",
+  "bloom",
+  "aspect",
+  "structureLeft",
+  "edgeMatchesFill"
+]);
+var PUBLIC_LAYER_GROUND_FIELD_CELLS = 40;
+var GROUND_FIELD_HEX = /^#[0-9a-f]{6}$/u;
+function parseGroundField(value, path, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    issues.push(`${path} must be an object`);
+    return void 0;
+  }
+  const input = value;
+  for (const key of Object.keys(input)) {
+    if (!GROUND_FIELD_KEYS.has(key)) issues.push(`${path}.${key} is not a ground-field key`);
+  }
+  const fill = typeof input.fill === "string" && GROUND_FIELD_HEX.test(input.fill) ? input.fill : null;
+  if (fill === null) issues.push(`${path}.fill must be a #rrggbb color`);
+  const bloom = Array.isArray(input.bloom) && input.bloom.length === PUBLIC_LAYER_GROUND_FIELD_CELLS && input.bloom.every((cell) => typeof cell === "string" && GROUND_FIELD_HEX.test(cell)) ? input.bloom.slice() : null;
+  if (bloom === null) {
+    issues.push(`${path}.bloom must be ${PUBLIC_LAYER_GROUND_FIELD_CELLS} #rrggbb colors`);
+  }
+  const aspect = typeof input.aspect === "number" && Number.isFinite(input.aspect) && input.aspect > 0 ? input.aspect : null;
+  if (aspect === null) issues.push(`${path}.aspect must be a positive number`);
+  const structureLeft = typeof input.structureLeft === "number" && Number.isFinite(input.structureLeft) && input.structureLeft >= 0 && input.structureLeft <= 1 ? input.structureLeft : null;
+  if (structureLeft === null) issues.push(`${path}.structureLeft must be between 0 and 1`);
+  const edgeMatchesFill = input.edgeMatchesFill === void 0 ? void 0 : typeof input.edgeMatchesFill === "boolean" ? input.edgeMatchesFill : null;
+  if (edgeMatchesFill === null) issues.push(`${path}.edgeMatchesFill must be a boolean`);
+  if (fill === null || bloom === null || aspect === null || structureLeft === null || edgeMatchesFill === null) {
+    return void 0;
+  }
+  return {
+    fill,
+    bloom,
+    aspect,
+    structureLeft,
+    ...edgeMatchesFill === void 0 ? {} : { edgeMatchesFill }
+  };
+}
+var STRING_FIELDS = [
+  "surface",
+  "fontStyle",
+  "googleFontFamily",
+  "color",
+  "markerColor",
+  "align",
+  "borderColor",
+  "style"
+];
+var NUMBER_FIELDS = [
+  "fontSizePx",
+  "fittedFontSizePx",
+  "textScaleX",
+  "textScaleY",
+  "fontWeight",
+  "textRotationDeg",
+  "textSlantDeg",
+  "borderRadiusPx",
+  "borderWidthPx",
+  "borderOpacity",
+  "blurPx"
+];
+var MEASURED_INK_KEYS = /* @__PURE__ */ new Set([
+  "box",
+  "rows",
+  "basis",
+  "marginPx",
+  "refusal"
+]);
+var DOCUMENT_RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "pinnedAssetDeclarations"
+]);
+var PUBLIC_LAYER_KEYS = /* @__PURE__ */ new Set([
+  "kind",
+  "content",
+  "group",
+  "box",
+  "typographicLockup",
+  "labelBox",
+  "controlTextAnchor",
+  "markerBox",
+  "checkableKind",
+  "checked",
+  "extractionIndex",
+  "canvasBackdrop",
+  "iconSvg",
+  "repeatedRules",
+  "measured",
+  "resolvedStyle",
+  "surfacePattern",
+  "textColorRanges",
+  "groundInk",
+  "groundRegistration",
+  "groundField",
+  "clipPathFrame",
+  ...STRING_FIELDS,
+  ...NUMBER_FIELDS
+]);
+var PUBLIC_LAYER_RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "pinnedAssetSha256",
+  "assetFit",
+  "assetSelectionProtected"
+]);
+var SHARED_LEFT_RAIL_RELATION_KEYS = /* @__PURE__ */ new Set([
+  "relationId",
+  "relationKind",
+  "memberExtractionIndices",
+  "role",
+  "container",
+  "target",
+  "writingDirection",
+  "sourceProvenance",
+  "measurementRevision",
+  "evidenceId"
+]);
+var SHARED_LEFT_RAIL_TARGET_KEYS = /* @__PURE__ */ new Set([
+  "coordinateSpace",
+  "x"
+]);
+var exactKeys2 = (value, keys) => Object.keys(value).length === keys.size && Object.keys(value).every((key) => keys.has(key));
+var relationString = (value, max) => typeof value === "string" && value.length > 0 && value.length <= max && !UNSUPPORTED_RENDER_CONTROL.test(value);
+function parseSharedLeftRailRelations(value) {
+  if (!Array.isArray(value)) return void 0;
+  const relations = value.flatMap((candidate) => {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return [];
+    const relation = candidate;
+    if (!exactKeys2(relation, SHARED_LEFT_RAIL_RELATION_KEYS)) return [];
+    if (!relation.target || typeof relation.target !== "object" || Array.isArray(relation.target)) {
+      return [];
+    }
+    const target = relation.target;
+    if (!exactKeys2(target, SHARED_LEFT_RAIL_TARGET_KEYS)) return [];
+    if (!relationString(relation.relationId, PUBLIC_LAYERDOC_MAX_OPTIONAL_STRING_LENGTH) || relation.relationKind !== "shared-left-rail" || !Array.isArray(relation.memberExtractionIndices) || relation.memberExtractionIndices.length < 3 || relation.memberExtractionIndices.length > PUBLIC_LAYERDOC_MAX_LAYERS || !relation.memberExtractionIndices.every((index) => Number.isSafeInteger(index) && index >= 0) || new Set(relation.memberExtractionIndices).size !== relation.memberExtractionIndices.length || !relationString(relation.role, PUBLIC_LAYERDOC_MAX_OPTIONAL_STRING_LENGTH) || !relationString(relation.container, PUBLIC_LAYERDOC_MAX_GROUP_LENGTH) || target.coordinateSpace !== "prepared-source" && target.coordinateSpace !== "source" || typeof target.x !== "number" || !Number.isFinite(target.x) || target.x < 0 || relation.writingDirection !== "ltr" || relation.sourceProvenance !== "declared-extraction-boxes" || !relationString(relation.measurementRevision, PUBLIC_LAYERDOC_MAX_OPTIONAL_STRING_LENGTH) || !relationString(relation.evidenceId, PUBLIC_LAYERDOC_MAX_OPTIONAL_STRING_LENGTH)) return [];
+    return [{
+      relationId: relation.relationId,
+      relationKind: "shared-left-rail",
+      memberExtractionIndices: [...relation.memberExtractionIndices],
+      role: relation.role,
+      container: relation.container,
+      target: {
+        coordinateSpace: target.coordinateSpace,
+        x: target.x
+      },
+      writingDirection: "ltr",
+      sourceProvenance: "declared-extraction-boxes",
+      measurementRevision: relation.measurementRevision,
+      evidenceId: relation.evidenceId
+    }];
+  });
+  return relations.length > 0 ? relations : void 0;
+}
+function record2(value, path, issues) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    issues.push(`${path} must be an object`);
+    return null;
+  }
+  return value;
+}
+function finiteNumber(value, path, issues) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    issues.push(`${path} must be a finite number`);
+    return null;
+  }
+  return value;
+}
+function parseQuad(value, path, issues) {
+  if (!Array.isArray(value) || value.length !== 4) {
+    issues.push(`${path} must contain exactly four numbers`);
+    return null;
+  }
+  const numbers = value.map((part, index) => finiteNumber(part, `${path}[${index}]`, issues));
+  if (numbers.some((part) => part === null)) return null;
+  return numbers;
+}
+function parseMeasuredTextInk(value, path, issues) {
+  const input = record2(value, path, issues);
+  if (!input) return void 0;
+  const forwarded = forwardUnknownKeys(
+    input,
+    MEASURED_INK_KEYS,
+    path,
+    issues
+  );
+  const rows = finiteNumber(input.rows, `${path}.rows`, issues);
+  if (rows !== null && (!Number.isSafeInteger(rows) || rows < 0)) {
+    issues.push(`${path}.rows must be a non-negative safe integer`);
+  }
+  if (!TEXT_INK_BASES.includes(input.basis)) {
+    issues.push(`${path}.basis must be one of ${TEXT_INK_BASES.join(", ")}`);
+  }
+  const marginPx = parseQuad(input.marginPx, `${path}.marginPx`, issues);
+  const box = input.box === void 0 ? void 0 : parseQuad(input.box, `${path}.box`, issues);
+  if (box && (box[0] < 0 || box[1] < 0 || box[2] < 0 || box[3] < 0)) {
+    issues.push(`${path}.box must have a non-negative origin and extent`);
+    return void 0;
+  }
+  if (input.refusal !== void 0 && !TEXT_INK_REFUSALS.includes(input.refusal)) {
+    issues.push(`${path}.refusal must be one of ${TEXT_INK_REFUSALS.join(", ")}`);
+  }
+  if (rows === null || marginPx === null || input.box !== void 0 && !box) return void 0;
+  return carryUnknownKeys({
+    ...box ? { box } : {},
+    rows,
+    basis: input.basis,
+    marginPx,
+    ...input.refusal === void 0 ? {} : { refusal: input.refusal }
+  }, forwarded);
+}
+
+// packages/layerdoc/src/core/public-layerdoc-v2.ts
+var PUBLIC_LAYERDOC_V2_VERSION = "2";
+var PUBLIC_ARTIFACT_PIXELS_V2 = ["source", "matted", "cleaned"];
+var PUBLIC_ARTIFACT_LINEAGE_V2 = ["prepared-source", "provider-upscale", "clean-output"];
+var PUBLIC_UPSCALE_PERIMETER_INTEGRITIES_V2 = ["guarded", "edge-exposed"];
+var MEASURED_MATTED_PUBLICATIONS = 73;
+var PUBLISH_MATTED_PROVENANCE = MEASURED_MATTED_PUBLICATIONS > 0;
+
+// packages/layerdoc/src/core/public-layerdoc-v2-input-values.ts
+var SLOT_KINDS = {
+  plate: "plate",
+  plate2x: "plate2x",
+  region2x: "region2x",
+  cutout: "cutout",
+  crop: "pixels"
+};
+var carriesPixelFields = (slotKind) => slotKind === "pixels" || slotKind === "region2x" || slotKind === "cutout";
+var ARTIFACT_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+var IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/svg+xml"]);
+var record3 = (value, path, issues) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    issues.push(`${path} must be an object`);
+    return null;
+  }
+  return value;
+};
+var ARTIFACT_REF_BASE_KEYS = [
+  "artifactId",
+  "url",
+  "expiresAt",
+  "mediaType",
+  "width",
+  "height",
+  "scale"
+];
+var ARTIFACT_REF_SLOT_KEYS = Object.freeze({
+  plain: ARTIFACT_REF_BASE_KEYS,
+  plate: [...ARTIFACT_REF_BASE_KEYS, "mode"],
+  plate2x: [...ARTIFACT_REF_BASE_KEYS, "mode"],
+  pixels: [...ARTIFACT_REF_BASE_KEYS, "pixels", "lineage", "carriesSourceContent"],
+  region2x: [
+    ...ARTIFACT_REF_BASE_KEYS,
+    "pixels",
+    "lineage",
+    "carriesSourceContent",
+    "upscalePerimeterIntegrity"
+  ],
+  cutout: [
+    ...ARTIFACT_REF_BASE_KEYS,
+    "pixels",
+    "lineage",
+    "carriesSourceContent",
+    "carriesLayerContent"
+  ]
+});
+var ARTIFACT_REF_RESERVED_KEYS = new Set(
+  Object.values(ARTIFACT_REF_SLOT_KEYS).flat().filter((key) => !ARTIFACT_REF_BASE_KEYS.includes(key))
+);
+var ARTIFACT_REF_KEYS = /* @__PURE__ */ new Set([
+  ...ARTIFACT_REF_BASE_KEYS,
+  ...ARTIFACT_REF_RESERVED_KEYS
+]);
+var ARTIFACT_SLOT_KEYS = new Set(Object.keys(SLOT_KINDS));
+var finiteNumber2 = (value, path, issues) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    issues.push(`${path} must be a finite number`);
+    return null;
+  }
+  return value;
+};
+var boundedString = (value, path, issues, options = {}) => {
+  if (typeof value !== "string") {
+    issues.push(`${path} must be a string`);
+    return null;
+  }
+  if (/\u0000|[\u0001-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value)) {
+    issues.push(`${path} contains unsupported control characters`);
+  }
+  if (options.nonEmpty && value.trim().length === 0) issues.push(`${path} must not be empty`);
+  if (options.max !== void 0 && value.length > options.max) {
+    issues.push(`${path} must not exceed ${options.max} characters`);
+  }
+  return value;
+};
+var parseBox = (value, path, issues, allowNegativeOrigin = false) => {
+  if (!Array.isArray(value) || value.length !== 4) {
+    issues.push(`${path} must contain exactly four numbers`);
+    return null;
+  }
+  const values = value.map((part, index) => finiteNumber2(part, `${path}[${index}]`, issues));
+  if (values.some((part) => part === null)) return null;
+  const box = values;
+  if (!allowNegativeOrigin && (box[0] < 0 || box[1] < 0)) {
+    issues.push(`${path} x and y must be non-negative`);
+  }
+  if (box[2] <= 0 || box[3] <= 0) issues.push(`${path} width and height must be positive`);
+  return box;
+};
+var unionBoxes = (boxes) => {
+  if (boxes.length === 0) return null;
+  const left = Math.min(...boxes.map((box) => box[0]));
+  const top = Math.min(...boxes.map((box) => box[1]));
+  const right = Math.max(...boxes.map((box) => box[0] + box[2]));
+  const bottom = Math.max(...boxes.map((box) => box[1] + box[3]));
+  return [left, top, right - left, bottom - top];
+};
+var parseArtifactRef = (value, path, issues, requireUrl, slotKind) => {
+  const input = record3(value, path, issues);
+  if (!input) return null;
+  const plate = slotKind === "plate";
+  const forwarded = forwardUnknownKeys(
+    input,
+    new Set(ARTIFACT_REF_SLOT_KEYS[slotKind]),
+    path,
+    issues,
+    { reserved: ARTIFACT_REF_RESERVED_KEYS }
+  );
+  const artifactId = boundedString(input.artifactId, `${path}.artifactId`, issues, { nonEmpty: true, max: 128 });
+  if (artifactId && !ARTIFACT_ID.test(artifactId)) issues.push(`${path}.artifactId has an invalid format`);
+  const url = input.url === void 0 ? void 0 : boundedString(input.url, `${path}.url`, issues, { nonEmpty: true, max: 2048 });
+  const expiresAt = input.expiresAt === void 0 ? void 0 : boundedString(input.expiresAt, `${path}.expiresAt`, issues, { nonEmpty: true, max: 64 });
+  if (requireUrl && (!url || !expiresAt)) issues.push(`${path} must include url and expiresAt`);
+  if (url && !expiresAt || !url && expiresAt) issues.push(`${path}.url and expiresAt must be supplied together`);
+  if (url) {
+    try {
+      const parsed = new URL(url);
+      if (parsed.protocol !== "https:" && parsed.protocol !== "http:") issues.push(`${path}.url must use http or https`);
+    } catch {
+      issues.push(`${path}.url must be an absolute URL`);
+    }
+  }
+  if (expiresAt && !Number.isFinite(Date.parse(expiresAt))) issues.push(`${path}.expiresAt must be an ISO timestamp`);
+  const mediaType = input.mediaType === void 0 ? void 0 : boundedString(input.mediaType, `${path}.mediaType`, issues, { nonEmpty: true, max: 64 });
+  if (mediaType && !IMAGE_MEDIA_TYPES.has(mediaType.toLowerCase())) {
+    issues.push(`${path}.mediaType must be image/png, image/jpeg, image/webp, or image/svg+xml`);
+  }
+  const dimensions = { width: void 0, height: void 0 };
+  for (const field of ["width", "height"]) {
+    if (input[field] === void 0) continue;
+    const parsed = finiteNumber2(input[field], `${path}.${field}`, issues);
+    if (parsed !== null) {
+      if (!Number.isInteger(parsed) || parsed <= 0) issues.push(`${path}.${field} must be a positive integer`);
+      else dimensions[field] = parsed;
+    }
+  }
+  let scale;
+  if (input.scale !== void 0) {
+    const parsed = finiteNumber2(input.scale, `${path}.scale`, issues);
+    if (parsed !== null) {
+      if (parsed <= 0) issues.push(`${path}.scale must be positive`);
+      else scale = parsed;
+    }
+  }
+  let mode;
+  if (plate || slotKind === "plate2x" && input.mode !== void 0) {
+    if (input.mode !== "plate" && input.mode !== "overlay") issues.push(`${path}.mode must be plate or overlay`);
+    else mode = input.mode;
+  }
+  let pixels;
+  if (carriesPixelFields(slotKind) && input.pixels !== void 0) {
+    if (!PUBLIC_ARTIFACT_PIXELS_V2.includes(input.pixels)) {
+      issues.push(`${path}.pixels must be ${PUBLIC_ARTIFACT_PIXELS_V2.join(", ")}`);
+    } else {
+      pixels = input.pixels;
+    }
+  }
+  let lineage;
+  if (carriesPixelFields(slotKind) && input.lineage !== void 0) {
+    if (!PUBLIC_ARTIFACT_LINEAGE_V2.includes(input.lineage)) {
+      issues.push(`${path}.lineage must be ${PUBLIC_ARTIFACT_LINEAGE_V2.join(", ")}`);
+    } else {
+      lineage = input.lineage;
+    }
+  }
+  let carriesSourceContent;
+  if (carriesPixelFields(slotKind) && input.carriesSourceContent !== void 0) {
+    if (typeof input.carriesSourceContent !== "boolean") {
+      issues.push(`${path}.carriesSourceContent must be a boolean`);
+    } else {
+      carriesSourceContent = input.carriesSourceContent;
+    }
+  }
+  let upscalePerimeterIntegrity;
+  if (slotKind === "region2x" && input.upscalePerimeterIntegrity !== void 0) {
+    if (!PUBLIC_UPSCALE_PERIMETER_INTEGRITIES_V2.includes(
+      input.upscalePerimeterIntegrity
+    )) {
+      issues.push(
+        `${path}.upscalePerimeterIntegrity must be ${PUBLIC_UPSCALE_PERIMETER_INTEGRITIES_V2.join(" or ")}`
+      );
+    } else {
+      upscalePerimeterIntegrity = input.upscalePerimeterIntegrity;
+    }
+  }
+  let carriesLayerContent;
+  if (slotKind === "cutout" && input.carriesLayerContent !== void 0) {
+    if (typeof input.carriesLayerContent !== "boolean") {
+      issues.push(`${path}.carriesLayerContent must be a boolean`);
+    } else {
+      carriesLayerContent = input.carriesLayerContent;
+    }
+  }
+  if (!artifactId) return null;
+  const output = {
+    artifactId,
+    ...url ? { url } : {},
+    ...expiresAt ? { expiresAt } : {},
+    ...mediaType ? { mediaType: mediaType.toLowerCase() } : {},
+    ...dimensions.width ? { width: dimensions.width } : {},
+    ...dimensions.height ? { height: dimensions.height } : {},
+    ...scale ? { scale } : {}
+  };
+  return carryUnknownKeys({
+    ...output,
+    ...mode ? { mode } : {},
+    ...pixels ? { pixels } : {},
+    ...lineage ? { lineage } : {},
+    ...carriesSourceContent !== void 0 ? { carriesSourceContent } : {},
+    ...upscalePerimeterIntegrity ? { upscalePerimeterIntegrity } : {},
+    ...carriesLayerContent !== void 0 ? { carriesLayerContent } : {}
+  }, forwarded);
+};
+var parseArtifacts = (value, path, issues, requireUrl) => {
+  if (value === void 0) return void 0;
+  const input = record3(value, path, issues);
+  if (!input) return void 0;
+  refuseUnknownKeys(input, ARTIFACT_SLOT_KEYS, path, issues);
+  const output = {};
+  for (const slot of ["plate", "plate2x", "region2x", "cutout", "crop"]) {
+    if (input[slot] === void 0) continue;
+    const parsed = parseArtifactRef(input[slot], `${path}.${slot}`, issues, requireUrl, SLOT_KINDS[slot]);
+    if (parsed) output[slot] = parsed;
+  }
+  if (output.plate2x && !output.plate) {
+    issues.push(`${path}.plate2x requires plate so its cleanup mode is defined`);
+  }
+  return Object.keys(output).length ? output : void 0;
+};
+
+// packages/layerdoc/src/core/public-layerdoc-v2-input.ts
+var MAX_GROUP_DEPTH = 512;
+var MAX_TOTAL_NODES = PUBLIC_LAYERDOC_MAX_LAYERS * (MAX_GROUP_DEPTH + 1);
+var PublicLayerDocV2ValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`Invalid PublicLayerDocV2: ${issues.join("; ")}`);
+    this.name = "PublicLayerDocV2ValidationError";
+    this.issues = issues;
+  }
+};
+var LEAF_KEYS = /* @__PURE__ */ new Set([
+  "kind",
+  "content",
+  "z",
+  "extractionIndex",
+  "box",
+  "typographicLockup",
+  "labelBox",
+  "controlTextAnchor",
+  "markerBox",
+  "checkableKind",
+  "checked",
+  "repeatedRules",
+  "canvasBackdrop",
+  "surface",
+  "surfacePattern",
+  "fontSizePx",
+  "fittedFontSizePx",
+  "textScaleX",
+  "textScaleY",
+  "fontWeight",
+  "fontStyle",
+  "textColorRanges",
+  "googleFontFamily",
+  "iconSvg",
+  "color",
+  "markerColor",
+  "align",
+  "textRotationDeg",
+  "textSlantDeg",
+  "styleHint",
+  "style",
+  "measured",
+  "artifacts",
+  "hidden",
+  "assetCrop",
+  "sourceFallback",
+  "groundInk",
+  "groundRegistration",
+  "groundField",
+  "clipPathFrame"
+]);
+var LEAF_RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "borderRadiusPx",
+  "borderWidthPx",
+  "blurPx",
+  ...PUBLIC_LAYER_RESERVED_KEYS
+]);
+var MEASURED_KEYS = /* @__PURE__ */ new Set(["ink"]);
+var GROUP_KEYS = /* @__PURE__ */ new Set([
+  "kind",
+  "name",
+  "box",
+  "children",
+  "hidden"
+]);
+var DOCUMENT_KEYS = /* @__PURE__ */ new Set([
+  "version",
+  "canvas",
+  "source",
+  "extractionContract",
+  "layoutRelations",
+  "layers"
+]);
+var CANVAS_KEYS = /* @__PURE__ */ new Set(["width", "height"]);
+var LEAF_STRING_FIELDS = [
+  "surface",
+  "fontStyle",
+  "googleFontFamily",
+  "color",
+  "markerColor",
+  "align"
+];
+var LEAF_NUMBER_FIELDS = [
+  "fontSizePx",
+  "fittedFontSizePx",
+  "textScaleX",
+  "textScaleY",
+  "fontWeight",
+  "textRotationDeg",
+  "textSlantDeg"
+];
+var parseLeaf = (input, path, issues, requireUrl, allowCanvasOverflow) => {
+  const forwarded = forwardUnknownKeys(input, LEAF_KEYS, path, issues, {
+    reserved: LEAF_RESERVED_KEYS
+  });
+  const kind = boundedString(input.kind, `${path}.kind`, issues, {
+    nonEmpty: true,
+    max: PUBLIC_LAYERDOC_MAX_KIND_LENGTH
+  });
+  const content = boundedString(input.content, `${path}.content`, issues, {
+    max: PUBLIC_LAYERDOC_MAX_CONTENT_LENGTH
+  });
+  const z = finiteNumber2(input.z, `${path}.z`, issues);
+  if (z !== null && (!Number.isInteger(z) || z < 0)) issues.push(`${path}.z must be a non-negative integer`);
+  const box = parseBox(input.box, `${path}.box`, issues, allowCanvasOverflow);
+  if (!kind || content === null || z === null || !box) return null;
+  const output = { kind, content, z, box };
+  const typographicLockup = parseTypographicLockup(
+    input.typographicLockup,
+    `${path}.typographicLockup`,
+    issues
+  );
+  if (typographicLockup) output.typographicLockup = typographicLockup;
+  if (input.labelBox !== void 0) {
+    const labelBox = parseBox(input.labelBox, `${path}.labelBox`, issues, allowCanvasOverflow);
+    if (labelBox) output.labelBox = labelBox;
+  }
+  const controlTextAnchor = parseControlTextAnchor(
+    input.controlTextAnchor,
+    `${path}.controlTextAnchor`,
+    issues
+  );
+  if (controlTextAnchor) output.controlTextAnchor = controlTextAnchor;
+  if (input.markerBox !== void 0) {
+    const markerBox = parseBox(input.markerBox, `${path}.markerBox`, issues, allowCanvasOverflow);
+    if (markerBox) output.markerBox = markerBox;
+  }
+  if (input.checkableKind !== void 0) {
+    if (!["checkbox", "radio", "toggle"].includes(String(input.checkableKind))) {
+      issues.push(`${path}.checkableKind must be checkbox, radio, or toggle`);
+    } else {
+      output.checkableKind = input.checkableKind;
+    }
+  }
+  if (input.checked !== void 0) {
+    if (typeof input.checked !== "boolean") issues.push(`${path}.checked must be a boolean`);
+    else output.checked = input.checked;
+  }
+  const repeatedRules = parseRepeatedRules(input.repeatedRules, `${path}.repeatedRules`, issues);
+  if (repeatedRules) output.repeatedRules = repeatedRules;
+  if (input.extractionIndex !== void 0) {
+    const extractionIndex = finiteNumber2(
+      input.extractionIndex,
+      `${path}.extractionIndex`,
+      issues
+    );
+    if (extractionIndex !== null && (!Number.isSafeInteger(extractionIndex) || extractionIndex < 0)) {
+      issues.push(`${path}.extractionIndex must be a non-negative safe integer`);
+    } else if (extractionIndex !== null) {
+      output.extractionIndex = extractionIndex;
+    }
+  }
+  if (input.canvasBackdrop !== void 0) {
+    if (input.canvasBackdrop !== true) issues.push(`${path}.canvasBackdrop must be true`);
+    else output.canvasBackdrop = true;
+  }
+  if (input.assetCrop !== void 0) {
+    const crop = parseBox(input.assetCrop, `${path}.assetCrop`, issues);
+    if (crop) {
+      if (crop[0] + crop[2] > 1.001 || crop[1] + crop[3] > 1.001) {
+        issues.push(`${path}.assetCrop must stay within normalized source bounds`);
+      } else output.assetCrop = crop;
+    }
+  }
+  if (input.hidden !== void 0) {
+    if (typeof input.hidden !== "boolean") issues.push(`${path}.hidden must be a boolean`);
+    else if (input.hidden) output.hidden = true;
+  }
+  if (input.sourceFallback !== void 0) {
+    if (input.sourceFallback !== "disabled") issues.push(`${path}.sourceFallback must be disabled`);
+    else output.sourceFallback = "disabled";
+  }
+  if (input.groundInk !== void 0) {
+    if (!PUBLIC_LAYER_GROUND_INK.includes(input.groundInk)) {
+      issues.push(`${path}.groundInk must be ${PUBLIC_LAYER_GROUND_INK.join(" or ")}`);
+    } else output.groundInk = input.groundInk;
+  }
+  if (input.surfacePattern !== void 0) {
+    try {
+      output.surfacePattern = parseSurfacePattern(input.surfacePattern, `${path}.surfacePattern`);
+    } catch (error) {
+      issues.push(error instanceof Error ? error.message : `${path}.surfacePattern is invalid`);
+    }
+  }
+  if (input.clipPathFrame !== void 0) {
+    if (input.clipPathFrame !== PUBLIC_CLIP_PATH_FRAME) {
+      issues.push(`${path}.clipPathFrame must be ${PUBLIC_CLIP_PATH_FRAME}`);
+    } else {
+      output.clipPathFrame = PUBLIC_CLIP_PATH_FRAME;
+    }
+  }
+  if (input.groundRegistration !== void 0) {
+    if (!PUBLIC_LAYER_GROUND_REGISTRATION.includes(
+      input.groundRegistration
+    )) {
+      issues.push(`${path}.groundRegistration must be ${PUBLIC_LAYER_GROUND_REGISTRATION.join(" or ")}`);
+    } else output.groundRegistration = input.groundRegistration;
+  }
+  const groundField = parseGroundField(input.groundField, `${path}.groundField`, issues);
+  if (groundField) output.groundField = groundField;
+  if (input.iconSvg !== void 0) {
+    try {
+      output.iconSvg = parseIconSvg(input.iconSvg, `${path}.iconSvg`);
+    } catch (error) {
+      issues.push(error instanceof Error ? error.message : `${path}.iconSvg is invalid`);
+    }
+  }
+  for (const field of LEAF_STRING_FIELDS) {
+    if (input[field] === void 0) continue;
+    const parsed = boundedString(input[field], `${path}.${field}`, issues, {
+      max: PUBLIC_LAYERDOC_MAX_OPTIONAL_STRING_LENGTH
+    });
+    if (parsed !== null) output[field] = parsed;
+  }
+  validateTypographicLockupOwner({
+    kind: output.kind,
+    content: output.content,
+    surface: output.surface,
+    lockup: output.typographicLockup,
+    path,
+    issues
+  });
+  if (input.styleHint !== void 0) {
+    const parsed = boundedString(input.styleHint, `${path}.styleHint`, issues, {
+      max: PUBLIC_LAYERDOC_MAX_OPTIONAL_STRING_LENGTH
+    });
+    if (parsed !== null) {
+      if (!isSafeStyleDescription(parsed)) {
+        issues.push(`${path}.styleHint must be descriptive text without CSS or HTML boundaries`);
+      } else {
+        output.styleHint = parsed;
+      }
+    }
+  }
+  for (const field of LEAF_NUMBER_FIELDS) {
+    if (input[field] === void 0) continue;
+    const parsed = finiteNumber2(input[field], `${path}.${field}`, issues);
+    if (parsed !== null) output[field] = parsed;
+  }
+  if (output.fittedFontSizePx !== void 0) {
+    if (output.fittedFontSizePx <= 0) issues.push(`${path}.fittedFontSizePx must be positive`);
+    if (output.fontSizePx === void 0) issues.push(`${path}.fittedFontSizePx requires fontSizePx`);
+    else if (output.fittedFontSizePx > output.fontSizePx) {
+      issues.push(`${path}.fittedFontSizePx must not exceed fontSizePx`);
+    }
+  }
+  for (const field of ["textScaleX", "textScaleY"]) {
+    const value = output[field];
+    if (value !== void 0 && !isValidTextAxisScale(value)) {
+      issues.push(
+        `${path}.${field} must have magnitude from ${MIN_TEXT_AXIS_SCALE} to ${MAX_TEXT_AXIS_SCALE}`
+      );
+    }
+  }
+  const textColorRanges = parseTextColorRanges(
+    input.textColorRanges,
+    content,
+    `${path}.textColorRanges`,
+    issues
+  );
+  if (textColorRanges) output.textColorRanges = textColorRanges;
+  if (input.style !== void 0) {
+    try {
+      output.style = parseSurfaceCss(input.style);
+    } catch (error) {
+      issues.push(`${path}.${error instanceof Error ? error.message : "style is invalid"}`);
+    }
+  }
+  if (output.clipPathFrame && !output.style?.clipPath?.trim().startsWith("path(")) {
+    issues.push(`${path}.clipPathFrame requires style.clipPath path(...)`);
+  }
+  const hasCheckableFact = output.checkableKind !== void 0 || output.markerBox !== void 0 || output.checked !== void 0 || output.markerColor !== void 0;
+  if (hasCheckableFact) {
+    if (output.kind.trim().toLowerCase() !== "input") {
+      issues.push(`${path} checkable facts require kind input`);
+    }
+    if (output.checkableKind === void 0) {
+      issues.push(`${path}.checkableKind is required with checkable facts`);
+    } else {
+      try {
+        selectionControlDeclaration(output);
+      } catch (error) {
+        issues.push(`${path}.${error instanceof Error ? error.message : "checkable declaration is invalid"}`);
+      }
+    }
+  }
+  if (input.measured !== void 0) {
+    const measured = record3(input.measured, `${path}.measured`, issues);
+    if (measured) {
+      const forwardedMeasured = forwardUnknownKeys(measured, MEASURED_KEYS, `${path}.measured`, issues);
+      if (measured.ink !== void 0) {
+        const parsedInk = parseMeasuredTextInk(measured.ink, `${path}.measured.ink`, issues);
+        if (parsedInk) output.measured = { ink: parsedInk };
+      }
+      if (forwardedMeasured) output.measured = carryUnknownKeys(output.measured ?? {}, forwardedMeasured);
+    }
+  }
+  const artifacts = parseArtifacts(input.artifacts, `${path}.artifacts`, issues, requireUrl);
+  if (artifacts) output.artifacts = artifacts;
+  return carryUnknownKeys(output, forwarded);
+};
+function parsePublicLayerDocV2(value, options = {}) {
+  const issues = [];
+  const input = record3(value, "document", issues);
+  if (!input) throw new PublicLayerDocV2ValidationError(issues);
+  const forwardedDocument = forwardUnknownKeys(
+    input,
+    DOCUMENT_KEYS,
+    "document",
+    issues,
+    { reserved: DOCUMENT_RESERVED_KEYS }
+  );
+  if (input.version !== PUBLIC_LAYERDOC_V2_VERSION) issues.push(`document.version must be ${PUBLIC_LAYERDOC_V2_VERSION}`);
+  const extractionContract = parseExtractionContract(
+    input.extractionContract,
+    "document.extractionContract",
+    issues
+  );
+  const layoutRelations = parseSharedLeftRailRelations(input.layoutRelations);
+  const canvasInput = record3(input.canvas, "canvas", issues);
+  let width = null;
+  let height = null;
+  let forwardedCanvas = null;
+  if (canvasInput) {
+    forwardedCanvas = forwardUnknownKeys(canvasInput, CANVAS_KEYS, "canvas", issues);
+    width = finiteNumber2(canvasInput.width, "canvas.width", issues);
+    height = finiteNumber2(canvasInput.height, "canvas.height", issues);
+    for (const [name, part] of [["width", width], ["height", height]]) {
+      if (part !== null && (!Number.isInteger(part) || part <= 0 || part > PUBLIC_LAYERDOC_MAX_CANVAS_SIDE)) {
+        issues.push(`canvas.${name} must be a positive integer no greater than ${PUBLIC_LAYERDOC_MAX_CANVAS_SIDE}`);
+      }
+    }
+  }
+  const requireUrl = options.requireHydratedArtifactUrls === true;
+  const allowCanvasOverflow = options.allowCanvasOverflow === true;
+  const source = input.source === void 0 ? null : parseArtifactRef(input.source, "source", issues, requireUrl, "plain");
+  if (!source) issues.push("document.source is required");
+  if (source && (source.width === void 0 || source.height === void 0)) {
+    issues.push("source must include width and height");
+  }
+  if (source && width && height) {
+    if (source.width !== void 0 && source.width !== width) issues.push("source.width must match canvas.width");
+    if (source.height !== void 0 && source.height !== height) issues.push("source.height must match canvas.height");
+  }
+  const leaves = [];
+  let nodeCount = 0;
+  const parseNodes = (nodes, path, depth, groupPathLength) => {
+    if (!Array.isArray(nodes)) {
+      issues.push(`${path} must be an array`);
+      return [];
+    }
+    if (depth > MAX_GROUP_DEPTH) {
+      issues.push(`${path} exceeds the maximum group depth of ${MAX_GROUP_DEPTH}`);
+      return [];
+    }
+    const output = [];
+    nodes.forEach((nodeValue, index) => {
+      nodeCount += 1;
+      if (nodeCount > MAX_TOTAL_NODES) return;
+      const nodePath = `${path}[${index}]`;
+      const node = record3(nodeValue, nodePath, issues);
+      if (!node) return;
+      if (Object.prototype.hasOwnProperty.call(node, "children")) {
+        const forwardedGroup = forwardUnknownKeys(
+          node,
+          GROUP_KEYS,
+          nodePath,
+          issues
+        );
+        if (node.kind !== "group") issues.push(`${nodePath}.kind must be group when children is present`);
+        const name = boundedString(node.name, `${nodePath}.name`, issues, {
+          nonEmpty: true,
+          max: PUBLIC_LAYERDOC_MAX_GROUP_LENGTH
+        });
+        if (name?.includes("/")) issues.push(`${nodePath}.name must not contain /`);
+        parseBox(node.box, `${nodePath}.box`, issues, allowCanvasOverflow);
+        const nestedGroupPathLength = name ? groupPathLength + (groupPathLength > 0 ? 1 : 0) + name.length : groupPathLength;
+        if (nestedGroupPathLength > PUBLIC_LAYERDOC_MAX_GROUP_LENGTH) {
+          issues.push(`${nodePath} aggregate group path must not exceed ${PUBLIC_LAYERDOC_MAX_GROUP_LENGTH} characters`);
+        }
+        const children = parseNodes(
+          node.children,
+          `${nodePath}.children`,
+          depth + 1,
+          nestedGroupPathLength
+        );
+        if (children.length === 0) issues.push(`${nodePath}.children must not be empty`);
+        const measured = unionBoxes(children.map((child) => child.box));
+        if (name && measured && nestedGroupPathLength <= PUBLIC_LAYERDOC_MAX_GROUP_LENGTH) {
+          if (node.hidden !== void 0 && typeof node.hidden !== "boolean") {
+            issues.push(`${nodePath}.hidden must be a boolean`);
+          }
+          output.push(carryUnknownKeys({
+            kind: "group",
+            name,
+            box: measured,
+            ...node.hidden === true ? { hidden: true } : {},
+            children
+          }, forwardedGroup));
+        }
+        return;
+      }
+      const leaf = parseLeaf(node, nodePath, issues, requireUrl, allowCanvasOverflow);
+      if (leaf) {
+        leaves.push(leaf);
+        output.push(leaf);
+      }
+    });
+    return output;
+  };
+  const layers = parseNodes(input.layers, "layers", 0, 0);
+  if (nodeCount > MAX_TOTAL_NODES) issues.push(`document must not contain more than ${MAX_TOTAL_NODES} total nodes`);
+  if (leaves.length > PUBLIC_LAYERDOC_MAX_LAYERS) {
+    issues.push(`document must not contain more than ${PUBLIC_LAYERDOC_MAX_LAYERS} leaf layers`);
+  }
+  const zValues = new Set(leaves.map((leaf) => leaf.z));
+  if (zValues.size !== leaves.length || [...zValues].some((z) => z < 0 || z >= leaves.length)) {
+    issues.push("leaf z values must be unique and contiguous from 0");
+  }
+  const extractionIndices = leaves.flatMap((leaf) => leaf.extractionIndex === void 0 ? [] : [leaf.extractionIndex]);
+  if (new Set(extractionIndices).size !== extractionIndices.length) {
+    issues.push("leaf extractionIndex values must be unique when present");
+  }
+  if (!allowCanvasOverflow && width !== null && height !== null) {
+    leaves.forEach((leaf) => {
+      if (leaf.box[0] + leaf.box[2] > width || leaf.box[1] + leaf.box[3] > height) {
+        issues.push(`leaf z=${leaf.z} box must stay inside the canvas`);
+      }
+    });
+  }
+  const artifactIds = /* @__PURE__ */ new Set();
+  const collectRef = (ref) => {
+    if (artifactIds.has(ref.artifactId)) issues.push(`artifactId ${ref.artifactId} is referenced more than once`);
+    artifactIds.add(ref.artifactId);
+  };
+  if (source) collectRef(source);
+  for (const leaf of leaves) {
+    if (!leaf.artifacts) continue;
+    for (const ref of Object.values(leaf.artifacts)) if (ref) collectRef(ref);
+  }
+  if (issues.length || width === null || height === null || !source) {
+    throw new PublicLayerDocV2ValidationError(issues);
+  }
+  return carryUnknownKeys({
+    version: PUBLIC_LAYERDOC_V2_VERSION,
+    canvas: carryUnknownKeys({ width, height }, forwardedCanvas),
+    source,
+    ...extractionContract ? { extractionContract } : {},
+    ...layoutRelations ? { layoutRelations } : {},
+    layers
+  }, forwardedDocument);
+}
+export {
+  parsePublicLayerDocV2
+};