@fuaran-ui/ops 0.9.0 → 0.19.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { FORM_FIELD_KIND_NAMES, NODE_KIND_GROUPS, defaults, projectSelectionField, controlValueDefaults } from '@fuaran-ui/schema';
+import { FORM_FIELD_KIND_NAMES, NODE_KIND_GROUPS, defaults, controlValueDefaults, MAX_NODE_DEPTH, MAX_NODES, MAX_STRING_LENGTH, MAX_JSON_DEPTH, MAX_ARRAY_LENGTH, narrows, admitAll, NODE_KIND_NAMES, admits, policyHint, projectSelectionField } from '@fuaran-ui/schema';
 
 // src/encode.ts
 var assertNever = (x) => {
@@ -78,10 +78,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) => {
@@ -591,6 +592,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)]);
 };
@@ -608,6 +612,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);
@@ -654,11 +659,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)]
@@ -867,6 +901,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":
@@ -994,6 +1030,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)],
@@ -1002,6 +1052,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) => {
@@ -1269,6 +1320,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:
@@ -2681,8 +2737,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;
@@ -2697,6 +2751,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 }
@@ -2719,7 +2777,14 @@ var parseStringRaw = (s) => {
     advance(s);
     if (c === '"') {
       return { ok: true, value: out };
-    } else if (c === "\\") {
+    }
+    if (out.length > MAX_STRING_LENGTH) {
+      return failLimit(
+        s,
+        `string is longer than the wire limit MAX_STRING_LENGTH = ${MAX_STRING_LENGTH}`
+      );
+    }
+    if (c === "\\") {
       if (s.pos >= s.text.length) return fail(s, "unterminated escape");
       const esc = s.text[s.pos];
       advance(s);
@@ -2819,6 +2884,12 @@ var parseValue = (s) => {
   }
 };
 var parseObjectValue = (s) => {
+  if (s.depth >= MAX_JSON_DEPTH) {
+    return failLimit(
+      s,
+      `JSON nesting deeper than the wire limit MAX_JSON_DEPTH = ${MAX_JSON_DEPTH}`
+    );
+  }
   const open = expectChar(s, "{");
   if (!open.ok) return open;
   skipWs(s);
@@ -2827,15 +2898,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 > MAX_ARRAY_LENGTH) {
+      s.depth -= 1;
+      return failLimit(
+        s,
+        `object has more members than the wire limit MAX_ARRAY_LENGTH = ${MAX_ARRAY_LENGTH}`
+      );
+    }
     fields.set(keyR.value, valR.value);
     skipWs(s);
     const c = peek(s);
@@ -2843,13 +2933,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 >= MAX_JSON_DEPTH) {
+    return failLimit(
+      s,
+      `JSON nesting deeper than the wire limit MAX_JSON_DEPTH = ${MAX_JSON_DEPTH}`
+    );
+  }
   const open = expectChar(s, "[");
   if (!open.ok) return open;
   skipWs(s);
@@ -2858,24 +2956,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 > MAX_ARRAY_LENGTH) {
+      s.depth -= 1;
+      return failLimit(
+        s,
+        `array is longer than the wire limit MAX_ARRAY_LENGTH = ${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 } };
@@ -2893,6 +3004,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");
@@ -3045,7 +3157,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.
@@ -3083,6 +3195,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");
@@ -3116,6 +3236,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");
@@ -4317,29 +4438,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: [] } }
           };
         }
@@ -4496,8 +4631,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 } }
 ];
@@ -4840,7 +4977,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 {
@@ -4861,10 +5005,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);
@@ -4878,6 +5024,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 } : {}
   });
@@ -4906,7 +5053,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);
@@ -4995,6 +5142,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;
@@ -5005,7 +5169,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);
@@ -5149,7 +5396,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;
@@ -5199,9 +5446,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;
@@ -5480,6 +5727,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;
@@ -5531,7 +5782,11 @@ var decodeFormFieldKind = (autoBind, path, j) => {
       return v.ok ? ok({ kind: "Text", value: v.value, ...onChangeField }) : v;
     }
     case "Number": {
-      const v = valueOr(decodeBinding, controlValueDefaults.number, "Number value binding");
+      const v = valueOr(
+        decodeBindingFloat,
+        controlValueDefaults.number,
+        "Number value binding"
+      );
       return v.ok ? ok({ kind: "Number", value: v.value, ...onChangeField }) : v;
     }
     case "Checkbox": {
@@ -5583,7 +5838,7 @@ var decodeFormFieldKind = (autoBind, path, j) => {
     }
     case "RangedNumber": {
       const value = valueOr(
-        decodeBinding,
+        decodeBindingFloat,
         controlValueDefaults.number,
         "RangedNumber value binding"
       );
@@ -5697,6 +5952,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;
@@ -5718,12 +6044,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) => {
@@ -6462,10 +6793,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) => {
@@ -6478,7 +6822,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) => {
@@ -6561,7 +6905,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,
@@ -6578,7 +6922,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;
@@ -6743,7 +7087,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 });
 };
@@ -6874,11 +7218,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"
@@ -6898,6 +7242,14 @@ var decodeNodeKind = (path, j) => {
   const f = fo.value;
   const d = requireDiscriminator(path, f);
   if (!d.ok) return d;
+  if (narrows(walkPolicy) && NODE_KIND_NAMES.includes(d.value) && !admits(walkPolicy, d.value)) {
+    return makeError(
+      "KIND_NOT_ADMITTED",
+      `${path}.$type`,
+      `node kind '${d.value}' is not admitted by decode policy '${walkPolicy.identity}'`,
+      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
@@ -6927,6 +7279,7 @@ var decodeNodeKind = (path, j) => {
     case "Fact":
     case "Link":
     case "Image":
+    case "Media":
     case "List":
     case "Toast":
     case "CodeBlock":
@@ -7202,10 +7555,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);
@@ -7250,7 +7647,39 @@ var placeholderClosureNode = {
     voice: "Default"
   }
 };
+var walkDepth = 0;
+var walkNodes = 0;
+var opDepth = 0;
+var walkPolicy = admitAll;
+var resetWalk = (policy = 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 >= MAX_NODE_DEPTH) {
+    return limitError(
+      path,
+      `node nesting deeper than the wire limit MAX_NODE_DEPTH = ${MAX_NODE_DEPTH}`,
+      `a tree nesting nodes no more than ${MAX_NODE_DEPTH} levels deep`
+    );
+  }
+  walkNodes += 1;
+  if (walkNodes > MAX_NODES) {
+    return limitError(
+      path,
+      `the document holds more than the wire limit MAX_NODES = ${MAX_NODES} nodes`,
+      `a tree of no more than ${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;
@@ -7278,6 +7707,25 @@ var decodeNodeAst = (path, j) => {
   });
 };
 var decodeTreeOpAst = (path, j) => {
+  if (opDepth >= MAX_NODE_DEPTH) {
+    return limitError(
+      path,
+      `op nesting deeper than the wire limit MAX_NODE_DEPTH = ${MAX_NODE_DEPTH}`,
+      `a Batch nesting ops no more than ${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;
@@ -7330,6 +7778,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);
@@ -7344,6 +7794,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);
@@ -7425,6 +7877,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
@@ -7445,13 +7899,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
@@ -7618,6 +8077,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),
@@ -7901,6 +8365,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),
@@ -9765,7 +10235,61 @@ 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(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 ?? {} } };
+};
 
-export { ELICITATION_KEY, ELICITATION_VERSION, PAYLOAD_KEY, PROFILE_KEY, REQUIRED_PROFILE_KEY, apply, canPlace, cellString, coerce, coreV1, decodeDagRecord, decodeElicitation, decodeElicitationOutcome, decodeEnvelope, decodeEnvelopeAst, decodeNode, decodeNodeTolerant, decodeOp, decodeTolerant, derivedFreshIds, duplicateOp, duplicateOpWith, encodeCell, encodeColExpr, encodeDagRecord, encodeDataSource, encodeElicitation, encodeElicitationOutcome, encodeEnvelope2 as encodeEnvelope, encodeNode, encodeOp, encodePipeline, evalErrorString, evalPipeline, evalPipelineInEnv, evalPipelineWith, evalPipelineWithInEnv, evalSource, field as jsonField, liveValueToTable, merge3Way, moveOp, negotiate, negotiateEnvelope, noResolve, nudgeOp, parse, pasteOp, pasteOpWith, pipelineParams, placeOp, reencodeNode, renderAstCanonical, renderProfile, sequentialFreshIds, stepParams, tryParseProfile, validateAnswer, validateAnswerAt, validateAnswerDocument };
+export { ELICITATION_KEY, ELICITATION_VERSION, HOST_RESERVED_PREFIX, PAYLOAD_KEY, PROFILE_KEY, REQUIRED_PROFILE_KEY, apply, canPlace, cellString, coerce, collectStateSeeds, coreV1, decodeDagRecord, decodeElicitation, decodeElicitationOutcome, decodeEnvelope, decodeEnvelopeAst, decodeNode, decodeNodeTolerant, decodeOp, decodeTolerant, derivedFreshIds, duplicateOp, duplicateOpWith, encodeCell, encodeColExpr, encodeDagRecord, encodeDataSource, encodeElicitation, encodeElicitationOutcome, encodeEnvelope2 as encodeEnvelope, encodeNode, encodeOp, encodePipeline, evalErrorString, evalPipeline, evalPipelineInEnv, evalPipelineWith, evalPipelineWithInEnv, evalSource, field as jsonField, liveValueToTable, merge3Way, moveOp, negotiate, negotiateEnvelope, noResolve, nudgeOp, parse, pasteOp, pasteOpWith, pipelineParams, placeOp, reencodeNode, renderAstCanonical, renderProfile, sequentialFreshIds, stepParams, tryParseProfile, validateAnswer, validateAnswerAt, validateAnswerDocument, withStateSeeds };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map