@fuaran-ui/ops 0.19.0 → 0.22.0

package/dist/index.cjs

@@ -386,9 +386,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) {
@@ -400,14 +403,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)],
@@ -437,6 +444,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)],
@@ -466,8 +489,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)]);
@@ -484,7 +510,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)],
@@ -559,6 +596,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);
   }
@@ -693,6 +734,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([
@@ -905,6 +982,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":
@@ -992,6 +1073,40 @@ var formFieldKind = (autoBind, k) => {
         ["orientation", str(k.orientation)],
         ...valueField(k.value, schema.controlValueDefaults.choice, (v) => binding(v, staticStringOpt))
       ]);
+    case "Combobox": {
+      const fields = [];
+      if (k.allowFreeText) fields.push(["allowFreeText", bool(true)]);
+      fields.push(...handlerField("onChange", k.onChange));
+      fields.push(["options", binding(k.options, staticSelectOptions)]);
+      fields.push(
+        ...valueField(k.value, schema.controlValueDefaults.choice, (v) => binding(v, staticStringOpt))
+      );
+      return caseObj("Combobox", fields);
+    }
+    case "Tokens": {
+      const fields = [];
+      if (!k.allowFreeText) fields.push(["allowFreeText", bool(false)]);
+      fields.push(...handlerField("onChange", k.onChange));
+      if (k.suggestions !== void 0)
+        fields.push(["suggestions", binding(k.suggestions, staticSelectOptions)]);
+      fields.push(
+        ...valueField(k.value, schema.controlValueDefaults.tokens, (v) => binding(v, staticStringList))
+      );
+      return caseObj("Tokens", fields);
+    }
+    case "Rating": {
+      const fields = [];
+      if (k.allowHalf) fields.push(["allowHalf", bool(true)]);
+      fields.push(["max", num(k.max)]);
+      fields.push(...handlerField("onChange", k.onChange));
+      fields.push(...valueField(k.value, schema.controlValueDefaults.number, (v) => binding(v)));
+      return caseObj("Rating", fields);
+    }
+    case "Color":
+      return caseObj("Color", [
+        ...handlerField("onChange", k.onChange),
+        ...valueField(k.value, schema.controlValueDefaults.color, (v) => binding(v))
+      ]);
     case "TextArea":
       return caseObj("TextArea", [
         ...handlerField("onChange", k.onChange),
@@ -1108,6 +1223,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) => {
@@ -1245,6 +1364,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 = [
@@ -1258,6 +1382,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)],
@@ -1275,6 +1418,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);
 };
@@ -1338,6 +1483,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([
@@ -1392,6 +1539,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) => {
@@ -1547,13 +1696,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)]] : []
               ])
             )
           )
@@ -1621,6 +1777,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) => {
@@ -1634,7 +1792,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)],
@@ -1643,6 +1803,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) => {
@@ -2739,6 +2901,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;
@@ -2769,51 +3035,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 > schema.MAX_STRING_LENGTH) {
+      return {
+        message: `string is longer than the wire limit MAX_STRING_LENGTH = ${schema.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 > schema.MAX_STRING_LENGTH) {
-      return failLimit(
-        s,
-        `string is longer than the wire limit MAX_STRING_LENGTH = ${schema.MAX_STRING_LENGTH}`
-      );
-    }
     if (c === "\\") {
       if (s.pos >= s.text.length) return fail(s, "unterminated escape");
       const esc = s.text[s.pos];
       advance(s);
+      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");
@@ -2822,26 +3131,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)) {
@@ -2928,6 +3269,10 @@ var parseObjectValue = (s) => {
         `object has more members than the wire limit MAX_ARRAY_LENGTH = ${schema.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);
@@ -2987,13 +3332,52 @@ var parseArrayValue = (s) => {
     }
   }
 };
+var documentBytes = (input) => {
+  if (input.length > schema.MAX_DOCUMENT_BYTES) return input.length;
+  if (input.length <= schema.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 > schema.MAX_DOCUMENT_BYTES) {
+    return {
+      ok: false,
+      error: {
+        message: `document of ${bytes} UTF-8 bytes exceeds the wire limit MAX_DOCUMENT_BYTES = ${schema.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);
 
@@ -3038,9 +3422,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);
@@ -3198,6 +3604,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,
@@ -3205,7 +3613,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 = {
@@ -3266,6 +3683,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)");
@@ -3280,6 +3840,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;
@@ -3379,11 +3940,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"
       );
   }
 };
@@ -3537,7 +4104,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) {
@@ -3568,7 +4141,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":
@@ -4271,6 +4844,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 > schema.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 > schema.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);
@@ -4361,23 +5065,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;
@@ -4392,6 +5104,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,
@@ -4403,15 +5146,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": {
@@ -4483,52 +5246,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,
@@ -4537,6 +5257,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 ${schema.MAX_EXPR_NODES} expression nodes (WIRE_FORMAT 21)`,
+          `at most ${schema.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;
@@ -4820,7 +5581,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);
@@ -4880,10 +5641,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);
@@ -4940,9 +5705,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;
@@ -4967,7 +5787,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"
       );
   }
 };
@@ -5248,12 +6068,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 >= schema.MAX_NODE_DEPTH) {
+    return limitError(
+      path,
+      `tree-item nesting deeper than the wire limit MAX_NODE_DEPTH = ${schema.MAX_NODE_DEPTH}`,
+      `a tree nesting items no more than ${schema.MAX_NODE_DEPTH} levels deep`
+    );
+  }
+  itemDepth += 1;
+  const r = decodeTreeItemInner(path, j);
+  itemDepth -= 1;
+  return r;
+};
+var decodeTreeItemInner = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const id = reqField(path, f, "id", "TreeItem id string", requireString);
+  if (!id.ok) return id;
+  const label = reqField(path, f, "label", "TreeItem label TextSource", decodeTextSource);
+  if (!label.ok) return label;
+  const childrenJ = tryField(f, "children");
+  const children = childrenJ === void 0 ? ok([]) : (() => {
+    const carr = requireArray(`${path}.children`, childrenJ);
+    if (!carr.ok) return carr;
+    return traverseIndexed(
+      carr.value,
+      (i, el) => decodeTreeItem(`${path}.children[${i}]`, el)
+    );
+  })();
+  if (!children.ok) return children;
+  const icon = optField(path, f, "icon", requireString);
+  if (!icon.ok) return icon;
+  return ok({
+    id: id.value,
+    label: label.value,
+    children: children.value,
+    ...icon.value !== void 0 ? { icon: icon.value } : {}
+  });
+};
+var decodeEmbedSpec = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const src = reqField(path, f, "src", "Embed Binding<string> Src", decodeBindingString);
+  if (!src.ok) return src;
+  const title = reqField(path, f, "title", "Embed accessible title TextSource", decodeTextSource);
+  if (!title.ok) return title;
+  const aspectJ = tryField(f, "aspectRatio");
+  const aspectRatio = aspectJ === void 0 ? ok("Natural") : decodeImageAspect(`${path}.aspectRatio`, aspectJ);
+  if (!aspectRatio.ok) return aspectRatio;
+  const permissionsJ = tryField(f, "permissions");
+  const permissions = permissionsJ === void 0 ? ok([]) : (() => {
+    const arr = requireArray(`${path}.permissions`, permissionsJ);
+    if (!arr.ok) return arr;
+    return traverseIndexed(
+      arr.value,
+      (i, el) => decodeEmbedPermission(`${path}.permissions[${i}]`, el)
+    );
+  })();
+  if (!permissions.ok) return permissions;
+  return ok({
+    src: src.value,
+    title: title.value,
+    aspectRatio: aspectRatio.value,
+    permissions: permissions.value
   });
 };
 var decodeListSpec = (path, j) => {
@@ -5729,10 +6676,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;
@@ -5757,7 +6712,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"
       );
   }
 };
@@ -5888,6 +6843,95 @@ var decodeFormFieldKind = (autoBind, path, j) => {
         orientation: orientation.value
       });
     }
+    case "Combobox": {
+      const options = reqField(
+        path,
+        f,
+        "options",
+        "Combobox options binding",
+        decodeBindingSelectOptions
+      );
+      if (!options.ok) return options;
+      const allowFreeTextJ = tryField(f, "allowFreeText");
+      const allowFreeText = allowFreeTextJ === void 0 ? ok(false) : requireBool(`${path}.allowFreeText`, allowFreeTextJ);
+      if (!allowFreeText.ok) return allowFreeText;
+      const value = valueOr(
+        decodeBindingStringOpt,
+        schema.controlValueDefaults.choice,
+        "Combobox value binding"
+      );
+      if (!value.ok) return value;
+      return ok({
+        kind: "Combobox",
+        allowFreeText: allowFreeText.value,
+        options: options.value,
+        value: value.value,
+        ...onChangeField
+      });
+    }
+    case "Tokens": {
+      const allowFreeTextJ = tryField(f, "allowFreeText");
+      const allowFreeText = allowFreeTextJ === void 0 ? ok(true) : requireBool(`${path}.allowFreeText`, allowFreeTextJ);
+      if (!allowFreeText.ok) return allowFreeText;
+      const suggestions = optField(path, f, "suggestions", decodeBindingSelectOptions);
+      if (!suggestions.ok) return suggestions;
+      if (!allowFreeText.value && suggestions.value === void 0)
+        return wrongType(
+          `${path}.allowFreeText`,
+          "a suggestion source alongside allowFreeText:false \u2014 a closed token field with nothing to pick from admits no token at all (WIRE_FORMAT.md \xA73.6.19)"
+        );
+      const value = valueOr(
+        decodeBindingStringList,
+        schema.controlValueDefaults.tokens,
+        "Tokens Binding<string list> value"
+      );
+      if (!value.ok) return value;
+      return ok({
+        kind: "Tokens",
+        allowFreeText: allowFreeText.value,
+        value: value.value,
+        ...suggestions.value !== void 0 ? { suggestions: suggestions.value } : {},
+        ...onChangeField
+      });
+    }
+    case "Rating": {
+      const maxJ = requireField(path, f, "max", "Rating max integer of 1 or more");
+      if (!maxJ.ok) return maxJ;
+      if (maxJ.value.kind !== "JNumber" || maxJ.value.value < 1 || !Number.isInteger(maxJ.value.value))
+        return wrongType(`${path}.max`, "JSON number (an integer scale of 1 or more)");
+      const max = maxJ.value.value;
+      const allowHalfJ = tryField(f, "allowHalf");
+      const allowHalf = allowHalfJ === void 0 ? ok(false) : requireBool(`${path}.allowHalf`, allowHalfJ);
+      if (!allowHalf.ok) return allowHalf;
+      const value = valueOr(
+        decodeBindingFloat,
+        schema.controlValueDefaults.number,
+        "Rating value binding"
+      );
+      if (!value.ok) return value;
+      return ok({
+        kind: "Rating",
+        max,
+        allowHalf: allowHalf.value,
+        value: value.value,
+        ...onChangeField
+      });
+    }
+    case "Color": {
+      const value = valueOr(
+        decodeBinding,
+        schema.controlValueDefaults.color,
+        "Color value binding"
+      );
+      if (!value.ok) return value;
+      const bound = value.value;
+      if (bound.kind === "Static" && !(typeof bound.value === "string" && /^#[0-9a-fA-F]{6}$/.test(bound.value)))
+        return wrongType(
+          `${path}.value`,
+          "a #rrggbb colour literal \u2014 six hexadecimal digits after a #, the one form a native colour input can hold (WIRE_FORMAT.md \xA73.6.17)"
+        );
+      return ok({ kind: "Color", value: value.value, ...onChangeField });
+    }
     case "TextArea": {
       const rows = reqField(path, f, "rows", "textarea row count integer", requireInt);
       if (!rows.ok) return rows;
@@ -6184,12 +7228,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) => {
@@ -6607,6 +7670,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) {
@@ -6627,6 +7700,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 } : {}
   });
 };
@@ -6672,6 +7750,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;
@@ -6689,6 +7779,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 } : {}
   });
 };
@@ -6839,11 +7930,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) => {
@@ -6990,12 +8087,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) => {
@@ -7282,6 +8386,8 @@ var decodeNodeKind = (path, j) => {
     case "Link":
     case "Image":
     case "Media":
+    case "Embed":
+    case "Tree":
     case "List":
     case "Toast":
     case "CodeBlock":
@@ -7372,18 +8478,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": {
@@ -7549,12 +8688,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 = [
@@ -7652,11 +8794,13 @@ var placeholderClosureNode = {
 var walkDepth = 0;
 var walkNodes = 0;
 var opDepth = 0;
+var itemDepth = 0;
 var walkPolicy = schema.admitAll;
 var resetWalk = (policy = schema.admitAll) => {
   walkDepth = 0;
   walkNodes = 0;
   opDepth = 0;
+  itemDepth = 0;
   walkPolicy = policy;
 };
 var limitError = (path, message, expected) => makeError("LIMIT_EXCEEDED", path, message, expected);
@@ -7700,12 +8844,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) => {
@@ -7914,10 +9064,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 }
 });
@@ -8754,22 +10132,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);
       };
@@ -8779,14 +10157,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}`
             );
@@ -8798,27 +10176,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}`
           );
@@ -8828,20 +10206,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);
     }
@@ -8852,39 +10230,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),
@@ -8895,26 +10273,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.`
         );
@@ -8932,10 +10310,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.`
         );
@@ -8943,7 +10321,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.`
         );
@@ -8951,7 +10329,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);
     }
@@ -8976,7 +10354,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 = [];
@@ -9160,10 +10538,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(",")}]`;
@@ -9172,7 +10552,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) => {
@@ -9195,6 +10574,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}` };
@@ -9203,12 +10596,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" };
@@ -9244,7 +10644,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
@@ -9277,11 +10677,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;
@@ -9292,7 +10701,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;
@@ -9303,18 +10712,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 = schema.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,
@@ -9370,8 +10789,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`);
   };
@@ -9382,6 +10808,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));
@@ -9393,7 +10821,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);
     }
   }
@@ -9405,6 +10842,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}`;
@@ -10292,19 +11744,23 @@ var withStateSeeds = (tree, sources) => {
   return { ...sources, state: { ...seeds, ...sources.state ?? {} } };
 };
 
+exports.DECODED_COMPUTED_MESSAGE = DECODED_COMPUTED_MESSAGE;
 exports.ELICITATION_KEY = ELICITATION_KEY;
 exports.ELICITATION_VERSION = ELICITATION_VERSION;
 exports.HOST_RESERVED_PREFIX = HOST_RESERVED_PREFIX;
 exports.PAYLOAD_KEY = PAYLOAD_KEY;
 exports.PROFILE_KEY = PROFILE_KEY;
 exports.REQUIRED_PROFILE_KEY = REQUIRED_PROFILE_KEY;
+exports.WireSurvivabilityError = WireSurvivabilityError;
 exports.apply = apply;
 exports.canPlace = canPlace;
 exports.cellString = cellString;
 exports.coerce = coerce;
 exports.collectStateSeeds = collectStateSeeds;
 exports.coreV1 = coreV1;
+exports.decodeCapabilityDeclaration = decodeCapabilityDeclaration;
 exports.decodeDagRecord = decodeDagRecord;
+exports.decodeDataSource = decodeDataSource;
 exports.decodeElicitation = decodeElicitation;
 exports.decodeElicitationOutcome = decodeElicitationOutcome;
 exports.decodeEnvelope = decodeEnvelope;
@@ -10312,10 +11768,13 @@ exports.decodeEnvelopeAst = decodeEnvelopeAst;
 exports.decodeNode = decodeNode;
 exports.decodeNodeTolerant = decodeNodeTolerant;
 exports.decodeOp = decodeOp;
+exports.decodeOps = decodeOps;
+exports.decodePipeline = decodePipelineCore;
 exports.decodeTolerant = decodeTolerant;
 exports.derivedFreshIds = derivedFreshIds;
 exports.duplicateOp = duplicateOp;
 exports.duplicateOpWith = duplicateOpWith;
+exports.encodeCapabilityDeclaration = encodeCapabilityDeclaration;
 exports.encodeCell = encodeCell;
 exports.encodeColExpr = encodeColExpr;
 exports.encodeDagRecord = encodeDagRecord;
@@ -10323,6 +11782,7 @@ exports.encodeDataSource = encodeDataSource;
 exports.encodeElicitation = encodeElicitation;
 exports.encodeElicitationOutcome = encodeElicitationOutcome;
 exports.encodeEnvelope = encodeEnvelope2;
+exports.encodeMergeEnvelope = encodeMergeEnvelope;
 exports.encodeNode = encodeNode;
 exports.encodeOp = encodeOp;
 exports.encodePipeline = encodePipeline;
@@ -10332,6 +11792,8 @@ exports.evalPipelineInEnv = evalPipelineInEnv;
 exports.evalPipelineWith = evalPipelineWith;
 exports.evalPipelineWithInEnv = evalPipelineWithInEnv;
 exports.evalSource = evalSource;
+exports.fixedText = fixedText;
+exports.identityFormat = identityFormat;
 exports.jsonField = field;
 exports.liveValueToTable = liveValueToTable;
 exports.merge3Way = merge3Way;
@@ -10340,6 +11802,7 @@ exports.negotiate = negotiate;
 exports.negotiateEnvelope = negotiateEnvelope;
 exports.noResolve = noResolve;
 exports.nudgeOp = nudgeOp;
+exports.numberText = numberText;
 exports.parse = parse;
 exports.pasteOp = pasteOp;
 exports.pasteOpWith = pasteOpWith;
@@ -10348,8 +11811,12 @@ exports.placeOp = placeOp;
 exports.reencodeNode = reencodeNode;
 exports.renderAstCanonical = renderAstCanonical;
 exports.renderProfile = renderProfile;
+exports.scalarOfText = scalarOfText;
 exports.sequentialFreshIds = sequentialFreshIds;
+exports.sortConflictsCanonical = sortConflictsCanonical;
 exports.stepParams = stepParams;
+exports.substituteListParams = substituteListParams;
+exports.tryNumberText = tryNumberText;
 exports.tryParseProfile = tryParseProfile;
 exports.validateAnswer = validateAnswer;
 exports.validateAnswerAt = validateAnswerAt;