@fuaran-ui/ops 0.9.0 → 0.21.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) => {
@@ -481,7 +482,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)],
@@ -591,6 +594,9 @@ var pushWeightOptional = (fields, w) => {
 var pushEmphasisOptional = (fields, e) => {
   if (e !== "Normal") fields.push(["emphasis", str(e)]);
 };
+var pushTrendPolarityOptional = (fields, p) => {
+  if (p !== "HigherIsBetter") fields.push(["trendPolarity", str(p)]);
+};
 var pushCellFormatOptional = (fields, key, f) => {
   if (f.kind !== "None") fields.push([key, cellFormat(f)]);
 };
@@ -608,6 +614,7 @@ var metricSpec = (s) => {
   pushEmphasisOptional(fields, s.emphasis);
   if (s.trend !== void 0) fields.push(["trend", binding(s.trend)]);
   if (s.trendFormat !== void 0) fields.push(["trendFormat", cellFormat(s.trendFormat)]);
+  pushTrendPolarityOptional(fields, s.trendPolarity);
   if (s.icon !== void 0) fields.push(["icon", str(s.icon)]);
   if (s.subtext !== void 0) fields.push(["subtext", textSource(s.subtext)]);
   return jObject(fields);
@@ -654,11 +661,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)]
@@ -867,6 +939,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":
@@ -954,6 +1032,40 @@ var formFieldKind = (autoBind, k) => {
         ["orientation", str(k.orientation)],
         ...valueField(k.value, 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, 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, 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, controlValueDefaults.number, (v) => binding(v)));
+      return caseObj("Rating", fields);
+    }
+    case "Color":
+      return caseObj("Color", [
+        ...handlerField("onChange", k.onChange),
+        ...valueField(k.value, controlValueDefaults.color, (v) => binding(v))
+      ]);
     case "TextArea":
       return caseObj("TextArea", [
         ...handlerField("onChange", k.onChange),
@@ -994,6 +1106,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 +1128,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) => {
@@ -1055,6 +1182,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) => {
@@ -1192,6 +1323,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 = [
@@ -1269,6 +1405,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:
@@ -1280,6 +1421,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([
@@ -1334,6 +1477,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) => {
@@ -1489,6 +1634,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(
@@ -1563,6 +1711,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) => {
@@ -1576,7 +1726,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)],
@@ -1585,6 +1737,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) => {
@@ -2681,8 +2834,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;
@@ -2697,6 +2907,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 +2933,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 +3040,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 +3054,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 +3089,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 +3112,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 +3160,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 +3313,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,7 +3351,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 = {
@@ -3116,6 +3402,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");
@@ -4238,12 +4525,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":
@@ -4317,29 +4603,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 +4796,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 } }
 ];
@@ -4681,7 +4983,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);
@@ -4801,9 +5103,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;
@@ -4828,7 +5140,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"
       );
   }
 };
@@ -4840,7 +5152,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 +5180,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 +5199,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 +5228,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 +5317,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 +5344,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 >= MAX_NODE_DEPTH) {
+    return limitError(
+      path,
+      `tree-item nesting deeper than the wire limit MAX_NODE_DEPTH = ${MAX_NODE_DEPTH}`,
+      `a tree nesting items no more than ${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);
@@ -5149,7 +5698,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 +5748,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 +6029,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;
@@ -5504,7 +6065,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"
       );
   }
 };
@@ -5531,7 +6092,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 +6148,7 @@ var decodeFormFieldKind = (autoBind, path, j) => {
     }
     case "RangedNumber": {
       const value = valueOr(
-        decodeBinding,
+        decodeBindingFloat,
         controlValueDefaults.number,
         "RangedNumber value binding"
       );
@@ -5631,6 +6196,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,
+        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,
+        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,
+        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,
+        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;
@@ -5697,6 +6351,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 +6443,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) => {
@@ -5851,12 +6581,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) => {
@@ -6274,6 +7023,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) {
@@ -6294,6 +7053,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 } : {}
   });
 };
@@ -6462,10 +7226,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 +7255,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) => {
@@ -6493,11 +7270,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) => {
@@ -6561,7 +7344,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 +7361,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;
@@ -6644,12 +7427,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) => {
@@ -6743,7 +7533,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 +7664,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 +7688,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 +7725,9 @@ var decodeNodeKind = (path, j) => {
     case "Fact":
     case "Link":
     case "Image":
+    case "Media":
+    case "Embed":
+    case "Tree":
     case "List":
     case "Toast":
     case "CodeBlock":
@@ -7026,9 +7827,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": {
@@ -7194,18 +8010,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);
@@ -7250,7 +8113,41 @@ var placeholderClosureNode = {
     voice: "Default"
   }
 };
+var walkDepth = 0;
+var walkNodes = 0;
+var opDepth = 0;
+var itemDepth = 0;
+var walkPolicy = admitAll;
+var resetWalk = (policy = 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 >= 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;
@@ -7269,15 +8166,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 >= 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 +8249,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 +8265,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 +8348,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 +8370,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 +8548,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 +8836,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),
@@ -8688,10 +9629,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(",")}]`;
@@ -8700,7 +9643,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) => {
@@ -8723,6 +9665,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}` };
@@ -8731,12 +9687,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" };
@@ -8772,7 +9735,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
@@ -9765,7 +10728,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, substituteListParams, tryParseProfile, validateAnswer, validateAnswerAt, validateAnswerDocument, withStateSeeds };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map