@fuaran-ui/ops 0.9.0 → 0.19.0

package/dist/index.cjs

@@ -80,10 +80,11 @@ var formatFiniteDouble = (n) => {
   return neg ? "-" + out : out;
 };
 var num = (n) => {
-  if (Number.isNaN(n)) return '"NaN"';
-  if (n === Infinity) return '"Infinity"';
-  if (n === -Infinity) return '"-Infinity"';
-  return formatFiniteDouble(n);
+  const v = Number(n);
+  if (Number.isNaN(v)) return '"NaN"';
+  if (v === Infinity) return '"Infinity"';
+  if (v === -Infinity) return '"-Infinity"';
+  return formatFiniteDouble(v);
 };
 var bool = (b) => b ? "true" : "false";
 var jObject = (fields) => {
@@ -593,6 +594,9 @@ var pushWeightOptional = (fields, w) => {
 var pushEmphasisOptional = (fields, e) => {
   if (e !== "Normal") fields.push(["emphasis", str(e)]);
 };
+var pushTrendPolarityOptional = (fields, p) => {
+  if (p !== "HigherIsBetter") fields.push(["trendPolarity", str(p)]);
+};
 var pushCellFormatOptional = (fields, key, f) => {
   if (f.kind !== "None") fields.push([key, cellFormat(f)]);
 };
@@ -610,6 +614,7 @@ var metricSpec = (s) => {
   pushEmphasisOptional(fields, s.emphasis);
   if (s.trend !== void 0) fields.push(["trend", binding(s.trend)]);
   if (s.trendFormat !== void 0) fields.push(["trendFormat", cellFormat(s.trendFormat)]);
+  pushTrendPolarityOptional(fields, s.trendPolarity);
   if (s.icon !== void 0) fields.push(["icon", str(s.icon)]);
   if (s.subtext !== void 0) fields.push(["subtext", textSource(s.subtext)]);
   return jObject(fields);
@@ -656,11 +661,40 @@ var linkSpec = (s) => {
   if (s.protection !== void 0) fields.push(["protection", str(s.protection)]);
   return jObject(fields);
 };
-var imageSpec = (s) => jObject([
-  ["alt", textSource(s.alt)],
-  ["src", binding(s.src)],
-  ["variant", str(s.variant)]
+var srcSetEntry = (e) => jObject([
+  ["src", binding(e.src)],
+  ["width", num(e.width)]
 ]);
+var imageSpec = (s) => {
+  const fields = [
+    ["alt", textSource(s.alt)],
+    ["src", binding(s.src)],
+    ["variant", str(s.variant)]
+  ];
+  if (s.fit !== "Natural") fields.push(["fit", str(s.fit)]);
+  if (s.aspectRatio !== "Natural") fields.push(["aspectRatio", str(s.aspectRatio)]);
+  if (s.loading !== "Eager") fields.push(["loading", str(s.loading)]);
+  if (s.caption !== void 0) fields.push(["caption", textSource(s.caption)]);
+  if (s.srcSet.length > 0) fields.push(["srcSet", jArray(s.srcSet.map(srcSetEntry))]);
+  if (s.expandable) fields.push(["expandable", bool(true)]);
+  return jObject(fields);
+};
+var mediaKind = (k) => {
+  if (k.$type === "Audio") return caseObj("Audio", []);
+  const fields = [];
+  if (k.autoplay) fields.push(["autoplay", bool(true)]);
+  if (k.poster !== void 0) fields.push(["poster", binding(k.poster)]);
+  return caseObj("Video", fields);
+};
+var mediaSpec = (s) => {
+  const fields = [];
+  if (!s.controls) fields.push(["controls", bool(false)]);
+  fields.push(["kind", mediaKind(s.kind)]);
+  fields.push(["label", textSource(s.label)]);
+  if (s.loop) fields.push(["loop", bool(true)]);
+  fields.push(["src", binding(s.src)]);
+  return jObject(fields);
+};
 var listSpec = (s) => jObject([
   ["items", jArray(s.items.map(textSource))],
   ["ordered", bool(s.ordered)]
@@ -869,6 +903,8 @@ var displayKind = (d) => {
       return hoistSpec("Link", linkSpec(d.spec));
     case "Image":
       return hoistSpec("Image", imageSpec(d.spec));
+    case "Media":
+      return hoistSpec("Media", mediaSpec(d.spec));
     case "List":
       return hoistSpec("List", listSpec(d.spec));
     case "Toast":
@@ -996,6 +1032,20 @@ var formFieldKind = (autoBind, k) => {
       return assertNever(k);
   }
 };
+var compareRule = (c) => jObject([
+  ["against", binding(c.against)],
+  ["op", str(c.op)]
+]);
+var fieldRule = (r) => {
+  const fields = [];
+  if (r.compare !== void 0) fields.push(["compare", compareRule(r.compare)]);
+  if (r.format !== void 0) fields.push(["format", str(r.format)]);
+  if (r.maxLength !== void 0) fields.push(["maxLength", intLit(r.maxLength)]);
+  if (r.message !== void 0) fields.push(["message", textSource(r.message)]);
+  if (r.minLength !== void 0) fields.push(["minLength", intLit(r.minLength)]);
+  if (r.pattern !== void 0) fields.push(["pattern", str(r.pattern)]);
+  return jObject(fields);
+};
 var formField = (f) => {
   const fields = [
     ["id", str(f.id)],
@@ -1004,6 +1054,7 @@ var formField = (f) => {
     ["required", bool(f.required)]
   ];
   if (f.help !== void 0) fields.push(["help", textSource(f.help)]);
+  if (f.rule !== void 0) fields.push(["rule", fieldRule(f.rule)]);
   return jObject(fields);
 };
 var formSpec = (s) => {
@@ -1271,6 +1322,11 @@ var boxLayout = (l) => {
       if (l.templateColumns !== void 0) fields.push(["templateColumns", str(l.templateColumns)]);
       return caseObj("Grid", fields);
     }
+    case "Masonry": {
+      const fields = [["cols", intLit(l.cols)]];
+      if (l.gap !== void 0) fields.push(["gap", intLit(l.gap)]);
+      return caseObj("Masonry", fields);
+    }
     case "Auto":
       return caseObj("Auto", []);
     default:
@@ -2683,8 +2739,6 @@ var stepParams = (t) => {
 var pipelineParams = (pipeline) => [
   ...new Set(pipeline.flatMap((t) => stepParams(t)))
 ];
-
-// src/parse.ts
 var peek = (s) => s.pos < s.text.length ? s.text[s.pos] : " ";
 var advance = (s) => {
   s.pos += 1;
@@ -2699,6 +2753,10 @@ var skipWs = (s) => {
     }
   }
 };
+var failLimit = (s, message) => ({
+  ok: false,
+  error: { message, offset: s.pos, limit: true }
+});
 var fail = (s, message) => ({
   ok: false,
   error: { message, offset: s.pos }
@@ -2721,7 +2779,14 @@ var parseStringRaw = (s) => {
     advance(s);
     if (c === '"') {
       return { ok: true, value: out };
-    } else if (c === "\\") {
+    }
+    if (out.length > schema.MAX_STRING_LENGTH) {
+      return failLimit(
+        s,
+        `string is longer than the wire limit MAX_STRING_LENGTH = ${schema.MAX_STRING_LENGTH}`
+      );
+    }
+    if (c === "\\") {
       if (s.pos >= s.text.length) return fail(s, "unterminated escape");
       const esc = s.text[s.pos];
       advance(s);
@@ -2821,6 +2886,12 @@ var parseValue = (s) => {
   }
 };
 var parseObjectValue = (s) => {
+  if (s.depth >= schema.MAX_JSON_DEPTH) {
+    return failLimit(
+      s,
+      `JSON nesting deeper than the wire limit MAX_JSON_DEPTH = ${schema.MAX_JSON_DEPTH}`
+    );
+  }
   const open = expectChar(s, "{");
   if (!open.ok) return open;
   skipWs(s);
@@ -2829,15 +2900,34 @@ var parseObjectValue = (s) => {
     advance(s);
     return { ok: true, value: { kind: "JObject", fields } };
   }
+  s.depth += 1;
+  let count = 0;
   for (; ; ) {
     skipWs(s);
     const keyR = parseStringRaw(s);
-    if (!keyR.ok) return keyR;
+    if (!keyR.ok) {
+      s.depth -= 1;
+      return keyR;
+    }
     skipWs(s);
     const colon = expectChar(s, ":");
-    if (!colon.ok) return colon;
+    if (!colon.ok) {
+      s.depth -= 1;
+      return colon;
+    }
     const valR = parseValue(s);
-    if (!valR.ok) return valR;
+    if (!valR.ok) {
+      s.depth -= 1;
+      return valR;
+    }
+    count += 1;
+    if (count > schema.MAX_ARRAY_LENGTH) {
+      s.depth -= 1;
+      return failLimit(
+        s,
+        `object has more members than the wire limit MAX_ARRAY_LENGTH = ${schema.MAX_ARRAY_LENGTH}`
+      );
+    }
     fields.set(keyR.value, valR.value);
     skipWs(s);
     const c = peek(s);
@@ -2845,13 +2935,21 @@ var parseObjectValue = (s) => {
       advance(s);
     } else if (c === "}") {
       advance(s);
+      s.depth -= 1;
       return { ok: true, value: { kind: "JObject", fields } };
     } else {
+      s.depth -= 1;
       return fail(s, `expected ',' or '}' but found '${c}'`);
     }
   }
 };
 var parseArrayValue = (s) => {
+  if (s.depth >= schema.MAX_JSON_DEPTH) {
+    return failLimit(
+      s,
+      `JSON nesting deeper than the wire limit MAX_JSON_DEPTH = ${schema.MAX_JSON_DEPTH}`
+    );
+  }
   const open = expectChar(s, "[");
   if (!open.ok) return open;
   skipWs(s);
@@ -2860,24 +2958,37 @@ var parseArrayValue = (s) => {
     advance(s);
     return { ok: true, value: { kind: "JArray", items } };
   }
+  s.depth += 1;
   for (; ; ) {
     const valR = parseValue(s);
-    if (!valR.ok) return valR;
+    if (!valR.ok) {
+      s.depth -= 1;
+      return valR;
+    }
     items.push(valR.value);
+    if (items.length > schema.MAX_ARRAY_LENGTH) {
+      s.depth -= 1;
+      return failLimit(
+        s,
+        `array is longer than the wire limit MAX_ARRAY_LENGTH = ${schema.MAX_ARRAY_LENGTH}`
+      );
+    }
     skipWs(s);
     const c = peek(s);
     if (c === ",") {
       advance(s);
     } else if (c === "]") {
       advance(s);
+      s.depth -= 1;
       return { ok: true, value: { kind: "JArray", items } };
     } else {
+      s.depth -= 1;
       return fail(s, `expected ',' or ']' but found '${c}'`);
     }
   }
 };
 var parse = (input) => {
-  const s = { text: input, pos: 0 };
+  const s = { text: input, pos: 0, depth: 0 };
   skipWs(s);
   if (s.pos >= s.text.length) {
     return { ok: false, error: { message: "input is empty", offset: 0 } };
@@ -2895,6 +3006,7 @@ var makeError = (code, path, message, expectedShape) => ({
 var missingField = (path, key, expected) => makeError("MISSING_FIELD", `${path}.${key}`, `missing required field '${key}'`, expected);
 var wrongType = (path, expected) => makeError("WRONG_TYPE", path, `expected ${expected}`, expected);
 var unknownDuCase = (path, got, expected) => makeError("UNKNOWN_DU_CASE", `${path}.$type`, `unknown discriminator '${got}'`, expected);
+var unknownEnumCase = (path, got, expected) => makeError("UNKNOWN_DU_CASE", path, `unknown discriminator '${got}'`, expected);
 var CLOSURE2 = "<closure>";
 var OPAQUE2 = "<opaque>";
 var requireObject = (path, j) => j.kind === "JObject" ? ok(j.fields) : wrongType(path, "JSON object");
@@ -3047,7 +3159,7 @@ var decodeJValMap = (path, j) => {
 var bareEnum = (path, j, valid, label) => {
   if (j.kind !== "JString") return wrongType(path, `JSON string (${label})`);
   if (valid.includes(j.value)) return ok(j.value);
-  return unknownDuCase(path, j.value, valid.join(" | "));
+  return unknownEnumCase(path, j.value, valid.join(" | "));
 };
 var ORIENTATION_ALIASES = {
   // CSS flex-direction prior: a row lays out horizontally, a column vertically.
@@ -3085,6 +3197,14 @@ var decodeHeadingVariant = (p, j) => {
   return bareEnum(p, j, ["Standard", "Eyebrow", "Caption", "Lead"], "HeadingVariant");
 };
 var decodeImageVariant = (p, j) => bareEnum(p, j, ["Default", "Avatar", "Rounded"], "ImageVariant");
+var decodeImageFit = (p, j) => bareEnum(p, j, ["Natural", "Cover", "Contain"], "ImageFit");
+var decodeImageAspect = (p, j) => bareEnum(
+  p,
+  j,
+  ["Natural", "Square", "FourThree", "ThreeTwo", "SixteenNine"],
+  "ImageAspect"
+);
+var decodeImageLoading = (p, j) => bareEnum(p, j, ["Eager", "Lazy"], "ImageLoading");
 var decodeScrollOrientation = (p, j) => bareEnum(p, j, ["Vertical", "Horizontal", "Both"], "ScrollOrientation");
 var decodeDateVariant = (p, j) => bareEnum(p, j, ["Date", "Time", "DateTime"], "DateVariant");
 var decodeMathDisplay = (p, j) => bareEnum(p, j, ["Inline", "Block"], "MathDisplay");
@@ -3118,6 +3238,7 @@ var decodeWeight = (p, j) => (
   // Compact|Standard|Spacious means density (WIRE_FORMAT.md §3.6).
   bareEnum(p, j, ["Compact", "Standard", "Spacious"], "StyleWeight")
 );
+var decodeTrendPolarity = (p, j) => bareEnum(p, j, ["HigherIsBetter", "LowerIsBetter"], "TrendPolarity");
 var decodeEmphasis = (p, j) => {
   if (j.kind === "JString" && j.value in EMPHASIS_ALIASES) return ok(EMPHASIS_ALIASES[j.value]);
   if (j.kind === "JBool") return ok(j.value ? "Loud" : "Normal");
@@ -4319,29 +4440,43 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       if (!pipeJ.ok) return pipeJ;
       const liveTagAst = srcJ.value.kind === "JObject" ? srcJ.value.fields.get("$type") : void 0;
       const liveTag = liveTagAst !== void 0 && liveTagAst.kind === "JString" && (liveTagAst.value === "State" || liveTagAst.value === "Selection" || liveTagAst.value === "Query") ? liveTagAst.value : void 0;
-      const hasCarried = srcJ.value.kind === "JObject" && srcJ.value.fields.has("defaultValue");
       let source;
-      if (liveTag === void 0 || liveTag === "State" && !hasCarried) {
+      if (liveTag === void 0) {
         const src = decodeDataSource(normaliseTransformSource(srcJ.value));
         if (!src.ok) return makeError("WRONG_TYPE", `${path}.source`, src.error);
         source = { kind: "Data", source: src.value };
       } else {
         const b2 = decodeBinding(`${path}.source`, srcJ.value, decodeJVal, void 0);
         if (!b2.ok) return b2;
+        const liveBinding = (() => {
+          const raw = b2.value;
+          const declared = srcJ.value.kind === "JObject" && srcJ.value.fields.has("defaultValue");
+          return raw.kind === "State" && !declared ? { ...raw, defaultValue: void 0 } : raw;
+        })();
         if (liveTag === "State") {
-          const snap = decodeDataSource(normaliseTransformSource(srcJ.value));
-          if (!snap.ok) return makeError("WRONG_TYPE", `${path}.source`, snap.error);
-          source = {
-            kind: "Live",
-            binding: b2.value,
-            initial: snap.value
-          };
+          const carriedJ = srcJ.value.kind === "JObject" ? srcJ.value.fields.get("defaultValue") : void 0;
+          const carriesNoData = carriedJ === void 0 || carriedJ.kind === "JArray" && carriedJ.items.length === 0;
+          if (carriesNoData) {
+            source = {
+              kind: "Live",
+              binding: liveBinding,
+              initial: { kind: "Embedded", table: { schema: [], columns: [] } }
+            };
+          } else {
+            const snap = decodeDataSource(normaliseTransformSource(srcJ.value));
+            if (!snap.ok) return makeError("WRONG_TYPE", `${path}.source`, snap.error);
+            source = {
+              kind: "Live",
+              binding: liveBinding,
+              initial: snap.value
+            };
+          }
         } else {
           const dv = srcJ.value.kind === "JObject" ? srcJ.value.fields.get("defaultValue") : void 0;
           const snap = dv !== void 0 ? decodeDataSource(normaliseTransformSource(dv)) : void 0;
           source = {
             kind: "Live",
-            binding: b2.value,
+            binding: liveBinding,
             initial: snap !== void 0 && snap.ok ? snap.value : { kind: "Embedded", table: { schema: [], columns: [] } }
           };
         }
@@ -4498,8 +4633,10 @@ var decodeBindingArgs = (path, j) => {
   }
   return ok(out);
 };
-var decodeBindingString = (p, j) => decodeBinding(p, j);
-var decodeBindingBool = (p, j) => decodeBinding(p, j);
+var decodeBindingString = (p, j) => decodeBinding(p, j, requireString, "");
+var decodeBindingBool = (p, j) => decodeBinding(p, j, requireBool, false);
+var decodeBindingFloat = (p, j) => decodeBinding(p, j, requireFloat, 0);
+var decodeBindingInt = (p, j) => decodeBinding(p, j, requireInt, 0);
 var OPTIONS_PLACEHOLDER = [
   { value: OPAQUE2, label: { kind: "Literal", value: OPAQUE2 } }
 ];
@@ -4842,7 +4979,14 @@ var decodeMetricSpec = (path, j) => {
   const f = fo.value;
   const label = reqField(path, f, "label", "Metric label TextSource", decodeTextSource);
   if (!label.ok) return label;
-  const source = reqFieldAliased(path, f, "value", ["data"], "Metric value binding", decodeBinding);
+  const source = reqFieldAliased(
+    path,
+    f,
+    "value",
+    ["data"],
+    "Metric value binding",
+    decodeBindingFloat
+  );
   if (!source.ok) {
     if (source.error.message.includes("expected JSON number")) {
       return {
@@ -4863,10 +5007,12 @@ var decodeMetricSpec = (path, j) => {
   if (!weight.ok) return weight;
   const emphasis = optField(path, f, "emphasis", decodeEmphasis);
   if (!emphasis.ok) return emphasis;
-  const trend = optField(path, f, "trend", decodeBinding);
+  const trend = optField(path, f, "trend", decodeBindingFloat);
   if (!trend.ok) return trend;
   const trendFormat = optField(path, f, "trendFormat", decodeCellFormat);
   if (!trendFormat.ok) return trendFormat;
+  const trendPolarity = optField(path, f, "trendPolarity", decodeTrendPolarity);
+  if (!trendPolarity.ok) return trendPolarity;
   const icon = optField(path, f, "icon", decodeIconSource);
   if (!icon.ok) return icon;
   const subtext = optField(path, f, "subtext", decodeTextSource);
@@ -4880,6 +5026,7 @@ var decodeMetricSpec = (path, j) => {
     emphasis: emphasis.value ?? "Normal",
     ...trend.value !== void 0 ? { trend: trend.value } : {},
     ...trendFormat.value !== void 0 ? { trendFormat: trendFormat.value } : {},
+    trendPolarity: trendPolarity.value ?? "HigherIsBetter",
     ...icon.value !== void 0 ? { icon: icon.value } : {},
     ...subtext.value !== void 0 ? { subtext: subtext.value } : {}
   });
@@ -4908,7 +5055,7 @@ var decodeLabelValueRowSpec = (path, j) => {
     "value",
     ["data"],
     "row Binding<float> value",
-    decodeBinding
+    decodeBindingFloat
   );
   if (!source.ok) return source;
   const format = optField(path, f, "format", decodeCellFormat);
@@ -4997,6 +5144,23 @@ var decodeLinkSpec = (path, j) => {
   });
 };
 var decodeLinkProtection = (p, j) => bareEnum(p, j, ["email"], "LinkProtection");
+var decodeSrcSetEntry = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const src = reqField(
+    path,
+    fo.value,
+    "src",
+    "srcSet entry Binding<string> src",
+    decodeBindingString
+  );
+  if (!src.ok) return src;
+  const widthJ = tryField(fo.value, "width");
+  if (widthJ === void 0) return missingField(path, "width", "positive intrinsic pixel width");
+  if (widthJ.kind !== "JNumber" || widthJ.value <= 0 || !Number.isInteger(widthJ.value))
+    return wrongType(`${path}.width`, "JSON number (positive integer pixel width)");
+  return ok({ src: src.value, width: widthJ.value });
+};
 var decodeImageSpec = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
@@ -5007,7 +5171,90 @@ var decodeImageSpec = (path, j) => {
   if (!src.ok) return src;
   const variant = reqField(path, f, "variant", "ImageVariant", decodeImageVariant);
   if (!variant.ok) return variant;
-  return ok({ alt: alt.value, src: src.value, variant: variant.value });
+  const fitJ = tryField(f, "fit");
+  const fit = fitJ === void 0 ? ok("Natural") : decodeImageFit(`${path}.fit`, fitJ);
+  if (!fit.ok) return fit;
+  const aspectJ = tryField(f, "aspectRatio");
+  const aspectRatio = aspectJ === void 0 ? ok("Natural") : decodeImageAspect(`${path}.aspectRatio`, aspectJ);
+  if (!aspectRatio.ok) return aspectRatio;
+  const loadingJ = tryField(f, "loading");
+  const loading = loadingJ === void 0 ? ok("Eager") : decodeImageLoading(`${path}.loading`, loadingJ);
+  if (!loading.ok) return loading;
+  const caption = optField(path, f, "caption", decodeTextSource);
+  if (!caption.ok) return caption;
+  const srcSetJ = tryField(f, "srcSet");
+  const srcSet = srcSetJ === void 0 ? ok([]) : (() => {
+    const arr = requireArray(`${path}.srcSet`, srcSetJ);
+    if (!arr.ok) return arr;
+    return traverseIndexed(
+      arr.value,
+      (i, el) => decodeSrcSetEntry(`${path}.srcSet[${i}]`, el)
+    );
+  })();
+  if (!srcSet.ok) return srcSet;
+  const expandableJ = tryField(f, "expandable");
+  const expandable = expandableJ === void 0 ? ok(false) : requireBool(`${path}.expandable`, expandableJ);
+  if (!expandable.ok) return expandable;
+  return ok({
+    alt: alt.value,
+    src: src.value,
+    variant: variant.value,
+    fit: fit.value,
+    aspectRatio: aspectRatio.value,
+    loading: loading.value,
+    srcSet: srcSet.value,
+    expandable: expandable.value,
+    ...caption.value !== void 0 ? { caption: caption.value } : {}
+  });
+};
+var decodeMediaKind = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const d = requireDiscriminator(path, f);
+  if (!d.ok) return d;
+  switch (d.value) {
+    case "Video": {
+      const autoplayJ = tryField(f, "autoplay");
+      const autoplay = autoplayJ === void 0 ? ok(false) : requireBool(`${path}.autoplay`, autoplayJ);
+      if (!autoplay.ok) return autoplay;
+      const poster = optField(path, f, "poster", decodeBindingString);
+      if (!poster.ok) return poster;
+      return ok({
+        $type: "Video",
+        autoplay: autoplay.value,
+        ...poster.value !== void 0 ? { poster: poster.value } : {}
+      });
+    }
+    case "Audio":
+      return ok({ $type: "Audio" });
+    default:
+      return unknownDuCase(path, d.value, "Video | Audio");
+  }
+};
+var decodeMediaSpec = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const src = reqField(path, f, "src", "Media Binding<string> Src", decodeBindingString);
+  if (!src.ok) return src;
+  const label = reqField(path, f, "label", "Media accessible label TextSource", decodeTextSource);
+  if (!label.ok) return label;
+  const kind = reqField(path, f, "kind", "MediaKind (Video | Audio)", decodeMediaKind);
+  if (!kind.ok) return kind;
+  const controlsJ = tryField(f, "controls");
+  const controls = controlsJ === void 0 ? ok(true) : requireBool(`${path}.controls`, controlsJ);
+  if (!controls.ok) return controls;
+  const loopJ = tryField(f, "loop");
+  const loop = loopJ === void 0 ? ok(false) : requireBool(`${path}.loop`, loopJ);
+  if (!loop.ok) return loop;
+  return ok({
+    src: src.value,
+    label: label.value,
+    controls: controls.value,
+    loop: loop.value,
+    kind: kind.value
+  });
 };
 var decodeListSpec = (path, j) => {
   const fo = requireObject(path, j);
@@ -5151,7 +5398,7 @@ var decodeProgressSpec = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
   const f = fo.value;
-  const fraction = reqField(path, f, "fraction", "Progress fraction binding", decodeBinding);
+  const fraction = reqField(path, f, "fraction", "Progress fraction binding", decodeBindingFloat);
   if (!fraction.ok) return fraction;
   const indeterminate = optField(path, f, "indeterminate", requireBool);
   if (!indeterminate.ok) return indeterminate;
@@ -5201,9 +5448,9 @@ var decodeDrawStyle = (path, j) => {
   if (!fill.ok) return fill;
   const stroke = optField(path, f, "stroke", decodeBindingString);
   if (!stroke.ok) return stroke;
-  const strokeWidth = optField(path, f, "strokeWidth", decodeBinding);
+  const strokeWidth = optField(path, f, "strokeWidth", decodeBindingFloat);
   if (!strokeWidth.ok) return strokeWidth;
-  const opacity = optField(path, f, "opacity", decodeBinding);
+  const opacity = optField(path, f, "opacity", decodeBindingFloat);
   if (!opacity.ok) return opacity;
   const textAnchor = optField(path, f, "textAnchor", decodeTextAnchor);
   if (!textAnchor.ok) return textAnchor;
@@ -5482,6 +5729,10 @@ var decodeDisplayKind = (path, j) => {
       const r = decodeImageSpec(path, j);
       return r.ok ? ok({ kind: "Image", spec: r.value }) : r;
     }
+    case "Media": {
+      const r = decodeMediaSpec(path, j);
+      return r.ok ? ok({ kind: "Media", spec: r.value }) : r;
+    }
     case "List": {
       const r = decodeListSpec(path, j);
       return r.ok ? ok({ kind: "List", spec: r.value }) : r;
@@ -5533,7 +5784,11 @@ var decodeFormFieldKind = (autoBind, path, j) => {
       return v.ok ? ok({ kind: "Text", value: v.value, ...onChangeField }) : v;
     }
     case "Number": {
-      const v = valueOr(decodeBinding, schema.controlValueDefaults.number, "Number value binding");
+      const v = valueOr(
+        decodeBindingFloat,
+        schema.controlValueDefaults.number,
+        "Number value binding"
+      );
       return v.ok ? ok({ kind: "Number", value: v.value, ...onChangeField }) : v;
     }
     case "Checkbox": {
@@ -5585,7 +5840,7 @@ var decodeFormFieldKind = (autoBind, path, j) => {
     }
     case "RangedNumber": {
       const value = valueOr(
-        decodeBinding,
+        decodeBindingFloat,
         schema.controlValueDefaults.number,
         "RangedNumber value binding"
       );
@@ -5699,6 +5954,77 @@ var decodeFormFieldKind = (autoBind, path, j) => {
       return unknownDuCase(path, d.value, WRONG_FORM_FIELD_KIND_HINT);
   }
 };
+var TEXT_FORMATS = ["email", "url", "tel"];
+var COMPARE_OPS = ["eq", "neq", "lt", "lte", "gt", "gte"];
+var decodeTextFormat = (path, j) => bareEnum(path, j, TEXT_FORMATS, "TextFormat");
+var decodeCompareOp = (path, j) => bareEnum(path, j, COMPARE_OPS, "CompareOp");
+var decodeCompareRule = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const op = reqField(path, f, "op", "CompareOp", decodeCompareOp);
+  if (!op.ok) return op;
+  const against = reqField(path, f, "against", "Binding", (p, v) => decodeBinding(p, v));
+  if (!against.ok) return against;
+  return ok({ op: op.value, against: against.value });
+};
+var decodeFieldRule = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const format = optField(path, f, "format", decodeTextFormat);
+  if (!format.ok) return format;
+  const pattern = optField(path, f, "pattern", requireString);
+  if (!pattern.ok) return pattern;
+  const minLength = optField(path, f, "minLength", requireInt);
+  if (!minLength.ok) return minLength;
+  const maxLength = optField(path, f, "maxLength", requireInt);
+  if (!maxLength.ok) return maxLength;
+  const compare = optField(path, f, "compare", decodeCompareRule);
+  if (!compare.ok) return compare;
+  const message = optField(path, f, "message", decodeTextSource);
+  if (!message.ok) return message;
+  const constrains = format.value !== void 0 || pattern.value !== void 0 || minLength.value !== void 0 || maxLength.value !== void 0 || compare.value !== void 0;
+  if (!constrains)
+    return makeError(
+      "WRONG_TYPE",
+      path,
+      "a rule that constrains nothing is a defect, not a no-op \u2014 declare at least one of format / pattern / minLength / maxLength / compare, or omit 'rule' entirely",
+      "FieldRule with at least one constraint slot"
+    );
+  if (minLength.value !== void 0 && maxLength.value !== void 0 && minLength.value > maxLength.value)
+    return makeError(
+      "WRONG_TYPE",
+      path,
+      `minLength ${minLength.value} is above maxLength ${maxLength.value} \u2014 an inverted length bound admits no value at all, so the field could never be submitted`,
+      "minLength <= maxLength"
+    );
+  return ok({
+    ...format.value !== void 0 ? { format: format.value } : {},
+    ...pattern.value !== void 0 ? { pattern: pattern.value } : {},
+    ...minLength.value !== void 0 ? { minLength: minLength.value } : {},
+    ...maxLength.value !== void 0 ? { maxLength: maxLength.value } : {},
+    ...compare.value !== void 0 ? { compare: compare.value } : {},
+    ...message.value !== void 0 ? { message: message.value } : {}
+  });
+};
+var FORM_FIELD_NEAR_MISSES = [
+  ["validation", "rule"],
+  ["constraints", "rule"],
+  ["validate", "rule"]
+];
+var checkFormFieldNearMisses = (path, f) => {
+  for (const [name, canonical] of FORM_FIELD_NEAR_MISSES) {
+    if (tryField(f, name) !== void 0)
+      return makeError(
+        "WRONG_TYPE",
+        `${path}.${name}`,
+        `'${name}' is not part of the form vocabulary \u2014 it would be ignored, not honoured, and the field would accept anything`,
+        canonical
+      );
+  }
+  return ok(void 0);
+};
 var decodeFormField = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
@@ -5720,12 +6046,17 @@ var decodeFormField = (path, j) => {
   if (!required.ok) return required;
   const help = optField(path, f, "help", decodeTextSource);
   if (!help.ok) return help;
+  const nm = checkFormFieldNearMisses(path, f);
+  if (!nm.ok) return nm;
+  const rule = optField(path, f, "rule", decodeFieldRule);
+  if (!rule.ok) return rule;
   return ok({
     id: id.value,
     kind: kind.value,
     label: label.value,
     required: required.value,
-    ...help.value !== void 0 ? { help: help.value } : {}
+    ...help.value !== void 0 ? { help: help.value } : {},
+    ...rule.value !== void 0 ? { rule: rule.value } : {}
   });
 };
 var decodeFormSpec = (path, j) => {
@@ -6464,10 +6795,23 @@ var decodeBoxLayout = (path, j) => {
         ...templateColumns.value !== void 0 ? { templateColumns: templateColumns.value } : {}
       });
     }
+    case "Masonry": {
+      const colsJ = tryField(f, "cols") ?? tryField(f, "columns");
+      if (colsJ === void 0) return missingField(path, "cols", "positive integer column count");
+      if (colsJ.kind !== "JNumber" || colsJ.value <= 0 || !Number.isInteger(colsJ.value))
+        return wrongType(`${path}.cols`, "JSON number (positive integer column count)");
+      const masonryGap = optField(path, f, "gap", requireInt);
+      if (!masonryGap.ok) return masonryGap;
+      return ok({
+        kind: "Masonry",
+        cols: colsJ.value,
+        ...masonryGap.value !== void 0 ? { gap: masonryGap.value } : {}
+      });
+    }
     case "Auto":
       return ok({ kind: "Auto" });
     default:
-      return unknownDuCase(path, d.value, "Flex | Grid | Auto");
+      return unknownDuCase(path, d.value, "Flex | Grid | Masonry | Auto");
   }
 };
 var decodeBoxRole = (path, j) => {
@@ -6480,7 +6824,7 @@ var decodeBoxRole = (path, j) => {
     case "Separator":
       return ok(s.value);
     default:
-      return unknownDuCase(path, s.value, "Group | Card | Dashboard | Separator");
+      return unknownEnumCase(path, s.value, "Group | Card | Dashboard | Separator");
   }
 };
 var decodeBox = (path, j) => {
@@ -6563,7 +6907,7 @@ var decodeTabsSpec = (path, j) => {
   }
   const activeTag = optField(path, f, "activeTag", decodeBindingString);
   if (!activeTag.ok) return activeTag;
-  const activeIndex = optField(path, f, "activeIndex", decodeBinding);
+  const activeIndex = optField(path, f, "activeIndex", decodeBindingInt);
   if (!activeIndex.ok) return activeIndex;
   return ok({
     children: children.value,
@@ -6580,7 +6924,7 @@ var decodeStepperSpec = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
   const f = fo.value;
-  const activeStep = reqField(path, f, "activeStep", "activeStep binding", decodeBinding);
+  const activeStep = reqField(path, f, "activeStep", "activeStep binding", decodeBindingInt);
   if (!activeStep.ok) return activeStep;
   const children = decodeChildren(path, f);
   if (!children.ok) return children;
@@ -6745,7 +7089,7 @@ var decodeContentHash = (path, j) => {
   if (!strictnessR.ok) return strictnessR;
   const s = strictnessR.value;
   if (s !== "StrictReplay" && s !== "AdvisoryWarning" && s !== "Enforced") {
-    return unknownDuCase(`${path}.strictness`, s, "StrictReplay | AdvisoryWarning | Enforced");
+    return unknownEnumCase(`${path}.strictness`, s, "StrictReplay | AdvisoryWarning | Enforced");
   }
   return ok({ algorithm: algorithm.value, hash: hash.value, strictness: s });
 };
@@ -6876,11 +7220,11 @@ var decodeEffectClass = (path, j) => {
   const host = reqField(path, fo.value, "hostEffect", "EffectClass hostEffect", requireString);
   if (!host.ok) return host;
   if (host.value !== "Pure" && host.value !== "ReadsHost" && host.value !== "WritesHost")
-    return unknownDuCase(`${path}.hostEffect`, host.value, "Pure | ReadsHost | WritesHost");
+    return unknownEnumCase(`${path}.hostEffect`, host.value, "Pure | ReadsHost | WritesHost");
   const det = reqField(path, fo.value, "determinism", "EffectClass determinism", requireString);
   if (!det.ok) return det;
   if (det.value !== "Deterministic" && det.value !== "Clock" && det.value !== "Random" && det.value !== "Network")
-    return unknownDuCase(
+    return unknownEnumCase(
       `${path}.determinism`,
       det.value,
       "Deterministic | Clock | Random | Network"
@@ -6900,6 +7244,14 @@ var decodeNodeKind = (path, j) => {
   const f = fo.value;
   const d = requireDiscriminator(path, f);
   if (!d.ok) return d;
+  if (schema.narrows(walkPolicy) && schema.NODE_KIND_NAMES.includes(d.value) && !schema.admits(walkPolicy, d.value)) {
+    return makeError(
+      "KIND_NOT_ADMITTED",
+      `${path}.$type`,
+      `node kind '${d.value}' is not admitted by decode policy '${walkPolicy.identity}'`,
+      schema.policyHint(walkPolicy)
+    );
+  }
   switch (d.value) {
     // The four behavioural categories are flat on the wire (WIRE_FORMAT §3.2):
     // the `kind` object carries the primitive discriminator directly, so route
@@ -6929,6 +7281,7 @@ var decodeNodeKind = (path, j) => {
     case "Fact":
     case "Link":
     case "Image":
+    case "Media":
     case "List":
     case "Toast":
     case "CodeBlock":
@@ -7204,10 +7557,54 @@ var decodeSemanticStyle = (path, j) => {
     voice: voice.value ?? "Default"
   });
 };
+var A11Y_NEAR_MISSES = [
+  [
+    "aria-label",
+    "label \u2014 the accessible name, a Binding<string> (a bare string is the \xA73.6 shorthand)"
+  ],
+  [
+    "ariaLabel",
+    "label \u2014 the accessible name, a Binding<string> (a bare string is the \xA73.6 shorthand)"
+  ],
+  ["aria-labelledby", "labelledBy \u2014 the id of a sibling node whose text carries the name"],
+  ["ariaLabelledBy", "labelledBy \u2014 the id of a sibling node whose text carries the name"],
+  [
+    "labelledby",
+    "labelledBy \u2014 the slot name is camelCase on the wire, not the ARIA attribute spelling"
+  ],
+  ["aria-describedby", "describedBy \u2014 the id of a sibling node whose text carries the description"],
+  ["ariaDescribedBy", "describedBy \u2014 the id of a sibling node whose text carries the description"],
+  [
+    "describedby",
+    "describedBy \u2014 the slot name is camelCase on the wire, not the ARIA attribute spelling"
+  ],
+  ["aria-role", "role \u2014 the ARIA role NAME as a bare string"],
+  ["ariaRole", "role \u2014 the ARIA role NAME as a bare string"],
+  ["aria-live", 'liveRegion \u2014 the closed token set "polite" / "assertive" / "off"'],
+  ["ariaLive", 'liveRegion \u2014 the closed token set "polite" / "assertive" / "off"'],
+  ["live", 'liveRegion \u2014 the closed token set "polite" / "assertive" / "off"'],
+  ["liveregion", 'liveRegion \u2014 the closed token set "polite" / "assertive" / "off"'],
+  ["aria-hidden", "hidden \u2014 a Binding<bool> (a bare bool is the \xA73.6 shorthand)"],
+  ["ariaHidden", "hidden \u2014 a Binding<bool> (a bare bool is the \xA73.6 shorthand)"]
+];
+var checkA11yNearMisses = (path, f) => {
+  for (const [name, canonical] of A11Y_NEAR_MISSES) {
+    if (tryField(f, name) !== void 0)
+      return makeError(
+        "WRONG_TYPE",
+        `${path}.${name}`,
+        `'${name}' is not part of the accessibility vocabulary \u2014 it would be ignored, not honoured, and the intent would reach assistive technology as nothing at all`,
+        canonical
+      );
+  }
+  return ok(void 0);
+};
 var decodeAccessibility = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
   const f = fo.value;
+  const nearMiss2 = checkA11yNearMisses(path, f);
+  if (!nearMiss2.ok) return nearMiss2;
   const label = optField(path, f, "label", decodeBindingString);
   if (!label.ok) return label;
   const labelledBy = optField(path, f, "labelledBy", requireString);
@@ -7252,7 +7649,39 @@ var placeholderClosureNode = {
     voice: "Default"
   }
 };
+var walkDepth = 0;
+var walkNodes = 0;
+var opDepth = 0;
+var walkPolicy = schema.admitAll;
+var resetWalk = (policy = schema.admitAll) => {
+  walkDepth = 0;
+  walkNodes = 0;
+  opDepth = 0;
+  walkPolicy = policy;
+};
+var limitError = (path, message, expected) => makeError("LIMIT_EXCEEDED", path, message, expected);
 var decodeNodeAst = (path, j) => {
+  if (walkDepth >= schema.MAX_NODE_DEPTH) {
+    return limitError(
+      path,
+      `node nesting deeper than the wire limit MAX_NODE_DEPTH = ${schema.MAX_NODE_DEPTH}`,
+      `a tree nesting nodes no more than ${schema.MAX_NODE_DEPTH} levels deep`
+    );
+  }
+  walkNodes += 1;
+  if (walkNodes > schema.MAX_NODES) {
+    return limitError(
+      path,
+      `the document holds more than the wire limit MAX_NODES = ${schema.MAX_NODES} nodes`,
+      `a tree of no more than ${schema.MAX_NODES} nodes in total`
+    );
+  }
+  walkDepth += 1;
+  const r = decodeNodeAstInner(path, j);
+  walkDepth -= 1;
+  return r;
+};
+var decodeNodeAstInner = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
   const f = fo.value;
@@ -7280,6 +7709,25 @@ var decodeNodeAst = (path, j) => {
   });
 };
 var decodeTreeOpAst = (path, j) => {
+  if (opDepth >= schema.MAX_NODE_DEPTH) {
+    return limitError(
+      path,
+      `op nesting deeper than the wire limit MAX_NODE_DEPTH = ${schema.MAX_NODE_DEPTH}`,
+      `a Batch nesting ops no more than ${schema.MAX_NODE_DEPTH} levels deep`
+    );
+  }
+  opDepth += 1;
+  const r = decodeTreeOpAstInner(path, j);
+  opDepth -= 1;
+  return r;
+};
+var retiredPositionalField = (path, f, name, opKind) => tryField(f, name) !== void 0 ? makeError(
+  "WRONG_TYPE",
+  `${path}.${name}`,
+  `'${name}' was removed from the wire format \u2014 ${opKind} appends, and order is stated by naming ids with ReorderChildren`,
+  "a Batch of the structural op followed by ReorderChildren"
+) : ok(void 0);
+var decodeTreeOpAstInner = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
   const f = fo.value;
@@ -7332,6 +7780,8 @@ var decodeTreeOpAst = (path, j) => {
       return state.ok ? ok({ kind: "UpdateState", target: t.value, state: state.value }) : state;
     }
     case "InsertChild": {
+      const retired = retiredPositionalField(path, f, "position", "InsertChild");
+      if (!retired.ok) return retired;
       const parentJ = reqField(path, f, "parentId", "parent NodeId", requireString);
       if (!parentJ.ok) return parentJ;
       const child = reqField(path, f, "child", "child Node object", decodeNodeAst);
@@ -7346,6 +7796,8 @@ var decodeTreeOpAst = (path, j) => {
       return t.ok ? ok({ kind: "RemoveNode", target: t.value }) : t;
     }
     case "MoveNode": {
+      const retired = retiredPositionalField(path, f, "newPosition", "MoveNode");
+      if (!retired.ok) return retired;
       const t = target();
       if (!t.ok) return t;
       const newParent = reqField(path, f, "newParentId", "new parent NodeId", requireString);
@@ -7427,6 +7879,8 @@ var coerce = {
   tone: (v) => viaAst(v, decodeTone),
   weight: (v) => viaAst(v, decodeWeight),
   emphasis: (v) => viaAst(v, decodeEmphasis),
+  /** `Metric.TrendPolarity` (Phase 867) - the UpdateProp twin of `decodeTrendPolarity`. */
+  trendPolarity: (v) => viaAst(v, decodeTrendPolarity),
   /**
    * The behavioural `emphasis` BOOL on Fact / LabelValueRow — the UpdateProp
    * twin of `decodeEmphasisFlag`, so a TreeOp edit gets the same
@@ -7447,13 +7901,18 @@ var invalidJson = (parseMessage) => makeError(
   `input is not valid JSON: ${parseMessage}`,
   "well-formed JSON object per the canonical-JSON shape"
 );
-var decodeNode = (json) => {
+var parseFailure = (e) => e.limit === true ? makeError("LIMIT_EXCEEDED", "$", e.message, "a document within the WIRE_FORMAT \xA721 limits") : invalidJson(e.message);
+var decodeNode = (json, policy) => {
   const parsed = parse(json);
-  return parsed.ok ? decodeNodeAst("$", parsed.value) : invalidJson(parsed.error.message);
+  if (!parsed.ok) return parseFailure(parsed.error);
+  resetWalk(policy);
+  return decodeNodeAst("$", parsed.value);
 };
-var decodeOp = (json) => {
+var decodeOp = (json, policy) => {
   const parsed = parse(json);
-  return parsed.ok ? decodeTreeOpAst("$", parsed.value) : invalidJson(parsed.error.message);
+  if (!parsed.ok) return parseFailure(parsed.error);
+  resetWalk(policy);
+  return decodeTreeOpAst("$", parsed.value);
 };
 
 // src/apply.ts
@@ -7620,6 +8079,11 @@ var updateField = (field2, value, kind) => {
               coerce.cellFormat(value),
               (x) => disp({ kind: "Metric", spec: { ...s, trendFormat: x } })
             );
+          case "TrendPolarity":
+            return patch(
+              coerce.trendPolarity(value),
+              (x) => disp({ kind: "Metric", spec: { ...s, trendPolarity: x } })
+            );
           case "Icon":
             return patch(
               coerce.iconSource(value),
@@ -7903,6 +8367,12 @@ var updateField = (field2, value, kind) => {
             (x) => lay({ kind: "Box", spec: { ...s, layout: { ...mode, cols: x } } })
           );
         }
+        if (field2 === "Cols" && mode.kind === "Masonry") {
+          return patch(
+            coerce.int(value),
+            (x) => lay({ kind: "Box", spec: { ...s, layout: { ...mode, cols: x } } })
+          );
+        }
         if (field2 === "TemplateColumns" && mode.kind === "Grid") {
           return patch(
             coerce.string(value),
@@ -9767,9 +10237,64 @@ var validateAnswerDocument = (json) => {
   if (!answer.ok) return answer;
   return validateAnswerAt("$.answer", contract.value, answer.value);
 };
+var HOST_RESERVED_PREFIX = "host.";
+var isHostReserved = (key) => typeof key === "string" && key.startsWith(HOST_RESERVED_PREFIX);
+var isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var isStateDeclaration = (v) => isPlainObject(v) && v["kind"] === "State" && typeof v["key"] === "string" && "defaultValue" in v && v["defaultValue"] !== void 0;
+var controlDefaults = Object.values(schema.controlValueDefaults);
+var deepEqual = (a, b) => {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+};
+var isAutoBoundFieldValue = (binding2, fieldId) => binding2.key === fieldId && controlDefaults.some((d) => deepEqual(d, binding2.defaultValue));
+var isEmptyDeclaration = (value) => {
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainObject(value)) {
+    const columns = value["columns"];
+    if (isPlainObject(columns)) return Object.keys(columns).length === 0;
+  }
+  return false;
+};
+var collectStateSeeds = (tree) => {
+  const seeds = {};
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value, autoBindFieldId) => {
+    if (value === null || typeof value !== "object") return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, autoBindFieldId);
+      return;
+    }
+    const obj = value;
+    if (isStateDeclaration(obj)) {
+      const key = obj.key;
+      const shouldSkip = isHostReserved(key) || Object.prototype.hasOwnProperty.call(seeds, key) || isEmptyDeclaration(obj.defaultValue) || autoBindFieldId !== void 0 && isAutoBoundFieldValue(obj, autoBindFieldId);
+      if (!shouldSkip) seeds[key] = obj.defaultValue;
+    }
+    const record = obj;
+    const ownId = record["id"];
+    const fieldId = typeof ownId === "string" && typeof record["required"] === "boolean" ? ownId : void 0;
+    for (const [k, v] of Object.entries(obj)) {
+      const established = k === "kind" && fieldId !== void 0 ? fieldId : void 0;
+      visit(v, established ?? autoBindFieldId);
+    }
+  };
+  visit(tree, void 0);
+  return seeds;
+};
+var withStateSeeds = (tree, sources) => {
+  const seeds = collectStateSeeds(tree);
+  if (Object.keys(seeds).length === 0) return sources;
+  return { ...sources, state: { ...seeds, ...sources.state ?? {} } };
+};
 
 exports.ELICITATION_KEY = ELICITATION_KEY;
 exports.ELICITATION_VERSION = ELICITATION_VERSION;
+exports.HOST_RESERVED_PREFIX = HOST_RESERVED_PREFIX;
 exports.PAYLOAD_KEY = PAYLOAD_KEY;
 exports.PROFILE_KEY = PROFILE_KEY;
 exports.REQUIRED_PROFILE_KEY = REQUIRED_PROFILE_KEY;
@@ -9777,6 +10302,7 @@ exports.apply = apply;
 exports.canPlace = canPlace;
 exports.cellString = cellString;
 exports.coerce = coerce;
+exports.collectStateSeeds = collectStateSeeds;
 exports.coreV1 = coreV1;
 exports.decodeDagRecord = decodeDagRecord;
 exports.decodeElicitation = decodeElicitation;
@@ -9828,5 +10354,6 @@ exports.tryParseProfile = tryParseProfile;
 exports.validateAnswer = validateAnswer;
 exports.validateAnswerAt = validateAnswerAt;
 exports.validateAnswerDocument = validateAnswerDocument;
+exports.withStateSeeds = withStateSeeds;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map