@fuaran-ui/ops 0.19.0 → 0.22.0

package/dist/index.js

@@ -1,4 +1,4 @@
-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';
+import { FORM_FIELD_KIND_NAMES, NODE_KIND_GROUPS, defaults, controlValueDefaults, MAX_DOCUMENT_BYTES, MAX_NODE_DEPTH, MAX_NODES, MAX_JSON_DEPTH, MAX_ARRAY_LENGTH, MAX_STRING_LENGTH, narrows, admitAll, NODE_KIND_NAMES, admits, policyHint, MAX_EXPR_NODES, projectSelectionField } from '@fuaran-ui/schema';
 
 // src/encode.ts
 var assertNever = (x) => {
@@ -384,9 +384,12 @@ var binding = (b, staticEnc = objValue) => {
     }
     case "Computed":
       return caseObj("Computed", [["fn", CLOSURE]]);
-    // No wire fields: the instant is host-furnished at resolve time.
+    // Phase 765 — the INSTANT is never on the wire: it is host-furnished at
+    // resolve time. Phase 1533 — the declared GRAIN is, and only when it is not
+    // the `Second` default, so a grain-less `Now` is the same bytes it has
+    // always been.
     case "Now":
-      return caseObj("Now", []);
+      return caseObj("Now", b.grain !== void 0 ? [["grain", str(b.grain)]] : []);
     case "I18n": {
       const fields = [];
       if (b.args !== void 0) {
@@ -398,14 +401,18 @@ var binding = (b, staticEnc = objValue) => {
       fields.push(["key", str(b.key)]);
       return caseObj("I18n", fields);
     }
-    case "Local":
-      return caseObj("Local", [
+    case "Local": {
+      const localFields = [
         ["flushOn", flushTrigger(b.local.flushOn)],
         ["format", CLOSURE],
         ["initialFrom", binding(b.local.initialFrom, staticEnc)],
-        ["onCommit", CLOSURE],
         ["parse", CLOSURE]
-      ]);
+      ];
+      if (b.local.codec !== void 0) localFields.push(["codec", formatIntent(b.local.codec)]);
+      if (b.local.commitTo !== void 0) localFields.push(["commitTo", str(b.local.commitTo)]);
+      if (b.local.onCommit !== void 0) localFields.push(["onCommit", CLOSURE]);
+      return caseObj("Local", localFields);
+    }
     case "Format":
       return caseObj("Format", [
         ["format", formatIntent(b.format)],
@@ -435,6 +442,22 @@ var binding = (b, staticEnc = objValue) => {
         ]
       ]);
     }
+    case "Expr": {
+      const exprParams = b.params !== void 0 && b.params.length > 0 ? [
+        [
+          "params",
+          jArray(
+            b.params.map(
+              (p) => jObject([
+                ["from", binding(p.from)],
+                ["name", str(p.name)]
+              ])
+            )
+          )
+        ]
+      ] : [];
+      return caseObj("Expr", [["expr", colExpr(b.expr)], ...exprParams]);
+    }
     case "Invoke":
       return caseObj("Invoke", [
         ["args", invokeArgs(b.args)],
@@ -464,8 +487,11 @@ var action = (a) => {
         ["channel", str(a.channel)],
         ["payload", jsonValue(a.payload)]
       ]);
-    case "Navigate":
-      return caseObj("Navigate", [["route", str(a.route)]]);
+    case "Navigate": {
+      const fields = [["route", textSource(a.route)]];
+      if (a.target !== "Self") fields.push(["target", str(a.target)]);
+      return caseObj("Navigate", fields);
+    }
     case "SetState": {
       const fields = [["key", str(a.key)]];
       if (a.value !== void 0) fields.push(["value", jsonValue(a.value)]);
@@ -482,7 +508,18 @@ 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 "Confirm": {
+      const fields = [];
+      if (a.onCancel !== void 0) fields.push(["onCancel", action(a.onCancel)]);
+      fields.push(["onConfirm", action(a.onConfirm)]);
+      fields.push(["prompt", textSource(a.prompt)]);
+      return caseObj("Confirm", fields);
+    }
+    case "Focus":
+      return caseObj("Focus", [["nodeId", str(a.nodeId)]]);
     case "ReadFileBody":
       return caseObj("ReadFileBody", [
         ["encoding", str(a.encoding)],
@@ -557,6 +594,10 @@ var formatIntent = (f) => {
         ["style", str(f.style)],
         ["unit", str(f.unit)]
       ]);
+    // Phase 1533 — `unit` omitted when absent: its absence is the
+    // auto-selection request, not a default that could be spelled out.
+    case "Since":
+      return caseObj("Since", f.unit !== void 0 ? [["unit", str(f.unit)]] : []);
     default:
       return assertNever(f);
   }
@@ -691,6 +732,42 @@ var mediaSpec = (s) => {
   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([
@@ -903,6 +980,10 @@ var displayKind = (d) => {
       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":
@@ -990,6 +1071,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),
@@ -1106,6 +1221,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) => {
@@ -1243,6 +1362,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 = [
@@ -1256,6 +1380,25 @@ var gridSpec = (s) => {
   }
   return jObject(fields);
 };
+var chartAnnotationX = (a) => a.kind === "Category" ? caseObj("Category", [["key", str(a.key)]]) : caseObj("Date", [["iso", str(a.iso)]]);
+var chartAnnotationRange = (r) => r.kind === "ValueRange" ? caseObj("ValueRange", [
+  ["from", num(r.from)],
+  ["to", num(r.to)]
+]) : caseObj("XRange", [
+  ["from", chartAnnotationX(r.from)],
+  ["to", chartAnnotationX(r.to)]
+]);
+var chartAnnotation = (a) => {
+  const label = a.label !== void 0 ? [["label", textSource(a.label)]] : [];
+  switch (a.kind) {
+    case "ReferenceLine":
+      return caseObj("ReferenceLine", [["value", num(a.value)], ...label]);
+    case "EventMarker":
+      return caseObj("EventMarker", [["at", chartAnnotationX(a.at)], ...label]);
+    default:
+      return caseObj("RangeBand", [["range", chartAnnotationRange(a.range)], ...label]);
+  }
+};
 var chartSpec = (s) => {
   const fields = [
     ["kind", str(s.kind)],
@@ -1273,6 +1416,8 @@ var chartSpec = (s) => {
   if (s.legendPosition !== void 0) fields.push(["legendPosition", str(s.legendPosition)]);
   if (s.dataLabels !== void 0) fields.push(["dataLabels", str(s.dataLabels)]);
   if (s.xScale !== void 0) fields.push(["xScale", str(s.xScale)]);
+  if (s.annotations !== void 0)
+    fields.push(["annotations", jArray(s.annotations.map(chartAnnotation))]);
   if (s.onPointClick !== void 0) fields.push(["onPointClick", CLOSURE]);
   return jObject(fields);
 };
@@ -1336,6 +1481,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([
@@ -1390,6 +1537,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) => {
@@ -1545,13 +1694,20 @@ 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(
+            // Phase 1535 — exactly one of `match` and `when` is present, so
+            // exactly one is emitted. `jObject` sorts, so the pair's relative
+            // order here is immaterial.
             k.spec.cases.map(
               (c) => jObject([
                 ["child", node(c.child)],
-                ["match", str(c.match)]
+                ...c.match !== void 0 ? [["match", str(c.match)]] : [],
+                ...c.when !== void 0 ? [["when", binding(c.when, bool)]] : []
               ])
             )
           )
@@ -1619,6 +1775,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) => {
@@ -1632,7 +1790,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)],
@@ -1641,6 +1801,8 @@ 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)]);
+  if (n.visible !== void 0) fields.push(["visible", binding(n.visible, bool)]);
   return jObject(fields);
 };
 var treeOp = (op) => {
@@ -2737,6 +2899,110 @@ var stepParams = (t) => {
 var pipelineParams = (pipeline) => [
   ...new Set(pipeline.flatMap((t) => stepParams(t)))
 ];
+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;
+  }
+});
+
+// src/localCodec.ts
+var identityFormat = (v) => {
+  if (v === null || v === void 0) return "";
+  if (typeof v === "string") return v;
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") {
+    if (Number.isNaN(v)) return "NaN";
+    if (v === Infinity) return "Infinity";
+    if (v === -Infinity) return "-Infinity";
+    return formatFiniteDouble(v);
+  }
+  return String(v);
+};
+var tryNumberText = (text) => {
+  const s = text.replace(/^[ \t\n\r]+|[ \t\n\r]+$/g, "");
+  if (!/^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(s)) return void 0;
+  const v = Number(s);
+  return Number.isFinite(v) ? v : void 0;
+};
+var scalarOfText = (text) => {
+  if (text === "true") return true;
+  if (text === "false") return false;
+  return tryNumberText(text);
+};
+var fixedText = (decimals, v) => {
+  if (!Number.isFinite(v)) return identityFormat(v);
+  const d = decimals < 0 ? 0 : Math.trunc(decimals);
+  const neg = v < 0;
+  const scaled = Math.floor(Math.abs(v) * Math.pow(10, d) + 0.5);
+  const whole = formatFiniteDouble(scaled);
+  const body = d === 0 ? whole : (() => {
+    const padded = whole.length <= d ? "0".repeat(d + 1 - whole.length) + whole : whole;
+    return padded.slice(0, padded.length - d) + "." + padded.slice(padded.length - d);
+  })();
+  return neg && scaled !== 0 ? "-" + body : body;
+};
+var numberText = (decimals, v) => decimals !== void 0 && typeof v === "number" ? fixedText(decimals, v) : identityFormat(v);
+var WireSurvivabilityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WireSurvivabilityError";
+  }
+};
+var DECODED_COMPUTED_MESSAGE = "Binding.Computed has no wire projection (decoded from a '<closure>' sentinel) \u2014 use Binding.Expr / Transform / State";
 var peek = (s) => s.pos < s.text.length ? s.text[s.pos] : " ";
 var advance = (s) => {
   s.pos += 1;
@@ -2767,51 +3033,94 @@ var expectChar = (s, ch) => {
   return fail(s, `expected '${ch}' but found '${peek(s)}'`);
 };
 var HEX_DIGIT = /[0-9a-fA-F]/;
+var HIGH_SURROGATE_FIRST = 55296;
+var HIGH_SURROGATE_LAST = 56319;
+var LOW_SURROGATE_FIRST = 56320;
+var LOW_SURROGATE_LAST = 57343;
 var parseStringRaw = (s) => {
   const open = expectChar(s, '"');
   if (!open.ok) return open;
   let out = "";
+  let codePoints = 0;
+  let pendingHigh = false;
+  const append = (unit) => {
+    const code = unit.charCodeAt(0);
+    const isHigh = code >= HIGH_SURROGATE_FIRST && code <= HIGH_SURROGATE_LAST;
+    const isLow = code >= LOW_SURROGATE_FIRST && code <= LOW_SURROGATE_LAST;
+    if (isHigh) {
+      if (pendingHigh) {
+        return {
+          message: "unpaired high surrogate: it must be followed by a low surrogate",
+          offset: s.pos
+        };
+      }
+      pendingHigh = true;
+      codePoints += 1;
+    } else if (isLow) {
+      if (!pendingHigh) {
+        return {
+          message: "unpaired low surrogate: it must be preceded by a high surrogate",
+          offset: s.pos
+        };
+      }
+      pendingHigh = false;
+    } else if (pendingHigh) {
+      return {
+        message: "unpaired high surrogate: it must be followed by a low surrogate",
+        offset: s.pos
+      };
+    } else {
+      codePoints += 1;
+    }
+    if (codePoints > MAX_STRING_LENGTH) {
+      return {
+        message: `string is longer than the wire limit MAX_STRING_LENGTH = ${MAX_STRING_LENGTH}`,
+        offset: s.pos,
+        limit: true
+      };
+    }
+    out += unit;
+    return void 0;
+  };
   for (; ; ) {
     if (s.pos >= s.text.length) return fail(s, "unterminated string");
     const c = s.text[s.pos];
     advance(s);
     if (c === '"') {
+      if (pendingHigh) {
+        return fail(s, "unpaired high surrogate at the end of a string");
+      }
       return { ok: true, value: out };
     }
-    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);
+      let unit;
       switch (esc) {
         case '"':
-          out += '"';
+          unit = '"';
           break;
         case "\\":
-          out += "\\";
+          unit = "\\";
           break;
         case "/":
-          out += "/";
+          unit = "/";
           break;
         case "b":
-          out += "\b";
+          unit = "\b";
           break;
         case "f":
-          out += "\f";
+          unit = "\f";
           break;
         case "n":
-          out += "\n";
+          unit = "\n";
           break;
         case "r":
-          out += "\r";
+          unit = "\r";
           break;
         case "t":
-          out += "	";
+          unit = "	";
           break;
         case "u": {
           if (s.pos + 4 > s.text.length) return fail(s, "incomplete \\u escape");
@@ -2820,26 +3129,58 @@ var parseStringRaw = (s) => {
             return fail(s, `invalid \\u escape '${hex}'`);
           }
           s.pos += 4;
-          out += String.fromCharCode(parseInt(hex, 16));
+          unit = String.fromCharCode(parseInt(hex, 16));
           break;
         }
         default:
           return fail(s, `unknown escape '\\${esc}'`);
       }
+      const bad = append(unit);
+      if (bad) return { ok: false, error: bad };
+    } else if (c.charCodeAt(0) < 32) {
+      return fail(
+        s,
+        `raw control character U+${c.charCodeAt(0).toString(16).padStart(4, "0").toUpperCase()} in a string must be escaped`
+      );
     } else {
-      out += c;
+      const bad = append(c);
+      if (bad) return { ok: false, error: bad };
     }
   }
 };
 var isNumberChar = (c) => c === "-" || c === "+" || c === "." || c === "e" || c === "E" || c >= "0" && c <= "9";
+var isRfc8259Number = (slice) => {
+  const n = slice.length;
+  let i = 0;
+  const digit = (k) => k < n && slice[k] >= "0" && slice[k] <= "9";
+  if (i < n && slice[i] === "-") i += 1;
+  if (!digit(i)) return false;
+  if (slice[i] === "0") {
+    i += 1;
+  } else {
+    while (digit(i)) i += 1;
+  }
+  if (i < n && slice[i] === ".") {
+    i += 1;
+    if (!digit(i)) return false;
+    while (digit(i)) i += 1;
+  }
+  if (i < n && (slice[i] === "e" || slice[i] === "E")) {
+    i += 1;
+    if (i < n && (slice[i] === "+" || slice[i] === "-")) i += 1;
+    if (!digit(i)) return false;
+    while (digit(i)) i += 1;
+  }
+  return i === n;
+};
 var parseNumberRaw = (s) => {
   const start = s.pos;
   while (s.pos < s.text.length && isNumberChar(s.text[s.pos])) {
     advance(s);
   }
   const slice = s.text.substring(start, s.pos);
-  if (slice.length === 0) {
-    return fail(s, `invalid number '${slice}'`);
+  if (!isRfc8259Number(slice)) {
+    return fail(s, `'${slice}' is not a JSON number (RFC 8259 grammar)`);
   }
   const n = Number(slice);
   if (Number.isNaN(n)) {
@@ -2926,6 +3267,10 @@ var parseObjectValue = (s) => {
         `object has more members than the wire limit MAX_ARRAY_LENGTH = ${MAX_ARRAY_LENGTH}`
       );
     }
+    if (fields.has(keyR.value)) {
+      s.depth -= 1;
+      return fail(s, `duplicate object member '${keyR.value}'`);
+    }
     fields.set(keyR.value, valR.value);
     skipWs(s);
     const c = peek(s);
@@ -2985,13 +3330,52 @@ var parseArrayValue = (s) => {
     }
   }
 };
+var documentBytes = (input) => {
+  if (input.length > MAX_DOCUMENT_BYTES) return input.length;
+  if (input.length <= MAX_DOCUMENT_BYTES / 3) return input.length;
+  let total = 0;
+  for (let i = 0; i < input.length; i += 1) {
+    const c = input.charCodeAt(i);
+    if (c < 128) {
+      total += 1;
+    } else if (c < 2048) {
+      total += 2;
+    } else if (c >= HIGH_SURROGATE_FIRST && c <= HIGH_SURROGATE_LAST && i + 1 < input.length) {
+      total += 4;
+      i += 1;
+    } else {
+      total += 3;
+    }
+  }
+  return total;
+};
 var parse = (input) => {
+  const bytes = documentBytes(input);
+  if (bytes > MAX_DOCUMENT_BYTES) {
+    return {
+      ok: false,
+      error: {
+        message: `document of ${bytes} UTF-8 bytes exceeds the wire limit MAX_DOCUMENT_BYTES = ${MAX_DOCUMENT_BYTES}`,
+        offset: 0,
+        limit: true
+      }
+    };
+  }
   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 } };
   }
-  return parseValue(s);
+  const value = parseValue(s);
+  if (!value.ok) return value;
+  skipWs(s);
+  if (s.pos < s.text.length) {
+    return fail(
+      s,
+      `unexpected content after the root value ('${s.text[s.pos]}'); a wire artefact is a single JSON document`
+    );
+  }
+  return value;
 };
 var field = (fields, key) => fields.get(key);
 
@@ -3036,9 +3420,31 @@ var requireFloat = (path, jRaw) => {
   }
   return wrongType(path, "JSON number (or 'NaN' / 'Infinity' / '-Infinity' sentinel string)");
 };
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+var isInt32Slot = (n) => Number.isFinite(n) && Number.isInteger(n) && n >= INT32_MIN && n <= INT32_MAX;
 var requireInt = (path, jRaw) => {
   const j = unwrapStaticEnvelope(jRaw);
-  return j.kind === "JNumber" ? ok(Math.trunc(j.value)) : wrongType(path, "JSON number (integer)");
+  if (j.kind !== "JNumber") return wrongType(path, "JSON number (integer)");
+  if (!Number.isFinite(j.value)) {
+    return wrongType(
+      path,
+      "JSON number (a finite 32-bit integer; the non-finite sentinels are a float slot's, not an integer slot's)"
+    );
+  }
+  if (!Number.isInteger(j.value)) {
+    return wrongType(
+      path,
+      "JSON number (a 32-bit integer; a fractional value is not truncated at an integer slot)"
+    );
+  }
+  if (!isInt32Slot(j.value)) {
+    return wrongType(
+      path,
+      "JSON number (a 32-bit integer; the value is outside the range this slot can hold)"
+    );
+  }
+  return ok(j.value);
 };
 var requireArray = (path, j) => j.kind === "JArray" ? ok(j.items) : wrongType(path, "JSON array");
 var tryField = (fields, key) => fields.get(key);
@@ -3196,6 +3602,8 @@ var decodeHeadingVariant = (p, j) => {
 };
 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 decodeNavigateTarget = (p, j) => bareEnum(p, j, ["Self", "Blank"], "NavigateTarget");
 var decodeImageAspect = (p, j) => bareEnum(
   p,
   j,
@@ -3203,7 +3611,16 @@ var decodeImageAspect = (p, j) => bareEnum(
   "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 = {
@@ -3264,6 +3681,149 @@ var decodeChartKind = (p, j) => bareEnum(p, j, ["Line", "Bar", "Area", "Pie", "S
 var decodeChartLegendPosition = (p, j) => bareEnum(p, j, ["Top", "Right", "Bottom", "None"], "ChartLegendPosition");
 var decodeChartDataLabels = (p, j) => bareEnum(p, j, ["Off", "Ends"], "ChartDataLabels");
 var decodeChartXScale = (p, j) => bareEnum(p, j, ["Category", "Temporal"], "ChartXScale");
+var annotationIsLeapYear = (y) => y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+var annotationDaysInMonth = (y, m) => m === 2 ? annotationIsLeapYear(y) ? 29 : 28 : m === 4 || m === 6 || m === 9 || m === 11 ? 30 : 31;
+var isCanonicalIsoDay = (text) => {
+  if (text.length < 10) return false;
+  if (text[4] !== "-" || text[7] !== "-") return false;
+  if (text.length > 10 && text[10] !== "T") return false;
+  const digits = (start, len) => {
+    let acc = 0;
+    for (let k = start; k < start + len; k += 1) {
+      const c = text.charCodeAt(k);
+      if (c < 48 || c > 57) return void 0;
+      acc = acc * 10 + (c - 48);
+    }
+    return acc;
+  };
+  const y = digits(0, 4);
+  const m = digits(5, 2);
+  const d = digits(8, 2);
+  if (y === void 0 || m === void 0 || d === void 0) return false;
+  return m >= 1 && m <= 12 && d >= 1 && d <= annotationDaysInMonth(y, m);
+};
+var decodeChartAnnotationX = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const disc = requireDiscriminator(path, f);
+  if (!disc.ok) return disc;
+  switch (disc.value) {
+    case "Category": {
+      const key = reqField(path, f, "key", "category key (the band's own label)", requireString);
+      if (!key.ok) return key;
+      return ok({ kind: "Category", key: key.value });
+    }
+    case "Date": {
+      const iso = reqField(path, f, "iso", "ISO-8601 date (YYYY-MM-DD)", requireString);
+      if (!iso.ok) return iso;
+      if (!isCanonicalIsoDay(iso.value))
+        return wrongType(
+          `${path}.iso`,
+          "a canonical ISO-8601 date (YYYY-MM-DD, optionally followed by a time) naming a real calendar day \u2014 an event marker\u2019s date is the address it is drawn at, and an unreadable one would place the marker at 1970-01-01 and drag the axis back with it"
+        );
+      return ok({ kind: "Date", iso: iso.value });
+    }
+    default:
+      return unknownDuCase(path, disc.value, "Category, Date");
+  }
+};
+var decodeChartAnnotationRange = (path, j) => {
+  const finite = (slot, v) => {
+    const r = requireFloat(`${path}.${slot}`, v);
+    if (!r.ok) return r;
+    return Number.isFinite(r.value) ? r : wrongType(
+      `${path}.${slot}`,
+      "a FINITE JSON number \u2014 a range band's end names a place on the value axis, and NaN / Infinity names none; give the value in the axis's own units, or drop the annotation"
+    );
+  };
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const disc = requireDiscriminator(path, f);
+  if (!disc.ok) return disc;
+  switch (disc.value) {
+    case "ValueRange": {
+      const fromJ = requireField(path, f, "from", "range-band lower value (a finite JSON number)");
+      if (!fromJ.ok) return fromJ;
+      const from = finite("from", fromJ.value);
+      if (!from.ok) return from;
+      const toJ = requireField(path, f, "to", "range-band upper value (a finite JSON number)");
+      if (!toJ.ok) return toJ;
+      const to = finite("to", toJ.value);
+      if (!to.ok) return to;
+      if (from.value > to.value)
+        return wrongType(
+          path,
+          "an ORDERED pair \u2014 a range band runs from its lower value to its upper one, and this pair runs backwards; swapping the ends silently would draw a band the author did not describe"
+        );
+      return ok({ kind: "ValueRange", from: from.value, to: to.value });
+    }
+    case "XRange": {
+      const fromJ = requireField(
+        path,
+        f,
+        "from",
+        "range-band lower x address (a ChartAnnotationX)"
+      );
+      if (!fromJ.ok) return fromJ;
+      const from = decodeChartAnnotationX(`${path}.from`, fromJ.value);
+      if (!from.ok) return from;
+      const toJ = requireField(path, f, "to", "range-band upper x address (a ChartAnnotationX)");
+      if (!toJ.ok) return toJ;
+      const to = decodeChartAnnotationX(`${path}.to`, toJ.value);
+      if (!to.ok) return to;
+      if (from.value.kind === "Date" && to.value.kind === "Date" && from.value.iso > to.value.iso)
+        return wrongType(
+          path,
+          "an ORDERED pair \u2014 a range band runs from its earlier date to its later one, and this pair runs backwards; swapping the ends silently would draw a band the author did not describe"
+        );
+      return ok({ kind: "XRange", from: from.value, to: to.value });
+    }
+    default:
+      return unknownDuCase(path, disc.value, "ValueRange, XRange");
+  }
+};
+var decodeChartAnnotation = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const disc = requireDiscriminator(path, f);
+  if (!disc.ok) return disc;
+  const label = optField(path, f, "label", decodeTextSource);
+  if (!label.ok) return label;
+  const withLabel = label.value !== void 0 ? { label: label.value } : {};
+  switch (disc.value) {
+    case "ReferenceLine": {
+      const valueJ = requireField(path, f, "value", "reference-line value (a finite JSON number)");
+      if (!valueJ.ok) return valueJ;
+      const value = requireFloat(`${path}.value`, valueJ.value);
+      if (!value.ok) return value;
+      if (!Number.isFinite(value.value))
+        return wrongType(
+          `${path}.value`,
+          "a FINITE JSON number \u2014 a reference line names a place on the value axis, and NaN / Infinity names none; give the value in the axis's own units, or drop the annotation"
+        );
+      return ok({ kind: "ReferenceLine", value: value.value, ...withLabel });
+    }
+    case "EventMarker": {
+      const atJ = requireField(path, f, "at", "event-marker x address (a ChartAnnotationX)");
+      if (!atJ.ok) return atJ;
+      const at = decodeChartAnnotationX(`${path}.at`, atJ.value);
+      if (!at.ok) return at;
+      return ok({ kind: "EventMarker", at: at.value, ...withLabel });
+    }
+    case "RangeBand": {
+      const rangeJ = requireField(path, f, "range", "range-band pair (a ChartAnnotationRange)");
+      if (!rangeJ.ok) return rangeJ;
+      const range = decodeChartAnnotationRange(`${path}.range`, rangeJ.value);
+      if (!range.ok) return range;
+      return ok({ kind: "RangeBand", range: range.value, ...withLabel });
+    }
+    default:
+      return unknownDuCase(path, disc.value, "ReferenceLine, EventMarker, RangeBand");
+  }
+};
 var decodeFileReadEncoding = (p, j) => bareEnum(p, j, ["Text", "Base64", "DataUrl"], "FileReadEncoding");
 var decodeAriaRole = (p, j) => {
   if (j.kind !== "JString") return wrongType(p, "JSON string (ARIA role)");
@@ -3278,6 +3838,7 @@ var decodeRelativeTimeUnit = (p, j) => bareEnum(
   ["Second", "Minute", "Hour", "Day", "Week", "Month", "Year"],
   "RelativeTimeUnit"
 );
+var decodeTimeGrain = (p, j) => bareEnum(p, j, ["Second", "Minute", "Hour", "Day"], "TimeGrain");
 var decodeCellFormat = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
@@ -3377,11 +3938,17 @@ var decodeFormat = (path, j) => {
       if (!style.ok) return style;
       return ok({ kind: "Duration", unit: unit.value, style: style.value });
     }
+    case "Since": {
+      const u = tryField(f, "unit");
+      if (u === void 0) return ok({ kind: "Since" });
+      const r = decodeRelativeTimeUnit(`${path}.unit`, u);
+      return r.ok ? ok({ kind: "Since", unit: r.value }) : r;
+    }
     default:
       return unknownDuCase(
         path,
         d.value,
-        "Number | Currency | Percent | Date | RelativeTime | Duration"
+        "Number | Currency | Percent | Date | RelativeTime | Duration | Since"
       );
   }
 };
@@ -3535,7 +4102,13 @@ var cFieldAliased = (f, canonical, alias) => {
 };
 var cStr = (j) => j.kind === "JString" ? cok(j.value) : cerr("malformed: expected string, got " + astKind(j));
 var cArr = (j) => j.kind === "JArray" ? cok(j.items) : cerr("malformed: expected array, got " + astKind(j));
-var cInt = (j) => j.kind === "JNumber" ? cok(Math.trunc(j.value)) : cerr("malformed: expected int, got " + astKind(j));
+var cInt = (j) => {
+  if (j.kind !== "JNumber") return cerr("malformed: expected int, got " + astKind(j));
+  if (!isInt32Slot(j.value)) {
+    return cerr(`malformed: expected a 32-bit integer, got ${j.value}`);
+  }
+  return cok(j.value);
+};
 var cMapM = (xs, fn) => {
   const out = [];
   for (const x of xs) {
@@ -3566,7 +4139,7 @@ var decodeCellLit = (j) => {
   if (v === void 0) return mismatch;
   switch (t) {
     case "Int":
-      return v.kind === "JNumber" ? cok({ kind: "Int", value: Math.trunc(v.value) }) : mismatch;
+      return v.kind === "JNumber" && isInt32Slot(v.value) ? cok({ kind: "Int", value: v.value }) : mismatch;
     case "Float":
       return v.kind === "JNumber" ? cok({ kind: "Float", value: v.value }) : mismatch;
     case "Bool":
@@ -4269,6 +4842,137 @@ var decodeInvokeArgs = (path, j) => {
     return ok({ addr: addr.value, value: value.value });
   });
 };
+var exprAdmissible = (root) => {
+  let count = 0;
+  let sawCol = false;
+  const walk = (e) => {
+    count += 1;
+    if (sawCol || count > MAX_EXPR_NODES) return;
+    switch (e.kind) {
+      case "col":
+        sawCol = true;
+        return;
+      case "lit":
+      case "param":
+        return;
+      case "binary":
+        walk(e.left);
+        walk(e.right);
+        return;
+      case "not":
+      case "cast":
+      case "isNull":
+        walk(e.expr);
+        return;
+      case "coalesce":
+        e.exprs.forEach(walk);
+        return;
+      case "apply":
+        e.args.forEach(walk);
+        return;
+      case "case":
+        for (const c of e.cases) {
+          walk(c.when);
+          walk(c.then);
+        }
+        walk(e.else);
+        return;
+      case "in":
+        walk(e.expr);
+        e.items.forEach(walk);
+        return;
+      case "inParam":
+        walk(e.expr);
+        return;
+    }
+  };
+  walk(root);
+  if (sawCol) return "col";
+  if (count > MAX_EXPR_NODES) return "limit";
+  return "ok";
+};
+var colExprParamNames = (root) => {
+  const seen = [];
+  const push = (n) => {
+    if (!seen.includes(n)) seen.push(n);
+  };
+  const walk = (e) => {
+    switch (e.kind) {
+      case "col":
+      case "lit":
+        return;
+      case "param":
+        push(e.name);
+        return;
+      case "binary":
+        walk(e.left);
+        walk(e.right);
+        return;
+      case "not":
+      case "cast":
+      case "isNull":
+        walk(e.expr);
+        return;
+      case "coalesce":
+        e.exprs.forEach(walk);
+        return;
+      case "apply":
+        e.args.forEach(walk);
+        return;
+      case "case":
+        for (const c of e.cases) {
+          walk(c.when);
+          walk(c.then);
+        }
+        walk(e.else);
+        return;
+      case "in":
+        walk(e.expr);
+        e.items.forEach(walk);
+        return;
+      case "inParam":
+        walk(e.expr);
+        push(e.param);
+        return;
+    }
+  };
+  walk(root);
+  return seen;
+};
+var decodeExprParams = (path, f) => {
+  const paramsField = tryField(f, "params");
+  if (paramsField === void 0) return ok(void 0);
+  if (paramsField.kind === "JObject") {
+    const entries = [...paramsField.fields.entries()].sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    );
+    const out = [];
+    for (const [name, v] of entries) {
+      const from = decodeBinding(`${path}.params.${name}.from`, v);
+      if (!from.ok) return from;
+      out.push({ name, from: from.value });
+    }
+    return ok(out);
+  }
+  const arr = requireArray(`${path}.params`, paramsField);
+  if (!arr.ok) return arr;
+  return traverseIndexed(arr.value, (_i, el) => {
+    const po = requireObject(`${path}.params[]`, el);
+    if (!po.ok) return po;
+    const name = reqField(`${path}.params[]`, po.value, "name", "param name string", requireString);
+    if (!name.ok) return name;
+    const from = reqFieldAliased(
+      `${path}.params[]`,
+      po.value,
+      "from",
+      ["value"],
+      "param source Binding",
+      decodeBinding
+    );
+    if (!from.ok) return from;
+    return ok({ name: name.value, from: from.value });
+  });
+};
 var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), placeholder = OPAQUE2) => {
   if (j.kind === "JArray" || j.kind === "JString" || j.kind === "JNumber" || j.kind === "JBool") {
     const parsed = parseStatic(path, j);
@@ -4359,23 +5063,31 @@ 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":
-      return ok({ kind: "Computed", compute: () => void 0 });
+      return ok({
+        kind: "Computed",
+        compute: () => {
+          throw new WireSurvivabilityError(DECODED_COMPUTED_MESSAGE);
+        }
+      });
     // The projection decodes to the IDENTITY (the Phase 427 Selection fix
     // replayed): the host-furnished instant is already the wire-shaped string,
     // so a decoded reader receives it as-is. A value-discarding placeholder
     // here would make every decoded `Now` resolve to nothing even when the
     // host furnishes the instant.
-    case "Now":
-      return ok({ kind: "Now", project: (iso) => iso });
+    case "Now": {
+      const g = tryField(f, "grain");
+      if (g === void 0) return ok({ kind: "Now", project: (iso) => iso });
+      const r = decodeTimeGrain(`${path}.grain`, g);
+      return r.ok ? ok({ kind: "Now", project: (iso) => iso, grain: r.value }) : r;
+    }
     case "I18n": {
       const key = reqField(path, f, "key", "i18n key string", requireString);
       if (!key.ok) return key;
@@ -4390,6 +5102,37 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       return ok(b);
     }
     case "Local": {
+      const codecJ = tryField(f, "codec");
+      let codec;
+      if (codecJ !== void 0) {
+        const c = decodeFormat(`${path}.codec`, codecJ);
+        if (!c.ok) return c;
+        if (c.value.kind !== "Number") {
+          return makeError(
+            "WRONG_TYPE",
+            `${path}.codec`,
+            "Binding.Local 'codec' must be a Format case with a total, locale-independent inverse \u2014 only 'Number' has one",
+            'use {"$type":"Number","decimals":2}, or drop the codec and let the buffer use the identity; a locale-rendered format (Currency / Date / RelativeTime / Since / Duration) cannot be parsed back from what the reader typed'
+          );
+        }
+        codec = c.value;
+      }
+      const onCommitPresent = tryField(f, "onCommit") !== void 0;
+      const commitToJ = tryField(f, "commitTo");
+      let commitTo;
+      if (commitToJ !== void 0) {
+        if (onCommitPresent) {
+          return makeError(
+            "WRONG_TYPE",
+            `${path}.commitTo`,
+            "Binding.Local carries both 'onCommit' and 'commitTo' \u2014 exactly one commit destination is allowed",
+            "either onCommit (a host closure, which crosses the wire only as the closure sentinel) or commitTo (the State key the flush writes); a decoding host can honour only the second, so keeping both makes the same document commit to two different places depending on who read it"
+          );
+        }
+        const ct = requireString(`${path}.commitTo`, commitToJ);
+        if (!ct.ok) return ct;
+        commitTo = ct.value;
+      }
       const initial = reqField(
         path,
         f,
@@ -4401,15 +5144,35 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       const flushJ = tryField(f, "flushOn");
       const flush = flushJ === void 0 ? ok({ kind: "OnBlur" }) : decodeLocalFlushTrigger(`${path}.flushOn`, flushJ);
       if (!flush.ok) return flush;
-      const b = {
-        kind: "Local",
-        local: {
-          initialFrom: initial.value,
-          flushOn: flush.value,
-          onCommit: () => void 0,
-          parse: () => ({ ok: false, error: CLOSURE2 })
-        }
+      const refusalOf = (raw) => `Binding.Local: '${raw}' is not a value this field accepts`;
+      const identityParse = (raw) => {
+        const asText = parseStatic(`${path}.parse`, { kind: "JString", value: raw });
+        if (asText.ok) return { ok: true, value: asText.value };
+        const scalar = scalarOfText(raw);
+        if (scalar === void 0) return { ok: false, error: refusalOf(raw) };
+        const asScalar = parseStatic(
+          `${path}.parse`,
+          typeof scalar === "number" ? { kind: "JNumber", value: scalar } : { kind: "JBool", value: scalar }
+        );
+        return asScalar.ok ? { ok: true, value: asScalar.value } : { ok: false, error: refusalOf(raw) };
       };
+      const decimals = codec !== void 0 && codec.kind === "Number" ? codec.decimals : void 0;
+      const codecParse = (raw) => {
+        const n = tryNumberText(raw);
+        if (n === void 0) return { ok: false, error: refusalOf(raw) };
+        const parsed = parseStatic(`${path}.parse`, { kind: "JNumber", value: n });
+        return parsed.ok ? { ok: true, value: parsed.value } : { ok: false, error: refusalOf(raw) };
+      };
+      const local = {
+        initialFrom: initial.value,
+        flushOn: flush.value,
+        format: codec !== void 0 ? (v) => numberText(decimals, v) : (v) => identityFormat(v),
+        parse: codec !== void 0 ? codecParse : identityParse,
+        ...onCommitPresent ? { onCommit: () => void 0 } : {},
+        ...codec !== void 0 ? { codec } : {},
+        ...commitTo !== void 0 ? { commitTo } : {}
+      };
+      const b = { kind: "Local", local };
       return ok(b);
     }
     case "Format": {
@@ -4481,52 +5244,9 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       }
       const pipe = decodePipelineCore(pipeJ.value);
       if (!pipe.ok) return makeError("WRONG_TYPE", `${path}.pipeline`, pipe.error);
-      const paramsField = tryField(f, "params");
-      let params;
-      if (paramsField !== void 0 && paramsField.kind === "JObject") {
-        const entries = [...paramsField.fields.entries()].sort(
-          ([a], [b2]) => a < b2 ? -1 : a > b2 ? 1 : 0
-        );
-        const out = [];
-        let coerceErr;
-        for (const [name, v] of entries) {
-          const from = decodeBinding(`${path}.params.${name}.from`, v);
-          if (!from.ok) {
-            coerceErr = from;
-            break;
-          }
-          out.push({ name, from: from.value });
-        }
-        if (coerceErr !== void 0) return coerceErr;
-        params = out;
-      } else if (paramsField !== void 0) {
-        const arr = requireArray(`${path}.params`, paramsField);
-        if (!arr.ok) return arr;
-        const decoded = traverseIndexed(arr.value, (_i, el) => {
-          const po = requireObject(`${path}.params[]`, el);
-          if (!po.ok) return po;
-          const name = reqField(
-            `${path}.params[]`,
-            po.value,
-            "name",
-            "param name string",
-            requireString
-          );
-          if (!name.ok) return name;
-          const from = reqFieldAliased(
-            `${path}.params[]`,
-            po.value,
-            "from",
-            ["value"],
-            "param source Binding",
-            decodeBinding
-          );
-          if (!from.ok) return from;
-          return ok({ name: name.value, from: from.value });
-        });
-        if (!decoded.ok) return decoded;
-        params = decoded.value;
-      }
+      const paramsR = decodeExprParams(path, f);
+      if (!paramsR.ok) return paramsR;
+      const params = paramsR.value;
       const b = {
         kind: "Transform",
         source,
@@ -4535,6 +5255,47 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       };
       return ok(b);
     }
+    case "Expr": {
+      const exprJ = requireField(path, f, "expr", "ColExpr object");
+      if (!exprJ.ok) return exprJ;
+      const expr = decodeColExprCore(exprJ.value);
+      if (!expr.ok) return makeError("WRONG_TYPE", `${path}.expr`, expr.error);
+      const verdict = exprAdmissible(expr.value);
+      if (verdict === "col") {
+        return makeError(
+          "WRONG_TYPE",
+          `${path}.expr`,
+          "a `col` reference is not admitted inside an Expr binding \u2014 an Expr evaluates against its params alone and has no row for a column name to read. Use `Binding.Transform`, whose source supplies the frame, and put the column expression in a `derive` step",
+          "a ColExpr over `param` / `lit` / operators only (no `col`)"
+        );
+      }
+      if (verdict === "limit") {
+        return makeError(
+          "LIMIT_EXCEEDED",
+          `${path}.expr`,
+          `expression exceeds the maximum of ${MAX_EXPR_NODES} expression nodes (WIRE_FORMAT 21)`,
+          `at most ${MAX_EXPR_NODES} ColExpr nodes in one Expr binding`
+        );
+      }
+      const exprParams = decodeExprParams(path, f);
+      if (!exprParams.ok) return exprParams;
+      const bound = new Set((exprParams.value ?? []).map((p) => p.name));
+      const missing = colExprParamNames(expr.value).filter((n) => !bound.has(n));
+      if (missing.length > 0) {
+        return makeError(
+          "WRONG_TYPE",
+          `${path}.expr`,
+          `the expression reads param(s) ${missing.map((n) => `'${n}'`).join(", ")} that this binding's \`params\` does not bind \u2014 an Expr has no rows and no filter to prune, so an unbound param has no value to take; add a params entry naming each, or drop the reference`,
+          '{"$type":"Expr","expr":{\u2026},"params":[{"name":"<name>","from":<Binding>}]}'
+        );
+      }
+      const b = {
+        kind: "Expr",
+        expr: expr.value,
+        ...exprParams.value !== void 0 ? { params: exprParams.value } : {}
+      };
+      return ok(b);
+    }
     case "Invoke": {
       const cid = reqField(path, f, "capabilityId", "capability id string", requireString);
       if (!cid.ok) return cid;
@@ -4818,7 +5579,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);
@@ -4878,10 +5639,14 @@ var decodeAction = (path, j) => {
         f,
         "route",
         ["href", "url", "to"],
-        "route string",
-        requireString
+        "route TextSource",
+        decodeTextSource
       );
-      return r.ok ? ok({ kind: "Navigate", route: r.value }) : r;
+      if (!r.ok) return r;
+      const targetJ = tryField(f, "target");
+      const target = targetJ === void 0 ? ok("Self") : decodeNavigateTarget(`${path}.target`, targetJ);
+      if (!target.ok) return target;
+      return ok({ kind: "Navigate", route: r.value, target: target.value });
     }
     case "SetState": {
       const key = reqField(path, f, "key", "state key string", requireString);
@@ -4938,9 +5703,64 @@ 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 "Confirm": {
+      const nestedConfirmPath = (p, a) => {
+        if (a.kind === "Confirm") return p;
+        if (a.kind === "Chain") {
+          for (let i = 0; i < a.actions.length; i++) {
+            const found = nestedConfirmPath(`${p}.ops[${i}]`, a.actions[i]);
+            if (found !== void 0) return found;
+          }
+        }
+        return void 0;
+      };
+      const prompt = reqField(path, f, "prompt", "confirm prompt TextSource", decodeTextSource);
+      if (!prompt.ok) return prompt;
+      const confirmJ = requireField(path, f, "onConfirm", "Action to dispatch on acceptance");
+      if (!confirmJ.ok) return confirmJ;
+      const onConfirm = decodeAction(`${path}.onConfirm`, confirmJ.value);
+      if (!onConfirm.ok) return onConfirm;
+      const nestedInConfirm = nestedConfirmPath(`${path}.onConfirm`, onConfirm.value);
+      if (nestedInConfirm !== void 0)
+        return wrongType(
+          nestedInConfirm,
+          "any action but Confirm \u2014 confirmation is bounded at one question (WIRE_FORMAT.md \xA73.6.22)"
+        );
+      const cancelJ = f.get("onCancel");
+      if (cancelJ === void 0)
+        return ok({ kind: "Confirm", prompt: prompt.value, onConfirm: onConfirm.value });
+      const onCancel = decodeAction(`${path}.onCancel`, cancelJ);
+      if (!onCancel.ok) return onCancel;
+      const nestedInCancel = nestedConfirmPath(`${path}.onCancel`, onCancel.value);
+      if (nestedInCancel !== void 0)
+        return wrongType(
+          nestedInCancel,
+          "any action but Confirm \u2014 confirmation is bounded at one question (WIRE_FORMAT.md \xA73.6.22)"
+        );
+      return ok({
+        kind: "Confirm",
+        prompt: prompt.value,
+        onConfirm: onConfirm.value,
+        onCancel: onCancel.value
+      });
+    }
+    case "Focus": {
+      const r = reqField(path, f, "nodeId", "NodeId string of the node to focus", requireString);
+      return r.ok ? ok({ kind: "Focus", nodeId: r.value }) : r;
+    }
     case "ReadFileBody": {
       const fileId = reqField(path, f, "fileRef", "FileRef id string", requireString);
       if (!fileId.ok) return fileId;
@@ -4965,7 +5785,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"
       );
   }
 };
@@ -5246,12 +6066,139 @@ var decodeMediaSpec = (path, j) => {
   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
+    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) => {
@@ -5727,10 +6674,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;
@@ -5755,7 +6710,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"
       );
   }
 };
@@ -5886,6 +6841,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;
@@ -6182,12 +7226,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) => {
@@ -6605,6 +7668,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) {
@@ -6625,6 +7698,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 } : {}
   });
 };
@@ -6670,6 +7748,18 @@ var decodeChartSpec = (path, j) => {
   if (!dataLabels.ok) return dataLabels;
   const xScale = optField(path, f, "xScale", decodeChartXScale);
   if (!xScale.ok) return xScale;
+  const annotationsJ = tryField(f, "annotations");
+  let annotations;
+  if (annotationsJ !== void 0) {
+    const arr2 = requireArray(`${path}.annotations`, annotationsJ);
+    if (!arr2.ok) return arr2;
+    const decoded = traverseIndexed(
+      arr2.value,
+      (i, item) => decodeChartAnnotation(`${path}.annotations[${i}]`, item)
+    );
+    if (!decoded.ok) return decoded;
+    annotations = decoded.value;
+  }
   const hasPointClick = tryField(f, "onPointClick") !== void 0;
   const stacked = optField(path, f, "stacked", requireBool);
   if (!stacked.ok) return stacked;
@@ -6687,6 +7777,7 @@ var decodeChartSpec = (path, j) => {
     ...legendPosition.value !== void 0 ? { legendPosition: legendPosition.value } : {},
     ...dataLabels.value !== void 0 ? { dataLabels: dataLabels.value } : {},
     ...xScale.value !== void 0 ? { xScale: xScale.value } : {},
+    ...annotations !== void 0 ? { annotations } : {},
     ...hasPointClick ? { onPointClick: () => placeholderAction } : {}
   });
 };
@@ -6837,11 +7928,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) => {
@@ -6988,12 +8085,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) => {
@@ -7280,6 +8384,8 @@ var decodeNodeKind = (path, j) => {
     case "Link":
     case "Image":
     case "Media":
+    case "Embed":
+    case "Tree":
     case "List":
     case "Toast":
     case "CodeBlock":
@@ -7370,18 +8476,51 @@ var decodeNodeKind = (path, j) => {
         const cp = `${path}.cases[${i}]`;
         const co = requireObject(cp, item);
         if (!co.ok) return co;
-        const m = reqField(cp, co.value, "match", "Switch case match string", requireString);
-        if (!m.ok) return m;
+        const mJ = tryField(co.value, "match");
+        const wJ = tryField(co.value, "when");
+        if (mJ !== void 0 && wJ !== void 0)
+          return wrongType(
+            `${cp}.when`,
+            "either 'match' (a literal string compared against the switch's `on` selector) or 'when' (a Binding<bool> predicate evaluated at render time, needing no selector); remove one"
+          );
+        if (mJ === void 0 && wJ === void 0)
+          return missingField(
+            cp,
+            "match",
+            "a literal string under 'match' (compared against the switch's `on` selector), or a Binding<bool> under 'when' (a predicate evaluated at render time)"
+          );
         const c = reqField(cp, co.value, "child", "Switch case child Node", decodeNodeAst);
         if (!c.ok) return c;
-        return ok({ match: m.value, child: c.value });
+        if (mJ !== void 0) {
+          const m = requireString(`${cp}.match`, mJ);
+          if (!m.ok) return m;
+          return ok({ match: m.value, child: c.value });
+        }
+        const w = decodeBindingBool(`${cp}.when`, wJ);
+        if (!w.ok) return w;
+        return ok({ when: w.value, child: c.value });
       });
       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": {
@@ -7547,12 +8686,15 @@ 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 = [
@@ -7650,11 +8792,13 @@ var placeholderClosureNode = {
 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);
@@ -7698,12 +8842,18 @@ var decodeNodeAstInner = (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;
+  const visible = optField(path, f, "visible", decodeBindingBool);
+  if (!visible.ok) return visible;
   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 } : {},
+    ...visible.value !== void 0 ? { visible: visible.value } : {}
   });
 };
 var decodeTreeOpAst = (path, j) => {
@@ -7912,10 +9062,238 @@ var decodeOp = (json, policy) => {
   resetWalk(policy);
   return decodeTreeOpAst("$", parsed.value);
 };
+var decodeOps = (json, policy) => {
+  const parsed = parse(json);
+  if (!parsed.ok) return parseFailure(parsed.error);
+  resetWalk(policy);
+  const entries = parsed.value.kind === "JArray" ? parsed.value.items : [parsed.value];
+  const ops = [];
+  for (let i = 0; i < entries.length; i += 1) {
+    const path = parsed.value.kind === "JArray" ? `$[${i}]` : "$";
+    const decoded = decodeTreeOpAst(path, entries[i]);
+    if (!decoded.ok) return decoded;
+    ops.push(decoded.value);
+  }
+  return ok(ops);
+};
+
+// src/capabilityDecl.ts
+var dok2 = (value) => ({ ok: true, value });
+var derr2 = (error) => ({ ok: false, error });
+var HOST_WIRE = {
+  Pure: "pure",
+  ReadsHost: "readsHost",
+  WritesHost: "writesHost"
+};
+var DETERMINISM_WIRE = {
+  Deterministic: "deterministic",
+  Clock: "clock",
+  Random: "random",
+  Network: "network"
+};
+var PLACEMENT_WIRE = {
+  BuildTime: "buildTime",
+  Server: "server",
+  ClientDeclarative: "clientDeclarative",
+  ClientIsland: "clientIsland",
+  Precomputed: "precomputed"
+};
+var SPACE_WIRE = {
+  IntRange: "intRange",
+  FloatRange: "floatRange",
+  StringLen: "stringLen",
+  Enum: "enum",
+  AnyString: "anyString"
+};
+var ISLANDS = ["pyodide", "fable", "js"];
+var invert = (m) => Object.fromEntries(Object.entries(m).map(([k, v]) => [v, k]));
+var HOST_OF = invert(HOST_WIRE);
+var DETERMINISM_OF = invert(DETERMINISM_WIRE);
+var PLACEMENT_OF = invert(PLACEMENT_WIRE);
+var SPACE_OF = invert(SPACE_WIRE);
+var spaceJson = (s) => {
+  switch (s.kind) {
+    case "IntRange":
+      return caseObj(SPACE_WIRE[s.kind], [
+        ["min", num(s.min)],
+        ["max", num(s.max)]
+      ]);
+    case "FloatRange":
+      return caseObj(SPACE_WIRE[s.kind], [
+        ["min", num(s.min)],
+        ["max", num(s.max)]
+      ]);
+    case "StringLen":
+      return caseObj(SPACE_WIRE[s.kind], [
+        ["min", num(s.minLen)],
+        ["max", num(s.maxLen)]
+      ]);
+    case "Enum":
+      return caseObj(SPACE_WIRE[s.kind], [["values", jArray(s.choices.map(str))]]);
+    case "AnyString":
+      return caseObj(SPACE_WIRE[s.kind], []);
+  }
+};
+var entryJson = (e) => {
+  const fields = [
+    ["addr", str(e.addr)],
+    ["name", str(e.name)],
+    ["kind", str(e.kind)],
+    ["required", bool(e.required)]
+  ];
+  if (e.space !== void 0) fields.push(["space", spaceJson(e.space)]);
+  if (e.slotKind !== void 0) fields.push(["slotKind", str(e.slotKind)]);
+  return jObject(fields);
+};
+var placementJson = (p) => p.kind === "ClientIsland" ? caseObj(PLACEMENT_WIRE[p.kind], [["island", str(p.island)]]) : caseObj(PLACEMENT_WIRE[p.kind], []);
+var signatureJson = (sg) => jObject([
+  ["name", str(sg.name)],
+  [
+    "effect",
+    jObject([
+      ["host", str(HOST_WIRE[sg.effect.hostEffect])],
+      ["determinism", str(DETERMINISM_WIRE[sg.effect.determinism])]
+    ])
+  ],
+  ["holes", jArray(sg.holes.map(entryJson))]
+]);
+var encodeCapabilityDeclaration = (cap) => caseObj("capability", [
+  ["id", str(cap.id)],
+  ["signature", signatureJson(cap.signature)],
+  ["determinism", str(DETERMINISM_WIRE[cap.determinism])],
+  ["placement", placementJson(cap.placement)]
+]);
+var DeclError = class extends Error {
+};
+var fail2 = (message) => {
+  throw new DeclError(message);
+};
+var asObject = (v, what) => typeof v !== "object" || v === null || Array.isArray(v) ? fail2(`${what} is not an object`) : v;
+var strAt = (o, k) => {
+  const v = o[k];
+  return typeof v === "string" ? v : fail2(`missing or non-string field: ${k}`);
+};
+var numAt = (o, k) => {
+  const v = o[k];
+  return typeof v === "number" && Number.isFinite(v) ? v : fail2(`missing or non-finite numeric field: ${k}`);
+};
+var spaceOf = (raw) => {
+  const o = asObject(raw, "value-space");
+  const tag = strAt(o, "$type");
+  const kind = SPACE_OF[tag];
+  switch (kind) {
+    case "IntRange":
+      return { kind, min: numAt(o, "min"), max: numAt(o, "max") };
+    case "FloatRange":
+      return { kind, min: numAt(o, "min"), max: numAt(o, "max") };
+    case "StringLen":
+      return { kind, minLen: numAt(o, "min"), maxLen: numAt(o, "max") };
+    case "Enum": {
+      const values = o["values"];
+      if (!Array.isArray(values) || values.some((x) => typeof x !== "string"))
+        fail2("enum values must be a string array");
+      return { kind, choices: values };
+    }
+    case "AnyString":
+      return { kind };
+    default:
+      return fail2(
+        `unknown value-space kind: ${tag}; expected one of: ${Object.values(SPACE_WIRE).join(", ")}`
+      );
+  }
+};
+var entryOf = (raw) => {
+  const o = asObject(raw, "signature hole");
+  if ("actionEffect" in o) {
+    fail2(
+      "this host's signature entry carries no action-effect axis, so a hole declaring `actionEffect` cannot round-trip"
+    );
+  }
+  const kind = strAt(o, "kind");
+  if (kind !== "value" && kind !== "slot" && kind !== "repeat")
+    fail2(`unknown hole kind: ${kind}; expected one of: value, slot, repeat`);
+  const required = o["required"];
+  if (typeof required !== "boolean") fail2("missing or non-boolean field: required");
+  return {
+    addr: strAt(o, "addr"),
+    name: strAt(o, "name"),
+    kind,
+    required,
+    ..."space" in o ? { space: spaceOf(o["space"]) } : {},
+    ..."slotKind" in o ? { slotKind: strAt(o, "slotKind") } : {}
+  };
+};
+var placementOf = (raw) => {
+  const o = asObject(raw, "placement");
+  const tag = strAt(o, "$type");
+  const kind = PLACEMENT_OF[tag];
+  if (kind === void 0)
+    fail2(`unknown placement: ${tag}; expected one of: ${Object.values(PLACEMENT_WIRE).join(", ")}`);
+  if (kind === "ClientIsland") {
+    const island = strAt(o, "island");
+    if (!ISLANDS.includes(island))
+      fail2(`unknown island kind: ${island}; expected one of: ${ISLANDS.join(", ")}`);
+    return { kind, island };
+  }
+  return { kind };
+};
+var declarationOf = (json) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return fail2("capability declaration is not well-formed JSON");
+  }
+  const o = asObject(parsed, "capability declaration");
+  const tag = o["$type"];
+  if (tag !== void 0 && tag !== "capability")
+    fail2(`not a capability declaration: $type '${String(tag)}'`);
+  const sigObj = asObject(o["signature"], "signature");
+  const effectObj = asObject(sigObj["effect"], "effect");
+  const hostTag = strAt(effectObj, "host");
+  const hostEffect = HOST_OF[hostTag];
+  if (hostEffect === void 0)
+    fail2(
+      `unknown host effect: ${hostTag}; expected one of: ${Object.values(HOST_WIRE).join(", ")}`
+    );
+  const detTag = strAt(effectObj, "determinism");
+  const determinism = DETERMINISM_OF[detTag];
+  if (determinism === void 0)
+    fail2(
+      `unknown determinism: ${detTag}; expected one of: ${Object.values(DETERMINISM_WIRE).join(", ")}`
+    );
+  const holes = sigObj["holes"];
+  if (!Array.isArray(holes)) fail2("missing or non-array field: holes");
+  const signature = {
+    name: strAt(sigObj, "name"),
+    holes: holes.map(entryOf),
+    effect: { hostEffect, determinism }
+  };
+  const wireTag = strAt(o, "determinism");
+  const expectedTag = DETERMINISM_WIRE[determinism];
+  if (wireTag !== expectedTag)
+    fail2(
+      `capability determinism disagrees with signature effect: wire '${wireTag}' vs signature '${expectedTag}'`
+    );
+  return {
+    id: strAt(o, "id"),
+    signature,
+    determinism,
+    placement: placementOf(o["placement"])
+  };
+};
+var decodeCapabilityDeclaration = (json) => {
+  try {
+    return dok2(declarationOf(json));
+  } catch (e) {
+    if (e instanceof DeclError) return derr2(e.message);
+    throw e;
+  }
+};
 
 // src/apply.ts
 var ok2 = (value) => ({ ok: true, value });
-var fail2 = (code, message, batchIndex) => ({
+var fail3 = (code, message, batchIndex) => ({
   ok: false,
   error: batchIndex === void 0 ? { code, message } : { code, message, batchIndex }
 });
@@ -8752,22 +10130,22 @@ var applyOne = (op, root, telem) => {
     case "EditNode": {
       const updatedTree = mapNode(op.target, (n) => ({ ...n, kind: op.newKind }), root);
       if (updatedTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "EditNode", targetId: op.target });
       return ok2(updatedTree);
     }
     case "UpdateProp": {
       const parsed = parsePath(op.path);
       if (!parsed.ok)
-        return fail2("PathInvalid", `Path '${op.path}' is structurally invalid: ${parsed.error}.`);
+        return fail3("PathInvalid", `Path '${op.path}' is structurally invalid: ${parsed.error}.`);
       const targetNode = findNode(op.target, root);
       if (targetNode === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const segs = parsed.value;
       const finish = (kind) => {
         const newTree = mapNode(op.target, (n) => ({ ...n, kind }), root);
         if (newTree === void 0)
-          return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+          return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
         telem.push({ op: "UpdateProp", targetId: op.target });
         return ok2(newTree);
       };
@@ -8777,14 +10155,14 @@ var applyOne = (op, root, telem) => {
           case "updated":
             return finish(outcome2.kind);
           case "unknownField":
-            return fail2("FieldNotFound", `Field '${op.path}' not found on node '${op.target}'.`);
+            return fail3("FieldNotFound", `Field '${op.path}' not found on node '${op.target}'.`);
           case "notSupported":
-            return fail2(
+            return fail3(
               "PathNotSupportedYet",
               `Path '${op.path}' on node '${op.target}' is not yet supported by the apply engine.`
             );
           case "typeMismatch":
-            return fail2(
+            return fail3(
               "KindMismatch",
               `UpdateProp value for '${op.path}' on node '${op.target}' does not match the field's expected type: ${outcome2.detail}`
             );
@@ -8796,27 +10174,27 @@ var applyOne = (op, root, telem) => {
         case "updated":
           return finish(outcome.kind);
         case "missingIndex":
-          return fail2(
+          return fail3(
             "PathInvalid",
             `Field '${outcome.listField}' on node '${op.target}' is a list \u2014 address an element with a 0-based index (the list has ${outcome.count} element(s)).`
           );
         case "indexOutOfRange":
-          return fail2(
+          return fail3(
             "PositionOutOfRange",
             `Index ${outcome.requested} is out of range for '${outcome.listField}' on node '${op.target}' (${outcome.count === 0 ? "the list is empty" : `valid: 0..${outcome.count - 1}`}).`
           );
         case "fieldNotFound":
-          return fail2(
+          return fail3(
             "FieldNotFound",
             `Field '${outcome.segment}' (in path '${op.path}') not found on node '${op.target}'. Available at this segment: ${outcome.available.join(", ")}.`
           );
         case "notSupported":
-          return fail2(
+          return fail3(
             "PathNotSupportedYet",
             `Path '${op.path}' on node '${op.target}' is not yet supported by the apply engine.`
           );
         case "typeMismatch":
-          return fail2(
+          return fail3(
             "KindMismatch",
             `UpdateProp value for '${op.path}' on node '${op.target}' does not match the field's expected type: ${outcome.detail}`
           );
@@ -8826,20 +10204,20 @@ var applyOne = (op, root, telem) => {
     case "ReplaceBinding": {
       const targetNode = findNode(op.target, root);
       if (targetNode === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const newKind = replaceBinding(op.slot, op.binding, targetNode.kind);
       if (newKind === void 0)
-        return fail2("SlotNotFound", `Binding slot '${op.slot}' not found on node '${op.target}'.`);
+        return fail3("SlotNotFound", `Binding slot '${op.slot}' not found on node '${op.target}'.`);
       const newTree = mapNode(op.target, (n) => ({ ...n, kind: newKind }), root);
       if (newTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "ReplaceBinding", targetId: op.target });
       return ok2(newTree);
     }
     case "UpdateStyle": {
       const newTree = mapNode(op.target, (n) => ({ ...n, style: op.style }), root);
       if (newTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "UpdateStyle", targetId: op.target });
       return ok2(newTree);
     }
@@ -8850,39 +10228,39 @@ var applyOne = (op, root, telem) => {
         root
       );
       if (newTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "UpdateState", targetId: op.target });
       return ok2(newTree);
     }
     case "InsertChild": {
       const parent = findNode(op.parentId, root);
       if (parent === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       const children = layoutChildren(parent);
       if (children === void 0)
-        return fail2(
+        return fail3(
           "ChildlessKind",
           `Node '${op.parentId}' (kind=${parent.kind.kind}) has no children field \u2014 only Layout kinds accept structural child ops.`
         );
       const existing = new Set(allNodeIds(root));
       const duplicate = allNodeIds(op.child).find((id) => existing.has(id));
       if (duplicate !== void 0)
-        return fail2(
+        return fail3(
           "DuplicateNodeId",
           `NodeId '${duplicate}' is already present in the tree; ids must be unique.`
         );
       const newChildren = [...children, op.child];
       const newTree = mapNode(op.parentId, (n) => withLayoutChildren(n, newChildren), root);
       if (newTree === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       telem.push({ op: "InsertChild", targetId: op.parentId });
       return ok2(newTree);
     }
     case "RemoveNode": {
-      if (idOf(root) === op.target) return fail2("KindMismatch", "Cannot RemoveNode the root.");
+      if (idOf(root) === op.target) return fail3("KindMismatch", "Cannot RemoveNode the root.");
       const parent = findLayoutParent(op.target, root);
       if (parent === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const children = layoutChildren(parent);
       const newTree = mapNode(
         idOf(parent),
@@ -8893,26 +10271,26 @@ var applyOne = (op, root, telem) => {
         root
       );
       if (newTree === void 0)
-        return fail2("ParentNotFound", `Parent node '${idOf(parent)}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${idOf(parent)}' not found in tree.`);
       telem.push({ op: "RemoveNode", targetId: op.target });
       return ok2(newTree);
     }
     case "MoveNode": {
       if (op.target === op.newParentId)
-        return fail2("KindMismatch", "Cannot move a node into itself.");
+        return fail3("KindMismatch", "Cannot move a node into itself.");
       if (isAncestor(op.target, op.newParentId, root))
-        return fail2(
+        return fail3(
           "KindMismatch",
           "Cannot move a node into its own descendant (would create a cycle)."
         );
       const moving = findNode(op.target, root);
       if (moving === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const newParent = findNode(op.newParentId, root);
       if (newParent === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.newParentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.newParentId}' not found in tree.`);
       if (layoutChildren(newParent) === void 0)
-        return fail2(
+        return fail3(
           "ChildlessKind",
           `Node '${op.newParentId}' (kind=${newParent.kind.kind}) has no children field.`
         );
@@ -8930,10 +10308,10 @@ var applyOne = (op, root, telem) => {
     case "ReorderChildren": {
       const parent = findNode(op.parentId, root);
       if (parent === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       const children = layoutChildren(parent);
       if (children === void 0)
-        return fail2(
+        return fail3(
           "ChildlessKind",
           `Node '${op.parentId}' (kind=${parent.kind.kind}) has no children field.`
         );
@@ -8941,7 +10319,7 @@ var applyOne = (op, root, telem) => {
       const sortedCurrent = [...currentIds].sort();
       const sortedNew = [...op.newOrder].map((x) => x).sort();
       if (sortedCurrent.length !== sortedNew.length || sortedCurrent.some((id, i) => id !== sortedNew[i]))
-        return fail2(
+        return fail3(
           "OrderingMismatch",
           `ReorderChildren for '${op.parentId}' did not list exactly the current child ids.`
         );
@@ -8949,7 +10327,7 @@ var applyOne = (op, root, telem) => {
       const reordered = op.newOrder.map((id) => byId.get(id)).filter((c) => c !== void 0);
       const newTree = mapNode(op.parentId, (n) => withLayoutChildren(n, reordered), root);
       if (newTree === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       telem.push({ op: "ReorderChildren", targetId: op.parentId });
       return ok2(newTree);
     }
@@ -8974,7 +10352,7 @@ var applyOne = (op, root, telem) => {
       return ok2(state);
     }
   }
-  return fail2("KindMismatch", "unreachable apply branch");
+  return fail3("KindMismatch", "unreachable apply branch");
 };
 var apply = (tree, op) => {
   const telem = [];
@@ -9158,10 +10536,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(",")}]`;
@@ -9170,7 +10550,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) => {
@@ -9193,6 +10572,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}` };
@@ -9201,12 +10594,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" };
@@ -9242,7 +10642,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
@@ -9275,11 +10675,20 @@ var isPureAddition = (baseIds, headIds) => {
   return survive.length === baseIds.length && survive.every((v, i) => v === baseIds[i]) && headKept.length === baseIds.length && headKept.every((v, i) => v === baseIds[i]);
 };
 var eqOpt = (x, y) => (x ?? null) === (y ?? null);
-var pickField = (conflicts, nodeId, facet, baseV, aV, bV) => {
+var refusal = (nodeId, facet, cls, base, aValue, bValue) => ({
+  nodeId,
+  facet,
+  class: cls,
+  base,
+  a: { value: aValue },
+  b: { value: bValue },
+  primacyHeld: false
+});
+var pickField = (conflicts, nodeId, facet, dflt, baseV, aV, bV) => {
   const aCh = !eqOpt(aV, baseV);
   const bCh = !eqOpt(bV, baseV);
   if (aCh && bCh && !eqOpt(aV, bV)) {
-    conflicts.push({ nodeId, facet });
+    conflicts.push(refusal(nodeId, facet, "ConcurrentEdit", baseV ?? dflt, aV ?? dflt, bV ?? dflt));
     return baseV;
   }
   if (aCh) return aV;
@@ -9290,7 +10699,7 @@ var pickCanonical = (conflicts, nodeId, facet, baseC, aC, bC) => {
   const aCh = aC !== baseC;
   const bCh = bC !== baseC;
   if (aCh && bCh && aC !== bC) {
-    conflicts.push({ nodeId, facet });
+    conflicts.push(refusal(nodeId, facet, "ConcurrentEdit", baseC, aC, bC));
     return 0;
   }
   if (aCh) return 1;
@@ -9301,18 +10710,28 @@ var mergeStyle = (conflicts, id, base, a, b) => {
   const bs = base.style;
   const as_ = a.style;
   const bsB = b.style;
-  const tone = pickField(conflicts, id, "style.tone", bs.tone, as_.tone, bsB.tone);
-  const weight = pickField(conflicts, id, "style.weight", bs.weight, as_.weight, bsB.weight);
+  const d = defaults.style;
+  const tone = pickField(conflicts, id, "style.tone", d.tone, bs.tone, as_.tone, bsB.tone);
+  const weight = pickField(
+    conflicts,
+    id,
+    "style.weight",
+    d.weight,
+    bs.weight,
+    as_.weight,
+    bsB.weight
+  );
   const emphasis = pickField(
     conflicts,
     id,
     "style.emphasis",
+    d.emphasis,
     bs.emphasis,
     as_.emphasis,
     bsB.emphasis
   );
-  const role = pickField(conflicts, id, "style.role", bs.role, as_.role, bsB.role);
-  const voice = pickField(conflicts, id, "style.voice", bs.voice, as_.voice, bsB.voice);
+  const role = pickField(conflicts, id, "style.role", d.role, bs.role, as_.role, bsB.role);
+  const voice = pickField(conflicts, id, "style.voice", d.voice, bs.voice, as_.voice, bsB.voice);
   const style = { tone, weight, emphasis };
   return {
     ...style,
@@ -9368,8 +10787,15 @@ var merge3 = (conflicts, base, aOpt, bOpt) => {
     const bc = baseMap.get(cid);
     if (bc !== void 0) return merge3(conflicts, bc, aMap.get(cid), bMap.get(cid));
     const ac = aMap.get(cid);
-    if (ac !== void 0) return ac;
     const bb = bMap.get(cid);
+    if (ac !== void 0 && bb !== void 0) {
+      const acC = encodeNode(ac);
+      const bcC = encodeNode(bb);
+      if (acC === bcC) return ac;
+      conflicts.push(refusal(cid, "insert", "ConcurrentEdit", "", acC, bcC));
+      return ordinal(acC, bcC) <= 0 ? ac : bb;
+    }
+    if (ac !== void 0) return ac;
     if (bb !== void 0) return bb;
     throw new Error(`merge3: child id ${cid} vanished`);
   };
@@ -9380,6 +10806,8 @@ var merge3 = (conflicts, base, aOpt, bOpt) => {
     mergedChildren = aIds.map(recurseChild);
   } else if (!aStruct && bStruct) {
     mergedChildren = bIds.map(recurseChild);
+  } else if (JSON.stringify(aIds) === JSON.stringify(bIds)) {
+    mergedChildren = aIds.map(recurseChild);
   } else {
     const baseSet = new Set(baseIds);
     const aNew = aIds.filter((i) => !baseSet.has(i));
@@ -9391,7 +10819,16 @@ var merge3 = (conflicts, base, aOpt, bOpt) => {
       const newIds = [.../* @__PURE__ */ new Set([...aNew, ...bNew])].sort(ordinal);
       mergedChildren = [...survivors, ...newIds.map(recurseChild)];
     } else {
-      conflicts.push({ nodeId: id, facet: "children" });
+      conflicts.push(
+        refusal(
+          id,
+          "children",
+          "ReorderVsStructural",
+          baseIds.join(","),
+          aIds.join(","),
+          bIds.join(",")
+        )
+      );
       mergedChildren = baseIds.map(recurseChild);
     }
   }
@@ -9403,6 +10840,21 @@ var merge3Way = (base, a, b) => {
   const merged = merge3(conflicts, base, a, b);
   return conflicts.length === 0 ? { ok: true, tree: merged } : { ok: false, conflicts };
 };
+var sortConflictsCanonical = (conflicts) => [...conflicts].sort((x, y) => ordinal(x.nodeId, y.nodeId) || ordinal(x.facet, y.facet));
+var escapeJson = (s) => {
+  let out = '"';
+  for (const ch of s) {
+    if (ch === '"') out += '\\"';
+    else if (ch === "\\") out += "\\\\";
+    else if (ch < " ") out += `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`;
+    else out += ch;
+  }
+  return out + '"';
+};
+var encodeSide = (side) => `{"tag":${side.tag === void 0 ? "null" : escapeJson(side.tag)},"value":${escapeJson(side.value)}}`;
+var encodeMergeEnvelope = (conflicts) => "[" + sortConflictsCanonical(conflicts).map(
+  (c) => `{"a":${encodeSide(c.a)},"b":${encodeSide(c.b)},"base":${escapeJson(c.base)},"class":${escapeJson(c.class)},"facet":${escapeJson(c.facet)},"nodeId":${escapeJson(c.nodeId)},"primacyHeld":${c.primacyHeld ? "true" : "false"}}`
+).join(",") + "]";
 
 // src/versioning.ts
 var renderProfile = (p) => `${p.name}@${p.major}.${p.minor}`;
@@ -10290,6 +11742,6 @@ var withStateSeeds = (tree, sources) => {
   return { ...sources, state: { ...seeds, ...sources.state ?? {} } };
 };
 
-export { ELICITATION_KEY, ELICITATION_VERSION, HOST_RESERVED_PREFIX, PAYLOAD_KEY, PROFILE_KEY, REQUIRED_PROFILE_KEY, apply, canPlace, cellString, coerce, collectStateSeeds, coreV1, decodeDagRecord, decodeElicitation, decodeElicitationOutcome, decodeEnvelope, decodeEnvelopeAst, decodeNode, decodeNodeTolerant, decodeOp, decodeTolerant, derivedFreshIds, duplicateOp, duplicateOpWith, encodeCell, encodeColExpr, encodeDagRecord, encodeDataSource, encodeElicitation, encodeElicitationOutcome, encodeEnvelope2 as encodeEnvelope, encodeNode, encodeOp, encodePipeline, evalErrorString, evalPipeline, evalPipelineInEnv, evalPipelineWith, evalPipelineWithInEnv, evalSource, field as jsonField, liveValueToTable, merge3Way, moveOp, negotiate, negotiateEnvelope, noResolve, nudgeOp, parse, pasteOp, pasteOpWith, pipelineParams, placeOp, reencodeNode, renderAstCanonical, renderProfile, sequentialFreshIds, stepParams, tryParseProfile, validateAnswer, validateAnswerAt, validateAnswerDocument, withStateSeeds };
+export { DECODED_COMPUTED_MESSAGE, ELICITATION_KEY, ELICITATION_VERSION, HOST_RESERVED_PREFIX, PAYLOAD_KEY, PROFILE_KEY, REQUIRED_PROFILE_KEY, WireSurvivabilityError, apply, canPlace, cellString, coerce, collectStateSeeds, coreV1, decodeCapabilityDeclaration, decodeDagRecord, decodeDataSource, decodeElicitation, decodeElicitationOutcome, decodeEnvelope, decodeEnvelopeAst, decodeNode, decodeNodeTolerant, decodeOp, decodeOps, decodePipelineCore as decodePipeline, decodeTolerant, derivedFreshIds, duplicateOp, duplicateOpWith, encodeCapabilityDeclaration, encodeCell, encodeColExpr, encodeDagRecord, encodeDataSource, encodeElicitation, encodeElicitationOutcome, encodeEnvelope2 as encodeEnvelope, encodeMergeEnvelope, encodeNode, encodeOp, encodePipeline, evalErrorString, evalPipeline, evalPipelineInEnv, evalPipelineWith, evalPipelineWithInEnv, evalSource, fixedText, identityFormat, field as jsonField, liveValueToTable, merge3Way, moveOp, negotiate, negotiateEnvelope, noResolve, nudgeOp, numberText, parse, pasteOp, pasteOpWith, pipelineParams, placeOp, reencodeNode, renderAstCanonical, renderProfile, scalarOfText, sequentialFreshIds, sortConflictsCanonical, stepParams, substituteListParams, tryNumberText, tryParseProfile, validateAnswer, validateAnswerAt, validateAnswerDocument, withStateSeeds };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map