@fuaran-ui/ops 0.9.0 → 0.21.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) => {
@@ -483,7 +484,9 @@ var action = (a) => {
     case "CommitLocal":
       return caseObj("CommitLocal", [["nodeId", str(a.nodeId)]]);
     case "WriteToClipboard":
-      return caseObj("WriteToClipboard", [["text", str(a.text)]]);
+      return caseObj("WriteToClipboard", [["text", textSource(a.text)]]);
+    case "Print":
+      return caseObj("Print", []);
     case "ReadFileBody":
       return caseObj("ReadFileBody", [
         ["encoding", str(a.encoding)],
@@ -593,6 +596,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 +616,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 +663,76 @@ 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)]);
+  if (s.tracks.length > 0) fields.push(["tracks", jArray(s.tracks.map(trackEntry))]);
+  if (s.transcript !== void 0) fields.push(["transcript", textSource(s.transcript)]);
+  return jObject(fields);
+};
+var trackEntry = (t) => {
+  const fields = [];
+  if (t.default) fields.push(["default", bool(true)]);
+  fields.push(["kind", str(t.kind)]);
+  fields.push(["label", textSource(t.label)]);
+  fields.push(["src", binding(t.src)]);
+  fields.push(["srcLang", str(t.srcLang)]);
+  return jObject(fields);
+};
+var treeSpec = (s) => {
+  const fields = [["items", jArray(s.items.map(treeItem))]];
+  if (s.expandedStateKey !== void 0) fields.push(["expandedStateKey", str(s.expandedStateKey)]);
+  if (s.onSelect !== void 0) fields.push(["onSelect", CLOSURE]);
+  if (s.selectionStateKey !== void 0)
+    fields.push(["selectionStateKey", str(s.selectionStateKey)]);
+  return jObject(fields);
+};
+var treeItem = (t) => {
+  const fields = [];
+  if (t.children.length > 0) fields.push(["children", jArray(t.children.map(treeItem))]);
+  if (t.icon !== void 0) fields.push(["icon", str(t.icon)]);
+  fields.push(["id", str(t.id)]);
+  fields.push(["label", textSource(t.label)]);
+  return jObject(fields);
+};
+var embedSpec = (s) => {
+  const fields = [];
+  if (s.aspectRatio !== "Natural") fields.push(["aspectRatio", str(s.aspectRatio)]);
+  if (s.permissions.length > 0)
+    fields.push(["permissions", jArray(s.permissions.map((p) => str(p)))]);
+  fields.push(["src", binding(s.src)]);
+  fields.push(["title", textSource(s.title)]);
+  return jObject(fields);
+};
 var listSpec = (s) => jObject([
   ["items", jArray(s.items.map(textSource))],
   ["ordered", bool(s.ordered)]
@@ -869,6 +941,12 @@ 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 "Tree":
+      return hoistSpec("Tree", treeSpec(d.spec));
+    case "Embed":
+      return hoistSpec("Embed", embedSpec(d.spec));
     case "List":
       return hoistSpec("List", listSpec(d.spec));
     case "Toast":
@@ -956,6 +1034,40 @@ var formFieldKind = (autoBind, k) => {
         ["orientation", str(k.orientation)],
         ...valueField(k.value, schema.controlValueDefaults.choice, (v) => binding(v, staticStringOpt))
       ]);
+    case "Combobox": {
+      const fields = [];
+      if (k.allowFreeText) fields.push(["allowFreeText", bool(true)]);
+      fields.push(...handlerField("onChange", k.onChange));
+      fields.push(["options", binding(k.options, staticSelectOptions)]);
+      fields.push(
+        ...valueField(k.value, schema.controlValueDefaults.choice, (v) => binding(v, staticStringOpt))
+      );
+      return caseObj("Combobox", fields);
+    }
+    case "Tokens": {
+      const fields = [];
+      if (!k.allowFreeText) fields.push(["allowFreeText", bool(false)]);
+      fields.push(...handlerField("onChange", k.onChange));
+      if (k.suggestions !== void 0)
+        fields.push(["suggestions", binding(k.suggestions, staticSelectOptions)]);
+      fields.push(
+        ...valueField(k.value, schema.controlValueDefaults.tokens, (v) => binding(v, staticStringList))
+      );
+      return caseObj("Tokens", fields);
+    }
+    case "Rating": {
+      const fields = [];
+      if (k.allowHalf) fields.push(["allowHalf", bool(true)]);
+      fields.push(["max", num(k.max)]);
+      fields.push(...handlerField("onChange", k.onChange));
+      fields.push(...valueField(k.value, schema.controlValueDefaults.number, (v) => binding(v)));
+      return caseObj("Rating", fields);
+    }
+    case "Color":
+      return caseObj("Color", [
+        ...handlerField("onChange", k.onChange),
+        ...valueField(k.value, schema.controlValueDefaults.color, (v) => binding(v))
+      ]);
     case "TextArea":
       return caseObj("TextArea", [
         ...handlerField("onChange", k.onChange),
@@ -996,6 +1108,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 +1130,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) => {
@@ -1057,6 +1184,10 @@ var fileUploadSpec = (s) => {
     ["onSelect", CLOSURE]
   ];
   if (s.disabled !== void 0) fields.push(["disabled", binding(s.disabled)]);
+  if (s.acceptPaste) fields.push(["acceptPaste", bool(true)]);
+  if (s.dropTarget) fields.push(["dropTarget", bool(true)]);
+  if (s.capture !== void 0) fields.push(["capture", str(s.capture)]);
+  if (s.destination !== void 0) fields.push(["destination", str(s.destination)]);
   return jObject(fields);
 };
 var inputKind = (i) => {
@@ -1194,6 +1325,11 @@ var gridSpec = (s) => {
   if (s.pageStateKey !== void 0) fields.push(["pageStateKey", str(s.pageStateKey)]);
   if (s.defaultSort !== void 0) fields.push(["defaultSort", defaultSortJson(s.defaultSort)]);
   if (s.editStateKey !== void 0) fields.push(["editStateKey", str(s.editStateKey)]);
+  if (s.transferOutKey !== void 0) fields.push(["transferOutKey", str(s.transferOutKey)]);
+  if (s.transferInKey !== void 0) fields.push(["transferInKey", str(s.transferInKey)]);
+  if (s.exportable) fields.push(["exportable", bool(true)]);
+  if (s.keepRowsTogether) fields.push(["keepRowsTogether", bool(true)]);
+  if (s.repeatHeader) fields.push(["repeatHeader", bool(true)]);
   if (s.staticRows !== void 0) {
     const sr = s.staticRows;
     const srFields = [
@@ -1271,6 +1407,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:
@@ -1282,6 +1423,8 @@ var boxSpec = (s) => {
   if (s.heading !== void 0) fields.push(["heading", textSource(s.heading)]);
   fields.push(["layout", boxLayout(s.layout)]);
   fields.push(["role", str(s.role)]);
+  if (s.keepTogether) fields.push(["keepTogether", bool(true)]);
+  if (s.breakBefore) fields.push(["breakBefore", bool(true)]);
   return jObject(fields);
 };
 var splitPanelSpec = (s) => jObject([
@@ -1336,6 +1479,8 @@ var modalSpec = (s) => {
   ];
   if (s.onDismiss !== void 0) fields.push(["onDismiss", action(s.onDismiss)]);
   if (s.heading !== void 0) fields.push(["heading", textSource(s.heading)]);
+  if (s.modality !== "Modal") fields.push(["modality", str(s.modality)]);
+  if (s.anchor !== void 0) fields.push(["anchor", str(s.anchor)]);
   return jObject(fields);
 };
 var scrollAreaSpec = (s) => {
@@ -1491,6 +1636,9 @@ var nodeKind = (k) => {
       ]);
     case "Switch":
       return caseObj("Switch", [
+        // Phase 1122 — omitted when absent, so every pre-1122 switch stays
+        // byte-identical.
+        ...k.spec.autoAdvanceMs !== void 0 ? [["autoAdvanceMs", num(k.spec.autoAdvanceMs)]] : [],
         [
           "cases",
           jArray(
@@ -1565,6 +1713,8 @@ var semanticStyle = (s) => {
   if (s.weight !== void 0 && s.weight !== "Standard") fields.push(["weight", str(s.weight)]);
   if (s.role !== void 0 && s.role !== "None") fields.push(["role", str(s.role)]);
   if (s.voice !== void 0 && s.voice !== "Default") fields.push(["voice", str(s.voice)]);
+  if (s.direction !== void 0 && s.direction !== "auto")
+    fields.push(["direction", str(s.direction)]);
   return jObject(fields);
 };
 var accessibility = (a) => {
@@ -1578,7 +1728,9 @@ var accessibility = (a) => {
   return jObject(fields);
 };
 var isEmptyState = (s) => s.onLoading === void 0 && s.onEmpty === void 0 && s.onError === void 0;
-var isDefaultStyle = (s) => (s.emphasis === void 0 || s.emphasis === "Normal") && (s.tone === void 0 || s.tone === "Default") && (s.weight === void 0 || s.weight === "Standard") && (s.role === void 0 || s.role === "None") && (s.voice === void 0 || s.voice === "Default");
+var isDefaultStyle = (s) => (s.emphasis === void 0 || s.emphasis === "Normal") && (s.tone === void 0 || s.tone === "Default") && (s.weight === void 0 || s.weight === "Standard") && (s.role === void 0 || s.role === "None") && (s.voice === void 0 || s.voice === "Default") && // Phase 1472 — `auto` is this member's identity, so a style that declares only
+// a direction is NOT all-default and the envelope must carry it.
+(s.direction === void 0 || s.direction === "auto");
 var node = (n) => {
   const fields = [
     ["id", str(n.id)],
@@ -1587,6 +1739,7 @@ var node = (n) => {
   if (!isEmptyState(n.state)) fields.push(["state", stateBehaviour(n.state)]);
   if (!isDefaultStyle(n.style)) fields.push(["style", semanticStyle(n.style)]);
   if (n.accessibility !== void 0) fields.push(["accessibility", accessibility(n.accessibility)]);
+  if (n.tooltip !== void 0) fields.push(["tooltip", textSource(n.tooltip)]);
   return jObject(fields);
 };
 var treeOp = (op) => {
@@ -2683,8 +2836,65 @@ var stepParams = (t) => {
 var pipelineParams = (pipeline) => [
   ...new Set(pipeline.flatMap((t) => stepParams(t)))
 ];
-
-// src/parse.ts
+var substituteListParamsExpr = (listEnv, e) => {
+  switch (e.kind) {
+    case "col":
+    case "lit":
+    case "param":
+      return e;
+    case "binary":
+      return {
+        kind: "binary",
+        op: e.op,
+        left: substituteListParamsExpr(listEnv, e.left),
+        right: substituteListParamsExpr(listEnv, e.right)
+      };
+    case "not":
+      return { kind: "not", expr: substituteListParamsExpr(listEnv, e.expr) };
+    case "coalesce":
+      return { kind: "coalesce", exprs: e.exprs.map((x) => substituteListParamsExpr(listEnv, x)) };
+    case "case":
+      return {
+        kind: "case",
+        cases: e.cases.map((br) => ({
+          when: substituteListParamsExpr(listEnv, br.when),
+          then: substituteListParamsExpr(listEnv, br.then)
+        })),
+        else: substituteListParamsExpr(listEnv, e.else)
+      };
+    case "cast":
+      return { kind: "cast", type: e.type, expr: substituteListParamsExpr(listEnv, e.expr) };
+    case "apply":
+      return {
+        kind: "apply",
+        fn: e.fn,
+        args: e.args.map((x) => substituteListParamsExpr(listEnv, x))
+      };
+    case "in":
+      return {
+        kind: "in",
+        expr: substituteListParamsExpr(listEnv, e.expr),
+        items: e.items.map((x) => substituteListParamsExpr(listEnv, x))
+      };
+    case "isNull":
+      return { kind: "isNull", expr: substituteListParamsExpr(listEnv, e.expr) };
+    case "inParam": {
+      const expr = substituteListParamsExpr(listEnv, e.expr);
+      const items = Object.prototype.hasOwnProperty.call(listEnv, e.param) ? listEnv[e.param] : void 0;
+      return items === void 0 ? { kind: "inParam", expr, param: e.param } : { kind: "in", expr, items: items.map((c) => ({ kind: "lit", cell: c })) };
+    }
+  }
+};
+var substituteListParams = (listEnv, pipeline) => pipeline.map((t) => {
+  switch (t.kind) {
+    case "filter":
+      return { kind: "filter", pred: substituteListParamsExpr(listEnv, t.pred) };
+    case "derive":
+      return { kind: "derive", name: t.name, expr: substituteListParamsExpr(listEnv, t.expr) };
+    default:
+      return t;
+  }
+});
 var peek = (s) => s.pos < s.text.length ? s.text[s.pos] : " ";
 var advance = (s) => {
   s.pos += 1;
@@ -2699,6 +2909,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 +2935,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 +3042,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 +3056,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 +3091,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 +3114,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 +3162,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 +3315,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,7 +3353,25 @@ 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 decodeModalityKind = (p, j) => bareEnum(p, j, ["Modal", "Popover"], "ModalityKind");
+var decodeImageAspect = (p, j) => bareEnum(
+  p,
+  j,
+  ["Natural", "Square", "FourThree", "ThreeTwo", "SixteenNine"],
+  "ImageAspect"
+);
+var decodeImageLoading = (p, j) => bareEnum(p, j, ["Eager", "Lazy"], "ImageLoading");
+var decodeEmbedPermission = (p, j) => bareEnum(
+  p,
+  j,
+  ["AllowScripts", "AllowSameOrigin", "AllowForms", "AllowFullscreen"],
+  "EmbedPermission"
+);
 var decodeScrollOrientation = (p, j) => bareEnum(p, j, ["Vertical", "Horizontal", "Both"], "ScrollOrientation");
+var decodeTrackKind = (p, j) => bareEnum(p, j, ["Subtitles", "Captions", "Descriptions", "Chapters"], "TrackKind");
+var decodeCaptureSource = (p, j) => bareEnum(p, j, ["Camera", "Microphone"], "CaptureSource");
+var decodeTextDirection = (p, j) => bareEnum(p, j, ["auto", "ltr", "rtl"], "TextDirection");
 var decodeDateVariant = (p, j) => bareEnum(p, j, ["Date", "Time", "DateTime"], "DateVariant");
 var decodeMathDisplay = (p, j) => bareEnum(p, j, ["Inline", "Block"], "MathDisplay");
 var TONE_ALIASES = {
@@ -3118,6 +3404,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");
@@ -4240,12 +4527,11 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
     case "State": {
       const key = reqField(path, f, "key", "state key string", requireString);
       if (!key.ok) return key;
-      const dv = fieldAliased(f, "defaultValue", ["initialValue", "default"]) ?? { kind: "JNull" };
-      let defaultValue = placeholder;
-      if (dv !== void 0) {
-        const parsed = parseStatic(`${path}.defaultValue`, dv);
-        if (parsed.ok) defaultValue = parsed.value;
-      }
+      const dvRaw = fieldAliased(f, "defaultValue", ["initialValue", "default"]);
+      const dv = dvRaw ?? { kind: "JNull" };
+      let defaultValue = dvRaw === void 0 ? void 0 : placeholder;
+      const parsed = parseStatic(`${path}.defaultValue`, dv);
+      if (parsed.ok) defaultValue = parsed.value;
       return ok({ kind: "State", key: key.value, defaultValue });
     }
     case "Computed":
@@ -4319,29 +4605,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 +4798,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 } }
 ];
@@ -4683,7 +4985,7 @@ var decodeAction = (path, j) => {
     const s = j.value.length > 24 ? j.value.slice(0, 24) + "\u2026" : j.value;
     return wrongType(
       path,
-      `JSON object, got the string '${s}' \u2014 an action is a $type-discriminated object (SetState | Navigate | Call | Notify | Chain | AiTool | WriteToClipboard | Invoke); "<closure>" is not authorable. Pick a real action, e.g. {"$type":"SetState","key":\u2026,"value":\u2026}`
+      `JSON object, got the string '${s}' \u2014 an action is a $type-discriminated object (SetState | Navigate | Call | Notify | Chain | AiTool | WriteToClipboard | Print | Invoke); "<closure>" is not authorable. Pick a real action, e.g. {"$type":"SetState","key":\u2026,"value":\u2026}`
     );
   }
   const fo = requireObject(path, j);
@@ -4803,9 +5105,19 @@ var decodeAction = (path, j) => {
       return r.ok ? ok({ kind: "CommitLocal", nodeId: r.value }) : r;
     }
     case "WriteToClipboard": {
-      const r = reqField(path, f, "text", "clipboard payload string", requireString);
+      const r = reqField(path, f, "text", "clipboard payload TextSource", decodeTextSource);
       return r.ok ? ok({ kind: "WriteToClipboard", text: r.value }) : r;
     }
+    case "Print": {
+      for (const key of f.keys()) {
+        if (key !== "$type")
+          return wrongType(
+            `${path}.${key}`,
+            "no member beside $type \u2014 Print takes no payload (WIRE_FORMAT.md \xA73.6.14)"
+          );
+      }
+      return ok({ kind: "Print" });
+    }
     case "ReadFileBody": {
       const fileId = reqField(path, f, "fileRef", "FileRef id string", requireString);
       if (!fileId.ok) return fileId;
@@ -4830,7 +5142,7 @@ var decodeAction = (path, j) => {
       return unknownDuCase(
         path,
         d.value,
-        "Dispatch | Call | Notify | Navigate | SetState | AiTool | Chain | CommitLocal | WriteToClipboard | ReadFileBody | Invoke"
+        "Dispatch | Call | Notify | Navigate | SetState | AiTool | Chain | CommitLocal | WriteToClipboard | Print | ReadFileBody | Invoke"
       );
   }
 };
@@ -4842,7 +5154,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 +5182,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 +5201,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 +5230,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 +5319,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 +5346,217 @@ 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;
+  const tracksJ = tryField(f, "tracks");
+  const tracks = tracksJ === void 0 ? ok([]) : (() => {
+    const arr = requireArray(`${path}.tracks`, tracksJ);
+    if (!arr.ok) return arr;
+    return traverseIndexed(
+      arr.value,
+      (i, el) => decodeTrackEntry(`${path}.tracks[${i}]`, el)
+    );
+  })();
+  if (!tracks.ok) return tracks;
+  const transcript = optField(path, f, "transcript", decodeTextSource);
+  if (!transcript.ok) return transcript;
+  return ok({
+    src: src.value,
+    label: label.value,
+    controls: controls.value,
+    loop: loop.value,
+    kind: kind.value,
+    tracks: tracks.value,
+    ...transcript.value !== void 0 ? { transcript: transcript.value } : {}
+  });
+};
+var decodeTrackEntry = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const kind = reqField(path, f, "kind", "TrackKind", decodeTrackKind);
+  if (!kind.ok) return kind;
+  const src = reqField(path, f, "src", "track Binding<string> Src", decodeBindingString);
+  if (!src.ok) return src;
+  const srcLang = reqField(path, f, "srcLang", "track srcLang string", requireString);
+  if (!srcLang.ok) return srcLang;
+  const label = reqField(path, f, "label", "track label TextSource", decodeTextSource);
+  if (!label.ok) return label;
+  const defaultJ = tryField(f, "default");
+  const dflt = defaultJ === void 0 ? ok(false) : requireBool(`${path}.default`, defaultJ);
+  if (!dflt.ok) return dflt;
+  return ok({
+    kind: kind.value,
+    src: src.value,
+    srcLang: srcLang.value,
+    label: label.value,
+    default: dflt.value
+  });
+};
+var decodeTreeSpec = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const itemsJ = requireField(path, f, "items", "Tree items list");
+  if (!itemsJ.ok) return itemsJ;
+  const arr = requireArray(`${path}.items`, itemsJ.value);
+  if (!arr.ok) return arr;
+  const items = traverseIndexed(arr.value, (i, el) => decodeTreeItem(`${path}.items[${i}]`, el));
+  if (!items.ok) return items;
+  const expandedStateKey = optField(path, f, "expandedStateKey", requireString);
+  if (!expandedStateKey.ok) return expandedStateKey;
+  const selectionStateKey = optField(path, f, "selectionStateKey", requireString);
+  if (!selectionStateKey.ok) return selectionStateKey;
+  return ok({
+    items: items.value,
+    ...expandedStateKey.value !== void 0 ? { expandedStateKey: expandedStateKey.value } : {},
+    ...selectionStateKey.value !== void 0 ? { selectionStateKey: selectionStateKey.value } : {},
+    // Emitted only when present (rule 4); the value is the closure sentinel.
+    ...tryField(f, "onSelect") !== void 0 ? { onSelect: () => placeholderAction } : {}
+  });
+};
+var decodeTreeItem = (path, j) => {
+  if (itemDepth >= schema.MAX_NODE_DEPTH) {
+    return limitError(
+      path,
+      `tree-item nesting deeper than the wire limit MAX_NODE_DEPTH = ${schema.MAX_NODE_DEPTH}`,
+      `a tree nesting items no more than ${schema.MAX_NODE_DEPTH} levels deep`
+    );
+  }
+  itemDepth += 1;
+  const r = decodeTreeItemInner(path, j);
+  itemDepth -= 1;
+  return r;
+};
+var decodeTreeItemInner = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const id = reqField(path, f, "id", "TreeItem id string", requireString);
+  if (!id.ok) return id;
+  const label = reqField(path, f, "label", "TreeItem label TextSource", decodeTextSource);
+  if (!label.ok) return label;
+  const childrenJ = tryField(f, "children");
+  const children = childrenJ === void 0 ? ok([]) : (() => {
+    const carr = requireArray(`${path}.children`, childrenJ);
+    if (!carr.ok) return carr;
+    return traverseIndexed(
+      carr.value,
+      (i, el) => decodeTreeItem(`${path}.children[${i}]`, el)
+    );
+  })();
+  if (!children.ok) return children;
+  const icon = optField(path, f, "icon", requireString);
+  if (!icon.ok) return icon;
+  return ok({
+    id: id.value,
+    label: label.value,
+    children: children.value,
+    ...icon.value !== void 0 ? { icon: icon.value } : {}
+  });
+};
+var decodeEmbedSpec = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const src = reqField(path, f, "src", "Embed Binding<string> Src", decodeBindingString);
+  if (!src.ok) return src;
+  const title = reqField(path, f, "title", "Embed accessible title TextSource", decodeTextSource);
+  if (!title.ok) return title;
+  const aspectJ = tryField(f, "aspectRatio");
+  const aspectRatio = aspectJ === void 0 ? ok("Natural") : decodeImageAspect(`${path}.aspectRatio`, aspectJ);
+  if (!aspectRatio.ok) return aspectRatio;
+  const permissionsJ = tryField(f, "permissions");
+  const permissions = permissionsJ === void 0 ? ok([]) : (() => {
+    const arr = requireArray(`${path}.permissions`, permissionsJ);
+    if (!arr.ok) return arr;
+    return traverseIndexed(
+      arr.value,
+      (i, el) => decodeEmbedPermission(`${path}.permissions[${i}]`, el)
+    );
+  })();
+  if (!permissions.ok) return permissions;
+  return ok({
+    src: src.value,
+    title: title.value,
+    aspectRatio: aspectRatio.value,
+    permissions: permissions.value
+  });
 };
 var decodeListSpec = (path, j) => {
   const fo = requireObject(path, j);
@@ -5151,7 +5700,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 +5750,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 +6031,18 @@ var decodeDisplayKind = (path, j) => {
       const r = decodeImageSpec(path, j);
       return r.ok ? ok({ kind: "Image", spec: r.value }) : r;
     }
+    case "Embed": {
+      const r = decodeEmbedSpec(path, j);
+      return r.ok ? ok({ kind: "Embed", spec: r.value }) : r;
+    }
+    case "Media": {
+      const r = decodeMediaSpec(path, j);
+      return r.ok ? ok({ kind: "Media", spec: r.value }) : r;
+    }
+    case "Tree": {
+      const r = decodeTreeSpec(path, j);
+      return r.ok ? ok({ kind: "Tree", spec: r.value }) : r;
+    }
     case "List": {
       const r = decodeListSpec(path, j);
       return r.ok ? ok({ kind: "List", spec: r.value }) : r;
@@ -5506,7 +6067,7 @@ var decodeDisplayKind = (path, j) => {
       return unknownDuCase(
         path,
         d.value,
-        "Heading | Markdown | Metric | Badge | Link | Image | List | Toast | CodeBlock | Math | Drawing | Sparkline | Callout | Progress | Skeleton | LabelValueRow"
+        "Heading | Markdown | Metric | Badge | Link | Image | Media | Embed | Tree | List | Toast | CodeBlock | Math | Drawing | Sparkline | Callout | Progress | Skeleton | LabelValueRow | Fact"
       );
   }
 };
@@ -5533,7 +6094,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 +6150,7 @@ var decodeFormFieldKind = (autoBind, path, j) => {
     }
     case "RangedNumber": {
       const value = valueOr(
-        decodeBinding,
+        decodeBindingFloat,
         schema.controlValueDefaults.number,
         "RangedNumber value binding"
       );
@@ -5633,6 +6198,95 @@ var decodeFormFieldKind = (autoBind, path, j) => {
         orientation: orientation.value
       });
     }
+    case "Combobox": {
+      const options = reqField(
+        path,
+        f,
+        "options",
+        "Combobox options binding",
+        decodeBindingSelectOptions
+      );
+      if (!options.ok) return options;
+      const allowFreeTextJ = tryField(f, "allowFreeText");
+      const allowFreeText = allowFreeTextJ === void 0 ? ok(false) : requireBool(`${path}.allowFreeText`, allowFreeTextJ);
+      if (!allowFreeText.ok) return allowFreeText;
+      const value = valueOr(
+        decodeBindingStringOpt,
+        schema.controlValueDefaults.choice,
+        "Combobox value binding"
+      );
+      if (!value.ok) return value;
+      return ok({
+        kind: "Combobox",
+        allowFreeText: allowFreeText.value,
+        options: options.value,
+        value: value.value,
+        ...onChangeField
+      });
+    }
+    case "Tokens": {
+      const allowFreeTextJ = tryField(f, "allowFreeText");
+      const allowFreeText = allowFreeTextJ === void 0 ? ok(true) : requireBool(`${path}.allowFreeText`, allowFreeTextJ);
+      if (!allowFreeText.ok) return allowFreeText;
+      const suggestions = optField(path, f, "suggestions", decodeBindingSelectOptions);
+      if (!suggestions.ok) return suggestions;
+      if (!allowFreeText.value && suggestions.value === void 0)
+        return wrongType(
+          `${path}.allowFreeText`,
+          "a suggestion source alongside allowFreeText:false \u2014 a closed token field with nothing to pick from admits no token at all (WIRE_FORMAT.md \xA73.6.19)"
+        );
+      const value = valueOr(
+        decodeBindingStringList,
+        schema.controlValueDefaults.tokens,
+        "Tokens Binding<string list> value"
+      );
+      if (!value.ok) return value;
+      return ok({
+        kind: "Tokens",
+        allowFreeText: allowFreeText.value,
+        value: value.value,
+        ...suggestions.value !== void 0 ? { suggestions: suggestions.value } : {},
+        ...onChangeField
+      });
+    }
+    case "Rating": {
+      const maxJ = requireField(path, f, "max", "Rating max integer of 1 or more");
+      if (!maxJ.ok) return maxJ;
+      if (maxJ.value.kind !== "JNumber" || maxJ.value.value < 1 || !Number.isInteger(maxJ.value.value))
+        return wrongType(`${path}.max`, "JSON number (an integer scale of 1 or more)");
+      const max = maxJ.value.value;
+      const allowHalfJ = tryField(f, "allowHalf");
+      const allowHalf = allowHalfJ === void 0 ? ok(false) : requireBool(`${path}.allowHalf`, allowHalfJ);
+      if (!allowHalf.ok) return allowHalf;
+      const value = valueOr(
+        decodeBindingFloat,
+        schema.controlValueDefaults.number,
+        "Rating value binding"
+      );
+      if (!value.ok) return value;
+      return ok({
+        kind: "Rating",
+        max,
+        allowHalf: allowHalf.value,
+        value: value.value,
+        ...onChangeField
+      });
+    }
+    case "Color": {
+      const value = valueOr(
+        decodeBinding,
+        schema.controlValueDefaults.color,
+        "Color value binding"
+      );
+      if (!value.ok) return value;
+      const bound = value.value;
+      if (bound.kind === "Static" && !(typeof bound.value === "string" && /^#[0-9a-fA-F]{6}$/.test(bound.value)))
+        return wrongType(
+          `${path}.value`,
+          "a #rrggbb colour literal \u2014 six hexadecimal digits after a #, the one form a native colour input can hold (WIRE_FORMAT.md \xA73.6.17)"
+        );
+      return ok({ kind: "Color", value: value.value, ...onChangeField });
+    }
     case "TextArea": {
       const rows = reqField(path, f, "rows", "textarea row count integer", requireInt);
       if (!rows.ok) return rows;
@@ -5699,6 +6353,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 +6445,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) => {
@@ -5853,12 +6583,31 @@ var decodeFileUploadSpec = (path, j) => {
   if (!multiple.ok) return multiple;
   const disabled = optField(path, f, "disabled", decodeBindingBool);
   if (!disabled.ok) return disabled;
+  const dropTargetJ = tryField(f, "dropTarget");
+  const dropTarget = dropTargetJ === void 0 ? ok(false) : requireBool(`${path}.dropTarget`, dropTargetJ);
+  if (!dropTarget.ok) return dropTarget;
+  const acceptPasteJ = tryField(f, "acceptPaste");
+  const acceptPaste = acceptPasteJ === void 0 ? ok(false) : requireBool(`${path}.acceptPaste`, acceptPasteJ);
+  if (!acceptPaste.ok) return acceptPaste;
+  const capture = optField(path, f, "capture", decodeCaptureSource);
+  if (!capture.ok) return capture;
+  const destinationJ = tryField(f, "destination");
+  const destination = destinationJ === void 0 ? ok(void 0) : (() => {
+    const str3 = requireString(`${path}.destination`, destinationJ);
+    if (!str3.ok) return str3;
+    return str3.value === "" ? wrongType(`${path}.destination`, "a non-empty host-registered destination id") : ok(str3.value);
+  })();
+  if (!destination.ok) return destination;
   return ok({
     accept: accept.value,
     label: label.value,
     multiple: multiple.value,
     onSelect: () => placeholderAction,
-    ...disabled.value !== void 0 ? { disabled: disabled.value } : {}
+    ...disabled.value !== void 0 ? { disabled: disabled.value } : {},
+    dropTarget: dropTarget.value,
+    acceptPaste: acceptPaste.value,
+    ...capture.value !== void 0 ? { capture: capture.value } : {},
+    ...destination.value !== void 0 ? { destination: destination.value } : {}
   });
 };
 var decodeInputKind = (path, j) => {
@@ -6276,6 +7025,16 @@ var decodeGridSpec = (path, j) => {
     if (!pk.ok) return pk;
     pageStateKey = pk.value;
   }
+  const transferOutKey = optField(path, f, "transferOutKey", requireString);
+  if (!transferOutKey.ok) return transferOutKey;
+  const transferInKey = optField(path, f, "transferInKey", requireString);
+  if (!transferInKey.ok) return transferInKey;
+  const exportable = optField(path, f, "exportable", requireBool);
+  if (!exportable.ok) return exportable;
+  const keepRowsTogether = optField(path, f, "keepRowsTogether", requireBool);
+  if (!keepRowsTogether.ok) return keepRowsTogether;
+  const repeatHeader = optField(path, f, "repeatHeader", requireBool);
+  if (!repeatHeader.ok) return repeatHeader;
   const staticRowsJ = tryField(f, "staticRows");
   let staticRows;
   if (staticRowsJ !== void 0) {
@@ -6296,6 +7055,11 @@ var decodeGridSpec = (path, j) => {
     ...pageStateKey !== void 0 ? { pageStateKey } : {},
     ...defaultSort !== void 0 ? { defaultSort } : {},
     ...editStateKey !== void 0 ? { editStateKey } : {},
+    ...transferOutKey.value !== void 0 ? { transferOutKey: transferOutKey.value } : {},
+    ...transferInKey.value !== void 0 ? { transferInKey: transferInKey.value } : {},
+    exportable: exportable.value ?? false,
+    keepRowsTogether: keepRowsTogether.value ?? false,
+    repeatHeader: repeatHeader.value ?? false,
     ...staticRows !== void 0 ? { staticRows } : {}
   });
 };
@@ -6464,10 +7228,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 +7257,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) => {
@@ -6495,11 +7272,17 @@ var decodeBox = (path, j) => {
   if (!layout.ok) return layout;
   const role = reqField(path, f, "role", "role string", decodeBoxRole);
   if (!role.ok) return role;
+  const keepTogether = optField(path, f, "keepTogether", requireBool);
+  if (!keepTogether.ok) return keepTogether;
+  const breakBefore = optField(path, f, "breakBefore", requireBool);
+  if (!breakBefore.ok) return breakBefore;
   return ok({
     children: children.value,
     ...heading.value !== void 0 ? { heading: heading.value } : {},
     layout: layout.value,
-    role: role.value
+    role: role.value,
+    keepTogether: keepTogether.value ?? false,
+    breakBefore: breakBefore.value ?? false
   });
 };
 var decodeSplitPanelSpec = (path, j) => {
@@ -6563,7 +7346,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 +7363,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;
@@ -6646,12 +7429,19 @@ var decodeModalSpec = (path, j) => {
   if (!open.ok) return open;
   const heading = optFieldAliased(path, f, "heading", ["title"], decodeTextSource);
   if (!heading.ok) return heading;
+  const modalityJ = tryField(f, "modality");
+  const modality = modalityJ === void 0 ? ok("Modal") : decodeModalityKind(`${path}.modality`, modalityJ);
+  if (!modality.ok) return modality;
+  const anchor = optField(path, f, "anchor", requireString);
+  if (!anchor.ok) return anchor;
   return ok({
     children: children.value,
     dismissable: dismissable.value,
     ...onDismiss.value !== void 0 ? { onDismiss: onDismiss.value } : {},
     open: open.value,
-    ...heading.value !== void 0 ? { heading: heading.value } : {}
+    ...heading.value !== void 0 ? { heading: heading.value } : {},
+    modality: modality.value,
+    ...anchor.value !== void 0 ? { anchor: anchor.value } : {}
   });
 };
 var decodeScrollAreaSpec = (path, j) => {
@@ -6745,7 +7535,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 +7666,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 +7690,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 +7727,9 @@ var decodeNodeKind = (path, j) => {
     case "Fact":
     case "Link":
     case "Image":
+    case "Media":
+    case "Embed":
+    case "Tree":
     case "List":
     case "Toast":
     case "CodeBlock":
@@ -7028,9 +7829,24 @@ var decodeNodeKind = (path, j) => {
       if (!cases.ok) return cases;
       const def = reqField(path, f, "default", "Switch default Node", decodeNodeAst);
       if (!def.ok) return def;
+      const autoAdvanceMsJ = tryField(f, "autoAdvanceMs");
+      let autoAdvanceMs;
+      if (autoAdvanceMsJ !== void 0) {
+        if (autoAdvanceMsJ.kind !== "JNumber" || autoAdvanceMsJ.value < 1 || !Number.isInteger(autoAdvanceMsJ.value))
+          return wrongType(
+            `${path}.autoAdvanceMs`,
+            "JSON number (a positive whole number of milliseconds)"
+          );
+        autoAdvanceMs = autoAdvanceMsJ.value;
+      }
       return ok({
         kind: "Switch",
-        spec: { on: on.value, cases: cases.value, default: def.value }
+        spec: {
+          on: on.value,
+          cases: cases.value,
+          default: def.value,
+          ...autoAdvanceMs !== void 0 ? { autoAdvanceMs } : {}
+        }
       });
     }
     case "FragmentDecl": {
@@ -7196,18 +8012,65 @@ var decodeSemanticStyle = (path, j) => {
   if (!role.ok) return role;
   const voice = optField(path, f, "voice", decodeFontVoice);
   if (!voice.ok) return voice;
+  const direction = optField(path, f, "direction", decodeTextDirection);
+  if (!direction.ok) return direction;
   return ok({
     tone: tone.value ?? "Default",
     weight: weight.value ?? "Standard",
     emphasis: emphasis.value ?? "Normal",
     role: role.value ?? "None",
-    voice: voice.value ?? "Default"
+    voice: voice.value ?? "Default",
+    direction: direction.value ?? "auto"
   });
 };
+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 +8115,41 @@ var placeholderClosureNode = {
     voice: "Default"
   }
 };
+var walkDepth = 0;
+var walkNodes = 0;
+var opDepth = 0;
+var itemDepth = 0;
+var walkPolicy = schema.admitAll;
+var resetWalk = (policy = schema.admitAll) => {
+  walkDepth = 0;
+  walkNodes = 0;
+  opDepth = 0;
+  itemDepth = 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;
@@ -7271,15 +8168,37 @@ var decodeNodeAst = (path, j) => {
   if (!style.ok) return style;
   const accessibility2 = optField(path, f, "accessibility", decodeAccessibility);
   if (!accessibility2.ok) return accessibility2;
+  const tooltip = optField(path, f, "tooltip", decodeTextSource);
+  if (!tooltip.ok) return tooltip;
   return ok({
     id: idStr.value,
     kind: kind.value,
     state: state.value,
     style: style.value,
-    ...accessibility2.value !== void 0 ? { accessibility: accessibility2.value } : {}
+    ...accessibility2.value !== void 0 ? { accessibility: accessibility2.value } : {},
+    ...tooltip.value !== void 0 ? { tooltip: tooltip.value } : {}
   });
 };
 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 +8251,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 +8267,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 +8350,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 +8372,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 +8550,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 +8838,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),
@@ -8690,10 +9631,12 @@ var str2 = (s) => {
   }
   return out + '"';
 };
+var encodeActorValue = (a) => a.kind === "human" ? `{"kind":"human","id":${str2(a.id)}}` : `{"kind":"agent","model":${str2(a.model)},"version":${str2(a.version)},"id":${str2(a.id)}}`;
 var encodeEnvelope = (e) => e.$type === "Success" ? '{"$type":"Success"}' : `{"$type":"Failure","code":${str2(e.code)},"message":${str2(e.message)}}`;
 var encodeDagRecord = (record) => {
   let out = "{";
-  out += `"hash":${str2(record.hash)}`;
+  out += `"actor":${encodeActorValue(record.actor)}`;
+  out += `,"hash":${str2(record.hash)}`;
   out += `,"op":${encodeOp(record.op)}`;
   if (record.outcomeHash !== void 0) out += `,"outcomeHash":${str2(record.outcomeHash)}`;
   out += `,"parents":[${record.parents.map(str2).join(",")}]`;
@@ -8702,7 +9645,6 @@ var encodeDagRecord = (record) => {
   out += `,"streamId":${str2(record.streamId)}`;
   out += `,"timestamp":${record.timestamp}`;
   out += `,"tombstoned":${record.tombstoned ? "true" : "false"}`;
-  out += `,"userId":${str2(record.userId)}`;
   return out + "}";
 };
 var astToJson = (ast) => {
@@ -8725,6 +9667,20 @@ var astToJson = (ast) => {
   }
 };
 var asString = (ast) => ast !== void 0 && ast.kind === "JString" ? ast.value : void 0;
+var decodeActor = (ast) => {
+  if (ast === void 0 || ast.kind !== "JObject") return void 0;
+  const kind = asString(field(ast.fields, "kind"));
+  const id = asString(field(ast.fields, "id"));
+  if (id === void 0) return void 0;
+  if (kind === "human") return { kind: "human", id };
+  if (kind === "agent") {
+    const model = asString(field(ast.fields, "model"));
+    const version = asString(field(ast.fields, "version"));
+    if (model === void 0 || version === void 0) return void 0;
+    return { kind: "agent", model, version, id };
+  }
+  return void 0;
+};
 var decodeDagRecord = (json) => {
   const parsed = parse(json);
   if (!parsed.ok) return { ok: false, error: `dag envelope parse: ${parsed.error.message}` };
@@ -8733,12 +9689,19 @@ var decodeDagRecord = (json) => {
   const f = root.fields;
   const hash = asString(field(f, "hash"));
   const streamId = asString(field(f, "streamId"));
-  const userId = asString(field(f, "userId"));
+  const actorAst = field(f, "actor");
   const opAst = field(f, "op");
   const parentsAst = field(f, "parents");
   const tsAst = field(f, "timestamp");
-  if (hash === void 0 || streamId === void 0 || userId === void 0)
-    return { ok: false, error: "dag envelope: missing hash/streamId/userId" };
+  if (actorAst === void 0 && field(f, "userId") !== void 0)
+    return {
+      ok: false,
+      error: "dag envelope: pre-1144 record \u2014 'userId' was replaced by the typed 'actor', and DAG content addresses do not carry forward"
+    };
+  if (hash === void 0 || streamId === void 0)
+    return { ok: false, error: "dag envelope: missing hash/streamId" };
+  const actor = decodeActor(actorAst);
+  if (actor === void 0) return { ok: false, error: "dag envelope: missing/malformed 'actor'" };
   if (opAst === void 0) return { ok: false, error: "dag envelope: missing op" };
   if (parentsAst === void 0 || parentsAst.kind !== "JArray")
     return { ok: false, error: "dag envelope: missing/!array parents" };
@@ -8774,7 +9737,7 @@ var decodeDagRecord = (json) => {
     op: opResult.value,
     ...outcomeHash !== void 0 ? { outcomeHash } : {},
     ...promptId !== void 0 ? { promptId } : {},
-    userId,
+    actor,
     timestamp: tsAst.value,
     resultEnvelope,
     tombstoned: tombAst !== void 0 && tombAst.kind === "JBool" && tombAst.value
@@ -9767,9 +10730,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 +10795,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;
@@ -9824,9 +10843,11 @@ exports.renderAstCanonical = renderAstCanonical;
 exports.renderProfile = renderProfile;
 exports.sequentialFreshIds = sequentialFreshIds;
 exports.stepParams = stepParams;
+exports.substituteListParams = substituteListParams;
 exports.tryParseProfile = tryParseProfile;
 exports.validateAnswer = validateAnswer;
 exports.validateAnswerAt = validateAnswerAt;
 exports.validateAnswerDocument = validateAnswerDocument;
+exports.withStateSeeds = withStateSeeds;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map