@fuaran-ui/ops 0.21.0 → 0.23.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { FORM_FIELD_KIND_NAMES, NODE_KIND_GROUPS, defaults, controlValueDefaults, MAX_NODE_DEPTH, MAX_NODES, MAX_STRING_LENGTH, MAX_JSON_DEPTH, MAX_ARRAY_LENGTH, narrows, admitAll, NODE_KIND_NAMES, admits, policyHint, projectSelectionField } from '@fuaran-ui/schema';
+import { FORM_FIELD_KIND_NAMES, NODE_KIND_GROUPS, defaults, controlValueDefaults, MAX_DOCUMENT_BYTES, MAX_NODE_DEPTH, MAX_NODES, MAX_JSON_DEPTH, MAX_ARRAY_LENGTH, MAX_STRING_LENGTH, narrows, admitAll, NODE_KIND_NAMES, admits, policyHint, MAX_EXPR_NODES, projectSelectionField } from '@fuaran-ui/schema';
 
 // src/encode.ts
 var assertNever = (x) => {
@@ -384,9 +384,12 @@ var binding = (b, staticEnc = objValue) => {
     }
     case "Computed":
       return caseObj("Computed", [["fn", CLOSURE]]);
-    // No wire fields: the instant is host-furnished at resolve time.
+    // Phase 765 — the INSTANT is never on the wire: it is host-furnished at
+    // resolve time. Phase 1533 — the declared GRAIN is, and only when it is not
+    // the `Second` default, so a grain-less `Now` is the same bytes it has
+    // always been.
     case "Now":
-      return caseObj("Now", []);
+      return caseObj("Now", b.grain !== void 0 ? [["grain", str(b.grain)]] : []);
     case "I18n": {
       const fields = [];
       if (b.args !== void 0) {
@@ -398,14 +401,18 @@ var binding = (b, staticEnc = objValue) => {
       fields.push(["key", str(b.key)]);
       return caseObj("I18n", fields);
     }
-    case "Local":
-      return caseObj("Local", [
+    case "Local": {
+      const localFields = [
         ["flushOn", flushTrigger(b.local.flushOn)],
         ["format", CLOSURE],
         ["initialFrom", binding(b.local.initialFrom, staticEnc)],
-        ["onCommit", CLOSURE],
         ["parse", CLOSURE]
-      ]);
+      ];
+      if (b.local.codec !== void 0) localFields.push(["codec", formatIntent(b.local.codec)]);
+      if (b.local.commitTo !== void 0) localFields.push(["commitTo", str(b.local.commitTo)]);
+      if (b.local.onCommit !== void 0) localFields.push(["onCommit", CLOSURE]);
+      return caseObj("Local", localFields);
+    }
     case "Format":
       return caseObj("Format", [
         ["format", formatIntent(b.format)],
@@ -435,6 +442,22 @@ var binding = (b, staticEnc = objValue) => {
         ]
       ]);
     }
+    case "Expr": {
+      const exprParams = b.params !== void 0 && b.params.length > 0 ? [
+        [
+          "params",
+          jArray(
+            b.params.map(
+              (p) => jObject([
+                ["from", binding(p.from)],
+                ["name", str(p.name)]
+              ])
+            )
+          )
+        ]
+      ] : [];
+      return caseObj("Expr", [["expr", colExpr(b.expr)], ...exprParams]);
+    }
     case "Invoke":
       return caseObj("Invoke", [
         ["args", invokeArgs(b.args)],
@@ -464,8 +487,11 @@ var action = (a) => {
         ["channel", str(a.channel)],
         ["payload", jsonValue(a.payload)]
       ]);
-    case "Navigate":
-      return caseObj("Navigate", [["route", str(a.route)]]);
+    case "Navigate": {
+      const fields = [["route", textSource(a.route)]];
+      if (a.target !== "Self") fields.push(["target", str(a.target)]);
+      return caseObj("Navigate", fields);
+    }
     case "SetState": {
       const fields = [["key", str(a.key)]];
       if (a.value !== void 0) fields.push(["value", jsonValue(a.value)]);
@@ -485,6 +511,15 @@ var action = (a) => {
       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 +594,10 @@ var formatIntent = (f) => {
         ["style", str(f.style)],
         ["unit", str(f.unit)]
       ]);
+    // Phase 1533 — `unit` omitted when absent: its absence is the
+    // auto-selection request, not a default that could be spelled out.
+    case "Since":
+      return caseObj("Since", f.unit !== void 0 ? [["unit", str(f.unit)]] : []);
     default:
       return assertNever(f);
   }
@@ -1341,15 +1380,34 @@ 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)],
     // fuaran#665 — rows are a typed Static payload now, not the opaque residual.
     ["source", binding(s.source, staticRowSeq)],
-    ["stacked", bool(s.stacked)],
     ["xField", str(s.xField)],
     ["yFields", jArray(s.yFields.map(str))]
   ];
+  if (s.stacked) fields.push(["stacked", bool(s.stacked)]);
   if (s.title !== void 0) fields.push(["title", textSource(s.title)]);
   if (s.valueFormat !== void 0) fields.push(["valueFormat", formatIntent(s.valueFormat)]);
   if (s.xTitle !== void 0) fields.push(["xTitle", textSource(s.xTitle)]);
@@ -1358,6 +1416,8 @@ var chartSpec = (s) => {
   if (s.legendPosition !== void 0) fields.push(["legendPosition", str(s.legendPosition)]);
   if (s.dataLabels !== void 0) fields.push(["dataLabels", str(s.dataLabels)]);
   if (s.xScale !== void 0) fields.push(["xScale", str(s.xScale)]);
+  if (s.annotations !== void 0)
+    fields.push(["annotations", jArray(s.annotations.map(chartAnnotation))]);
   if (s.onPointClick !== void 0) fields.push(["onPointClick", CLOSURE]);
   return jObject(fields);
 };
@@ -1640,10 +1700,14 @@ var nodeKind = (k) => {
         [
           "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)]] : []
               ])
             )
           )
@@ -1738,6 +1802,7 @@ var node = (n) => {
   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) => {
@@ -2893,6 +2958,51 @@ var substituteListParams = (listEnv, pipeline) => pipeline.map((t) => {
       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;
@@ -2923,51 +3033,94 @@ var expectChar = (s, ch) => {
   return fail(s, `expected '${ch}' but found '${peek(s)}'`);
 };
 var HEX_DIGIT = /[0-9a-fA-F]/;
+var HIGH_SURROGATE_FIRST = 55296;
+var HIGH_SURROGATE_LAST = 56319;
+var LOW_SURROGATE_FIRST = 56320;
+var LOW_SURROGATE_LAST = 57343;
 var parseStringRaw = (s) => {
   const open = expectChar(s, '"');
   if (!open.ok) return open;
   let out = "";
+  let codePoints = 0;
+  let pendingHigh = false;
+  const append = (unit) => {
+    const code = unit.charCodeAt(0);
+    const isHigh = code >= HIGH_SURROGATE_FIRST && code <= HIGH_SURROGATE_LAST;
+    const isLow = code >= LOW_SURROGATE_FIRST && code <= LOW_SURROGATE_LAST;
+    if (isHigh) {
+      if (pendingHigh) {
+        return {
+          message: "unpaired high surrogate: it must be followed by a low surrogate",
+          offset: s.pos
+        };
+      }
+      pendingHigh = true;
+      codePoints += 1;
+    } else if (isLow) {
+      if (!pendingHigh) {
+        return {
+          message: "unpaired low surrogate: it must be preceded by a high surrogate",
+          offset: s.pos
+        };
+      }
+      pendingHigh = false;
+    } else if (pendingHigh) {
+      return {
+        message: "unpaired high surrogate: it must be followed by a low surrogate",
+        offset: s.pos
+      };
+    } else {
+      codePoints += 1;
+    }
+    if (codePoints > MAX_STRING_LENGTH) {
+      return {
+        message: `string is longer than the wire limit MAX_STRING_LENGTH = ${MAX_STRING_LENGTH}`,
+        offset: s.pos,
+        limit: true
+      };
+    }
+    out += unit;
+    return void 0;
+  };
   for (; ; ) {
     if (s.pos >= s.text.length) return fail(s, "unterminated string");
     const c = s.text[s.pos];
     advance(s);
     if (c === '"') {
+      if (pendingHigh) {
+        return fail(s, "unpaired high surrogate at the end of a string");
+      }
       return { ok: true, value: out };
     }
-    if (out.length > MAX_STRING_LENGTH) {
-      return failLimit(
-        s,
-        `string is longer than the wire limit MAX_STRING_LENGTH = ${MAX_STRING_LENGTH}`
-      );
-    }
     if (c === "\\") {
       if (s.pos >= s.text.length) return fail(s, "unterminated escape");
       const esc = s.text[s.pos];
       advance(s);
+      let unit;
       switch (esc) {
         case '"':
-          out += '"';
+          unit = '"';
           break;
         case "\\":
-          out += "\\";
+          unit = "\\";
           break;
         case "/":
-          out += "/";
+          unit = "/";
           break;
         case "b":
-          out += "\b";
+          unit = "\b";
           break;
         case "f":
-          out += "\f";
+          unit = "\f";
           break;
         case "n":
-          out += "\n";
+          unit = "\n";
           break;
         case "r":
-          out += "\r";
+          unit = "\r";
           break;
         case "t":
-          out += "	";
+          unit = "	";
           break;
         case "u": {
           if (s.pos + 4 > s.text.length) return fail(s, "incomplete \\u escape");
@@ -2976,26 +3129,58 @@ var parseStringRaw = (s) => {
             return fail(s, `invalid \\u escape '${hex}'`);
           }
           s.pos += 4;
-          out += String.fromCharCode(parseInt(hex, 16));
+          unit = String.fromCharCode(parseInt(hex, 16));
           break;
         }
         default:
           return fail(s, `unknown escape '\\${esc}'`);
       }
+      const bad = append(unit);
+      if (bad) return { ok: false, error: bad };
+    } else if (c.charCodeAt(0) < 32) {
+      return fail(
+        s,
+        `raw control character U+${c.charCodeAt(0).toString(16).padStart(4, "0").toUpperCase()} in a string must be escaped`
+      );
     } else {
-      out += c;
+      const bad = append(c);
+      if (bad) return { ok: false, error: bad };
     }
   }
 };
 var isNumberChar = (c) => c === "-" || c === "+" || c === "." || c === "e" || c === "E" || c >= "0" && c <= "9";
+var isRfc8259Number = (slice) => {
+  const n = slice.length;
+  let i = 0;
+  const digit = (k) => k < n && slice[k] >= "0" && slice[k] <= "9";
+  if (i < n && slice[i] === "-") i += 1;
+  if (!digit(i)) return false;
+  if (slice[i] === "0") {
+    i += 1;
+  } else {
+    while (digit(i)) i += 1;
+  }
+  if (i < n && slice[i] === ".") {
+    i += 1;
+    if (!digit(i)) return false;
+    while (digit(i)) i += 1;
+  }
+  if (i < n && (slice[i] === "e" || slice[i] === "E")) {
+    i += 1;
+    if (i < n && (slice[i] === "+" || slice[i] === "-")) i += 1;
+    if (!digit(i)) return false;
+    while (digit(i)) i += 1;
+  }
+  return i === n;
+};
 var parseNumberRaw = (s) => {
   const start = s.pos;
   while (s.pos < s.text.length && isNumberChar(s.text[s.pos])) {
     advance(s);
   }
   const slice = s.text.substring(start, s.pos);
-  if (slice.length === 0) {
-    return fail(s, `invalid number '${slice}'`);
+  if (!isRfc8259Number(slice)) {
+    return fail(s, `'${slice}' is not a JSON number (RFC 8259 grammar)`);
   }
   const n = Number(slice);
   if (Number.isNaN(n)) {
@@ -3082,6 +3267,10 @@ var parseObjectValue = (s) => {
         `object has more members than the wire limit MAX_ARRAY_LENGTH = ${MAX_ARRAY_LENGTH}`
       );
     }
+    if (fields.has(keyR.value)) {
+      s.depth -= 1;
+      return fail(s, `duplicate object member '${keyR.value}'`);
+    }
     fields.set(keyR.value, valR.value);
     skipWs(s);
     const c = peek(s);
@@ -3141,13 +3330,52 @@ var parseArrayValue = (s) => {
     }
   }
 };
+var documentBytes = (input) => {
+  if (input.length > MAX_DOCUMENT_BYTES) return input.length;
+  if (input.length <= MAX_DOCUMENT_BYTES / 3) return input.length;
+  let total = 0;
+  for (let i = 0; i < input.length; i += 1) {
+    const c = input.charCodeAt(i);
+    if (c < 128) {
+      total += 1;
+    } else if (c < 2048) {
+      total += 2;
+    } else if (c >= HIGH_SURROGATE_FIRST && c <= HIGH_SURROGATE_LAST && i + 1 < input.length) {
+      total += 4;
+      i += 1;
+    } else {
+      total += 3;
+    }
+  }
+  return total;
+};
 var parse = (input) => {
+  const bytes = documentBytes(input);
+  if (bytes > MAX_DOCUMENT_BYTES) {
+    return {
+      ok: false,
+      error: {
+        message: `document of ${bytes} UTF-8 bytes exceeds the wire limit MAX_DOCUMENT_BYTES = ${MAX_DOCUMENT_BYTES}`,
+        offset: 0,
+        limit: true
+      }
+    };
+  }
   const s = { text: input, pos: 0, depth: 0 };
   skipWs(s);
   if (s.pos >= s.text.length) {
     return { ok: false, error: { message: "input is empty", offset: 0 } };
   }
-  return parseValue(s);
+  const value = parseValue(s);
+  if (!value.ok) return value;
+  skipWs(s);
+  if (s.pos < s.text.length) {
+    return fail(
+      s,
+      `unexpected content after the root value ('${s.text[s.pos]}'); a wire artefact is a single JSON document`
+    );
+  }
+  return value;
 };
 var field = (fields, key) => fields.get(key);
 
@@ -3192,9 +3420,31 @@ var requireFloat = (path, jRaw) => {
   }
   return wrongType(path, "JSON number (or 'NaN' / 'Infinity' / '-Infinity' sentinel string)");
 };
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+var isInt32Slot = (n) => Number.isFinite(n) && Number.isInteger(n) && n >= INT32_MIN && n <= INT32_MAX;
 var requireInt = (path, jRaw) => {
   const j = unwrapStaticEnvelope(jRaw);
-  return j.kind === "JNumber" ? ok(Math.trunc(j.value)) : wrongType(path, "JSON number (integer)");
+  if (j.kind !== "JNumber") return wrongType(path, "JSON number (integer)");
+  if (!Number.isFinite(j.value)) {
+    return wrongType(
+      path,
+      "JSON number (a finite 32-bit integer; the non-finite sentinels are a float slot's, not an integer slot's)"
+    );
+  }
+  if (!Number.isInteger(j.value)) {
+    return wrongType(
+      path,
+      "JSON number (a 32-bit integer; a fractional value is not truncated at an integer slot)"
+    );
+  }
+  if (!isInt32Slot(j.value)) {
+    return wrongType(
+      path,
+      "JSON number (a 32-bit integer; the value is outside the range this slot can hold)"
+    );
+  }
+  return ok(j.value);
 };
 var requireArray = (path, j) => j.kind === "JArray" ? ok(j.items) : wrongType(path, "JSON array");
 var tryField = (fields, key) => fields.get(key);
@@ -3353,6 +3603,7 @@ 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,
@@ -3430,6 +3681,149 @@ var decodeChartKind = (p, j) => bareEnum(p, j, ["Line", "Bar", "Area", "Pie", "S
 var decodeChartLegendPosition = (p, j) => bareEnum(p, j, ["Top", "Right", "Bottom", "None"], "ChartLegendPosition");
 var decodeChartDataLabels = (p, j) => bareEnum(p, j, ["Off", "Ends"], "ChartDataLabels");
 var decodeChartXScale = (p, j) => bareEnum(p, j, ["Category", "Temporal"], "ChartXScale");
+var annotationIsLeapYear = (y) => y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+var annotationDaysInMonth = (y, m) => m === 2 ? annotationIsLeapYear(y) ? 29 : 28 : m === 4 || m === 6 || m === 9 || m === 11 ? 30 : 31;
+var isCanonicalIsoDay = (text) => {
+  if (text.length < 10) return false;
+  if (text[4] !== "-" || text[7] !== "-") return false;
+  if (text.length > 10 && text[10] !== "T") return false;
+  const digits = (start, len) => {
+    let acc = 0;
+    for (let k = start; k < start + len; k += 1) {
+      const c = text.charCodeAt(k);
+      if (c < 48 || c > 57) return void 0;
+      acc = acc * 10 + (c - 48);
+    }
+    return acc;
+  };
+  const y = digits(0, 4);
+  const m = digits(5, 2);
+  const d = digits(8, 2);
+  if (y === void 0 || m === void 0 || d === void 0) return false;
+  return m >= 1 && m <= 12 && d >= 1 && d <= annotationDaysInMonth(y, m);
+};
+var decodeChartAnnotationX = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const disc = requireDiscriminator(path, f);
+  if (!disc.ok) return disc;
+  switch (disc.value) {
+    case "Category": {
+      const key = reqField(path, f, "key", "category key (the band's own label)", requireString);
+      if (!key.ok) return key;
+      return ok({ kind: "Category", key: key.value });
+    }
+    case "Date": {
+      const iso = reqField(path, f, "iso", "ISO-8601 date (YYYY-MM-DD)", requireString);
+      if (!iso.ok) return iso;
+      if (!isCanonicalIsoDay(iso.value))
+        return wrongType(
+          `${path}.iso`,
+          "a canonical ISO-8601 date (YYYY-MM-DD, optionally followed by a time) naming a real calendar day \u2014 an event marker\u2019s date is the address it is drawn at, and an unreadable one would place the marker at 1970-01-01 and drag the axis back with it"
+        );
+      return ok({ kind: "Date", iso: iso.value });
+    }
+    default:
+      return unknownDuCase(path, disc.value, "Category, Date");
+  }
+};
+var decodeChartAnnotationRange = (path, j) => {
+  const finite = (slot, v) => {
+    const r = requireFloat(`${path}.${slot}`, v);
+    if (!r.ok) return r;
+    return Number.isFinite(r.value) ? r : wrongType(
+      `${path}.${slot}`,
+      "a FINITE JSON number \u2014 a range band's end names a place on the value axis, and NaN / Infinity names none; give the value in the axis's own units, or drop the annotation"
+    );
+  };
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const disc = requireDiscriminator(path, f);
+  if (!disc.ok) return disc;
+  switch (disc.value) {
+    case "ValueRange": {
+      const fromJ = requireField(path, f, "from", "range-band lower value (a finite JSON number)");
+      if (!fromJ.ok) return fromJ;
+      const from = finite("from", fromJ.value);
+      if (!from.ok) return from;
+      const toJ = requireField(path, f, "to", "range-band upper value (a finite JSON number)");
+      if (!toJ.ok) return toJ;
+      const to = finite("to", toJ.value);
+      if (!to.ok) return to;
+      if (from.value > to.value)
+        return wrongType(
+          path,
+          "an ORDERED pair \u2014 a range band runs from its lower value to its upper one, and this pair runs backwards; swapping the ends silently would draw a band the author did not describe"
+        );
+      return ok({ kind: "ValueRange", from: from.value, to: to.value });
+    }
+    case "XRange": {
+      const fromJ = requireField(
+        path,
+        f,
+        "from",
+        "range-band lower x address (a ChartAnnotationX)"
+      );
+      if (!fromJ.ok) return fromJ;
+      const from = decodeChartAnnotationX(`${path}.from`, fromJ.value);
+      if (!from.ok) return from;
+      const toJ = requireField(path, f, "to", "range-band upper x address (a ChartAnnotationX)");
+      if (!toJ.ok) return toJ;
+      const to = decodeChartAnnotationX(`${path}.to`, toJ.value);
+      if (!to.ok) return to;
+      if (from.value.kind === "Date" && to.value.kind === "Date" && from.value.iso > to.value.iso)
+        return wrongType(
+          path,
+          "an ORDERED pair \u2014 a range band runs from its earlier date to its later one, and this pair runs backwards; swapping the ends silently would draw a band the author did not describe"
+        );
+      return ok({ kind: "XRange", from: from.value, to: to.value });
+    }
+    default:
+      return unknownDuCase(path, disc.value, "ValueRange, XRange");
+  }
+};
+var decodeChartAnnotation = (path, j) => {
+  const fo = requireObject(path, j);
+  if (!fo.ok) return fo;
+  const f = fo.value;
+  const disc = requireDiscriminator(path, f);
+  if (!disc.ok) return disc;
+  const label = optField(path, f, "label", decodeTextSource);
+  if (!label.ok) return label;
+  const withLabel = label.value !== void 0 ? { label: label.value } : {};
+  switch (disc.value) {
+    case "ReferenceLine": {
+      const valueJ = requireField(path, f, "value", "reference-line value (a finite JSON number)");
+      if (!valueJ.ok) return valueJ;
+      const value = requireFloat(`${path}.value`, valueJ.value);
+      if (!value.ok) return value;
+      if (!Number.isFinite(value.value))
+        return wrongType(
+          `${path}.value`,
+          "a FINITE JSON number \u2014 a reference line names a place on the value axis, and NaN / Infinity names none; give the value in the axis's own units, or drop the annotation"
+        );
+      return ok({ kind: "ReferenceLine", value: value.value, ...withLabel });
+    }
+    case "EventMarker": {
+      const atJ = requireField(path, f, "at", "event-marker x address (a ChartAnnotationX)");
+      if (!atJ.ok) return atJ;
+      const at = decodeChartAnnotationX(`${path}.at`, atJ.value);
+      if (!at.ok) return at;
+      return ok({ kind: "EventMarker", at: at.value, ...withLabel });
+    }
+    case "RangeBand": {
+      const rangeJ = requireField(path, f, "range", "range-band pair (a ChartAnnotationRange)");
+      if (!rangeJ.ok) return rangeJ;
+      const range = decodeChartAnnotationRange(`${path}.range`, rangeJ.value);
+      if (!range.ok) return range;
+      return ok({ kind: "RangeBand", range: range.value, ...withLabel });
+    }
+    default:
+      return unknownDuCase(path, disc.value, "ReferenceLine, EventMarker, RangeBand");
+  }
+};
 var decodeFileReadEncoding = (p, j) => bareEnum(p, j, ["Text", "Base64", "DataUrl"], "FileReadEncoding");
 var decodeAriaRole = (p, j) => {
   if (j.kind !== "JString") return wrongType(p, "JSON string (ARIA role)");
@@ -3444,6 +3838,7 @@ var decodeRelativeTimeUnit = (p, j) => bareEnum(
   ["Second", "Minute", "Hour", "Day", "Week", "Month", "Year"],
   "RelativeTimeUnit"
 );
+var decodeTimeGrain = (p, j) => bareEnum(p, j, ["Second", "Minute", "Hour", "Day"], "TimeGrain");
 var decodeCellFormat = (path, j) => {
   const fo = requireObject(path, j);
   if (!fo.ok) return fo;
@@ -3543,11 +3938,17 @@ var decodeFormat = (path, j) => {
       if (!style.ok) return style;
       return ok({ kind: "Duration", unit: unit.value, style: style.value });
     }
+    case "Since": {
+      const u = tryField(f, "unit");
+      if (u === void 0) return ok({ kind: "Since" });
+      const r = decodeRelativeTimeUnit(`${path}.unit`, u);
+      return r.ok ? ok({ kind: "Since", unit: r.value }) : r;
+    }
     default:
       return unknownDuCase(
         path,
         d.value,
-        "Number | Currency | Percent | Date | RelativeTime | Duration"
+        "Number | Currency | Percent | Date | RelativeTime | Duration | Since"
       );
   }
 };
@@ -3701,7 +4102,13 @@ var cFieldAliased = (f, canonical, alias) => {
 };
 var cStr = (j) => j.kind === "JString" ? cok(j.value) : cerr("malformed: expected string, got " + astKind(j));
 var cArr = (j) => j.kind === "JArray" ? cok(j.items) : cerr("malformed: expected array, got " + astKind(j));
-var cInt = (j) => j.kind === "JNumber" ? cok(Math.trunc(j.value)) : cerr("malformed: expected int, got " + astKind(j));
+var cInt = (j) => {
+  if (j.kind !== "JNumber") return cerr("malformed: expected int, got " + astKind(j));
+  if (!isInt32Slot(j.value)) {
+    return cerr(`malformed: expected a 32-bit integer, got ${j.value}`);
+  }
+  return cok(j.value);
+};
 var cMapM = (xs, fn) => {
   const out = [];
   for (const x of xs) {
@@ -3732,7 +4139,7 @@ var decodeCellLit = (j) => {
   if (v === void 0) return mismatch;
   switch (t) {
     case "Int":
-      return v.kind === "JNumber" ? cok({ kind: "Int", value: Math.trunc(v.value) }) : mismatch;
+      return v.kind === "JNumber" && isInt32Slot(v.value) ? cok({ kind: "Int", value: v.value }) : mismatch;
     case "Float":
       return v.kind === "JNumber" ? cok({ kind: "Float", value: v.value }) : mismatch;
     case "Bool":
@@ -4435,6 +4842,137 @@ var decodeInvokeArgs = (path, j) => {
     return ok({ addr: addr.value, value: value.value });
   });
 };
+var exprAdmissible = (root) => {
+  let count = 0;
+  let sawCol = false;
+  const walk = (e) => {
+    count += 1;
+    if (sawCol || count > MAX_EXPR_NODES) return;
+    switch (e.kind) {
+      case "col":
+        sawCol = true;
+        return;
+      case "lit":
+      case "param":
+        return;
+      case "binary":
+        walk(e.left);
+        walk(e.right);
+        return;
+      case "not":
+      case "cast":
+      case "isNull":
+        walk(e.expr);
+        return;
+      case "coalesce":
+        e.exprs.forEach(walk);
+        return;
+      case "apply":
+        e.args.forEach(walk);
+        return;
+      case "case":
+        for (const c of e.cases) {
+          walk(c.when);
+          walk(c.then);
+        }
+        walk(e.else);
+        return;
+      case "in":
+        walk(e.expr);
+        e.items.forEach(walk);
+        return;
+      case "inParam":
+        walk(e.expr);
+        return;
+    }
+  };
+  walk(root);
+  if (sawCol) return "col";
+  if (count > MAX_EXPR_NODES) return "limit";
+  return "ok";
+};
+var colExprParamNames = (root) => {
+  const seen = [];
+  const push = (n) => {
+    if (!seen.includes(n)) seen.push(n);
+  };
+  const walk = (e) => {
+    switch (e.kind) {
+      case "col":
+      case "lit":
+        return;
+      case "param":
+        push(e.name);
+        return;
+      case "binary":
+        walk(e.left);
+        walk(e.right);
+        return;
+      case "not":
+      case "cast":
+      case "isNull":
+        walk(e.expr);
+        return;
+      case "coalesce":
+        e.exprs.forEach(walk);
+        return;
+      case "apply":
+        e.args.forEach(walk);
+        return;
+      case "case":
+        for (const c of e.cases) {
+          walk(c.when);
+          walk(c.then);
+        }
+        walk(e.else);
+        return;
+      case "in":
+        walk(e.expr);
+        e.items.forEach(walk);
+        return;
+      case "inParam":
+        walk(e.expr);
+        push(e.param);
+        return;
+    }
+  };
+  walk(root);
+  return seen;
+};
+var decodeExprParams = (path, f) => {
+  const paramsField = tryField(f, "params");
+  if (paramsField === void 0) return ok(void 0);
+  if (paramsField.kind === "JObject") {
+    const entries = [...paramsField.fields.entries()].sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    );
+    const out = [];
+    for (const [name, v] of entries) {
+      const from = decodeBinding(`${path}.params.${name}.from`, v);
+      if (!from.ok) return from;
+      out.push({ name, from: from.value });
+    }
+    return ok(out);
+  }
+  const arr = requireArray(`${path}.params`, paramsField);
+  if (!arr.ok) return arr;
+  return traverseIndexed(arr.value, (_i, el) => {
+    const po = requireObject(`${path}.params[]`, el);
+    if (!po.ok) return po;
+    const name = reqField(`${path}.params[]`, po.value, "name", "param name string", requireString);
+    if (!name.ok) return name;
+    const from = reqFieldAliased(
+      `${path}.params[]`,
+      po.value,
+      "from",
+      ["value"],
+      "param source Binding",
+      decodeBinding
+    );
+    if (!from.ok) return from;
+    return ok({ name: name.value, from: from.value });
+  });
+};
 var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), placeholder = OPAQUE2) => {
   if (j.kind === "JArray" || j.kind === "JString" || j.kind === "JNumber" || j.kind === "JBool") {
     const parsed = parseStatic(path, j);
@@ -4533,14 +5071,23 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       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;
@@ -4555,6 +5102,37 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       return ok(b);
     }
     case "Local": {
+      const codecJ = tryField(f, "codec");
+      let codec;
+      if (codecJ !== void 0) {
+        const c = decodeFormat(`${path}.codec`, codecJ);
+        if (!c.ok) return c;
+        if (c.value.kind !== "Number") {
+          return makeError(
+            "WRONG_TYPE",
+            `${path}.codec`,
+            "Binding.Local 'codec' must be a Format case with a total, locale-independent inverse \u2014 only 'Number' has one",
+            'use {"$type":"Number","decimals":2}, or drop the codec and let the buffer use the identity; a locale-rendered format (Currency / Date / RelativeTime / Since / Duration) cannot be parsed back from what the reader typed'
+          );
+        }
+        codec = c.value;
+      }
+      const onCommitPresent = tryField(f, "onCommit") !== void 0;
+      const commitToJ = tryField(f, "commitTo");
+      let commitTo;
+      if (commitToJ !== void 0) {
+        if (onCommitPresent) {
+          return makeError(
+            "WRONG_TYPE",
+            `${path}.commitTo`,
+            "Binding.Local carries both 'onCommit' and 'commitTo' \u2014 exactly one commit destination is allowed",
+            "either onCommit (a host closure, which crosses the wire only as the closure sentinel) or commitTo (the State key the flush writes); a decoding host can honour only the second, so keeping both makes the same document commit to two different places depending on who read it"
+          );
+        }
+        const ct = requireString(`${path}.commitTo`, commitToJ);
+        if (!ct.ok) return ct;
+        commitTo = ct.value;
+      }
       const initial = reqField(
         path,
         f,
@@ -4566,15 +5144,35 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       const flushJ = tryField(f, "flushOn");
       const flush = flushJ === void 0 ? ok({ kind: "OnBlur" }) : decodeLocalFlushTrigger(`${path}.flushOn`, flushJ);
       if (!flush.ok) return flush;
-      const b = {
-        kind: "Local",
-        local: {
-          initialFrom: initial.value,
-          flushOn: flush.value,
-          onCommit: () => void 0,
-          parse: () => ({ ok: false, error: CLOSURE2 })
-        }
+      const refusalOf = (raw) => `Binding.Local: '${raw}' is not a value this field accepts`;
+      const identityParse = (raw) => {
+        const asText = parseStatic(`${path}.parse`, { kind: "JString", value: raw });
+        if (asText.ok) return { ok: true, value: asText.value };
+        const scalar = scalarOfText(raw);
+        if (scalar === void 0) return { ok: false, error: refusalOf(raw) };
+        const asScalar = parseStatic(
+          `${path}.parse`,
+          typeof scalar === "number" ? { kind: "JNumber", value: scalar } : { kind: "JBool", value: scalar }
+        );
+        return asScalar.ok ? { ok: true, value: asScalar.value } : { ok: false, error: refusalOf(raw) };
       };
+      const decimals = codec !== void 0 && codec.kind === "Number" ? codec.decimals : void 0;
+      const codecParse = (raw) => {
+        const n = tryNumberText(raw);
+        if (n === void 0) return { ok: false, error: refusalOf(raw) };
+        const parsed = parseStatic(`${path}.parse`, { kind: "JNumber", value: n });
+        return parsed.ok ? { ok: true, value: parsed.value } : { ok: false, error: refusalOf(raw) };
+      };
+      const local = {
+        initialFrom: initial.value,
+        flushOn: flush.value,
+        format: codec !== void 0 ? (v) => numberText(decimals, v) : (v) => identityFormat(v),
+        parse: codec !== void 0 ? codecParse : identityParse,
+        ...onCommitPresent ? { onCommit: () => void 0 } : {},
+        ...codec !== void 0 ? { codec } : {},
+        ...commitTo !== void 0 ? { commitTo } : {}
+      };
+      const b = { kind: "Local", local };
       return ok(b);
     }
     case "Format": {
@@ -4646,52 +5244,9 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       }
       const pipe = decodePipelineCore(pipeJ.value);
       if (!pipe.ok) return makeError("WRONG_TYPE", `${path}.pipeline`, pipe.error);
-      const paramsField = tryField(f, "params");
-      let params;
-      if (paramsField !== void 0 && paramsField.kind === "JObject") {
-        const entries = [...paramsField.fields.entries()].sort(
-          ([a], [b2]) => a < b2 ? -1 : a > b2 ? 1 : 0
-        );
-        const out = [];
-        let coerceErr;
-        for (const [name, v] of entries) {
-          const from = decodeBinding(`${path}.params.${name}.from`, v);
-          if (!from.ok) {
-            coerceErr = from;
-            break;
-          }
-          out.push({ name, from: from.value });
-        }
-        if (coerceErr !== void 0) return coerceErr;
-        params = out;
-      } else if (paramsField !== void 0) {
-        const arr = requireArray(`${path}.params`, paramsField);
-        if (!arr.ok) return arr;
-        const decoded = traverseIndexed(arr.value, (_i, el) => {
-          const po = requireObject(`${path}.params[]`, el);
-          if (!po.ok) return po;
-          const name = reqField(
-            `${path}.params[]`,
-            po.value,
-            "name",
-            "param name string",
-            requireString
-          );
-          if (!name.ok) return name;
-          const from = reqFieldAliased(
-            `${path}.params[]`,
-            po.value,
-            "from",
-            ["value"],
-            "param source Binding",
-            decodeBinding
-          );
-          if (!from.ok) return from;
-          return ok({ name: name.value, from: from.value });
-        });
-        if (!decoded.ok) return decoded;
-        params = decoded.value;
-      }
+      const paramsR = decodeExprParams(path, f);
+      if (!paramsR.ok) return paramsR;
+      const params = paramsR.value;
       const b = {
         kind: "Transform",
         source,
@@ -4700,6 +5255,47 @@ var decodeBinding = (path, j, parseStatic = (_p, v) => ok(decodeAstValue(v)), pl
       };
       return ok(b);
     }
+    case "Expr": {
+      const exprJ = requireField(path, f, "expr", "ColExpr object");
+      if (!exprJ.ok) return exprJ;
+      const expr = decodeColExprCore(exprJ.value);
+      if (!expr.ok) return makeError("WRONG_TYPE", `${path}.expr`, expr.error);
+      const verdict = exprAdmissible(expr.value);
+      if (verdict === "col") {
+        return makeError(
+          "WRONG_TYPE",
+          `${path}.expr`,
+          "a `col` reference is not admitted inside an Expr binding \u2014 an Expr evaluates against its params alone and has no row for a column name to read. Use `Binding.Transform`, whose source supplies the frame, and put the column expression in a `derive` step",
+          "a ColExpr over `param` / `lit` / operators only (no `col`)"
+        );
+      }
+      if (verdict === "limit") {
+        return makeError(
+          "LIMIT_EXCEEDED",
+          `${path}.expr`,
+          `expression exceeds the maximum of ${MAX_EXPR_NODES} expression nodes (WIRE_FORMAT 21)`,
+          `at most ${MAX_EXPR_NODES} ColExpr nodes in one Expr binding`
+        );
+      }
+      const exprParams = decodeExprParams(path, f);
+      if (!exprParams.ok) return exprParams;
+      const bound = new Set((exprParams.value ?? []).map((p) => p.name));
+      const missing = colExprParamNames(expr.value).filter((n) => !bound.has(n));
+      if (missing.length > 0) {
+        return makeError(
+          "WRONG_TYPE",
+          `${path}.expr`,
+          `the expression reads param(s) ${missing.map((n) => `'${n}'`).join(", ")} that this binding's \`params\` does not bind \u2014 an Expr has no rows and no filter to prune, so an unbound param has no value to take; add a params entry naming each, or drop the reference`,
+          '{"$type":"Expr","expr":{\u2026},"params":[{"name":"<name>","from":<Binding>}]}'
+        );
+      }
+      const b = {
+        kind: "Expr",
+        expr: expr.value,
+        ...exprParams.value !== void 0 ? { params: exprParams.value } : {}
+      };
+      return ok(b);
+    }
     case "Invoke": {
       const cid = reqField(path, f, "capabilityId", "capability id string", requireString);
       if (!cid.ok) return cid;
@@ -5043,10 +5639,14 @@ var decodeAction = (path, j) => {
         f,
         "route",
         ["href", "url", "to"],
-        "route string",
-        requireString
+        "route TextSource",
+        decodeTextSource
       );
-      return r.ok ? ok({ kind: "Navigate", route: r.value }) : r;
+      if (!r.ok) return r;
+      const targetJ = tryField(f, "target");
+      const target = targetJ === void 0 ? ok("Self") : decodeNavigateTarget(`${path}.target`, targetJ);
+      if (!target.ok) return target;
+      return ok({ kind: "Navigate", route: r.value, target: target.value });
     }
     case "SetState": {
       const key = reqField(path, f, "key", "state key string", requireString);
@@ -5116,6 +5716,51 @@ var decodeAction = (path, j) => {
       }
       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;
@@ -7103,6 +7748,18 @@ var decodeChartSpec = (path, j) => {
   if (!dataLabels.ok) return dataLabels;
   const xScale = optField(path, f, "xScale", decodeChartXScale);
   if (!xScale.ok) return xScale;
+  const annotationsJ = tryField(f, "annotations");
+  let annotations;
+  if (annotationsJ !== void 0) {
+    const arr2 = requireArray(`${path}.annotations`, annotationsJ);
+    if (!arr2.ok) return arr2;
+    const decoded = traverseIndexed(
+      arr2.value,
+      (i, item) => decodeChartAnnotation(`${path}.annotations[${i}]`, item)
+    );
+    if (!decoded.ok) return decoded;
+    annotations = decoded.value;
+  }
   const hasPointClick = tryField(f, "onPointClick") !== void 0;
   const stacked = optField(path, f, "stacked", requireBool);
   if (!stacked.ok) return stacked;
@@ -7120,6 +7777,7 @@ var decodeChartSpec = (path, j) => {
     ...legendPosition.value !== void 0 ? { legendPosition: legendPosition.value } : {},
     ...dataLabels.value !== void 0 ? { dataLabels: dataLabels.value } : {},
     ...xScale.value !== void 0 ? { xScale: xScale.value } : {},
+    ...annotations !== void 0 ? { annotations } : {},
     ...hasPointClick ? { onPointClick: () => placeholderAction } : {}
   });
 };
@@ -7818,11 +8476,29 @@ 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);
@@ -8168,13 +8844,16 @@ var decodeNodeAstInner = (path, j) => {
   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 } : {},
-    ...tooltip.value !== void 0 ? { tooltip: tooltip.value } : {}
+    ...tooltip.value !== void 0 ? { tooltip: tooltip.value } : {},
+    ...visible.value !== void 0 ? { visible: visible.value } : {}
   });
 };
 var decodeTreeOpAst = (path, j) => {
@@ -8383,10 +9062,238 @@ var decodeOp = (json, policy) => {
   resetWalk(policy);
   return decodeTreeOpAst("$", parsed.value);
 };
+var decodeOps = (json, policy) => {
+  const parsed = parse(json);
+  if (!parsed.ok) return parseFailure(parsed.error);
+  resetWalk(policy);
+  const entries = parsed.value.kind === "JArray" ? parsed.value.items : [parsed.value];
+  const ops = [];
+  for (let i = 0; i < entries.length; i += 1) {
+    const path = parsed.value.kind === "JArray" ? `$[${i}]` : "$";
+    const decoded = decodeTreeOpAst(path, entries[i]);
+    if (!decoded.ok) return decoded;
+    ops.push(decoded.value);
+  }
+  return ok(ops);
+};
+
+// src/capabilityDecl.ts
+var dok2 = (value) => ({ ok: true, value });
+var derr2 = (error) => ({ ok: false, error });
+var HOST_WIRE = {
+  Pure: "pure",
+  ReadsHost: "readsHost",
+  WritesHost: "writesHost"
+};
+var DETERMINISM_WIRE = {
+  Deterministic: "deterministic",
+  Clock: "clock",
+  Random: "random",
+  Network: "network"
+};
+var PLACEMENT_WIRE = {
+  BuildTime: "buildTime",
+  Server: "server",
+  ClientDeclarative: "clientDeclarative",
+  ClientIsland: "clientIsland",
+  Precomputed: "precomputed"
+};
+var SPACE_WIRE = {
+  IntRange: "intRange",
+  FloatRange: "floatRange",
+  StringLen: "stringLen",
+  Enum: "enum",
+  AnyString: "anyString"
+};
+var ISLANDS = ["pyodide", "fable", "js"];
+var invert = (m) => Object.fromEntries(Object.entries(m).map(([k, v]) => [v, k]));
+var HOST_OF = invert(HOST_WIRE);
+var DETERMINISM_OF = invert(DETERMINISM_WIRE);
+var PLACEMENT_OF = invert(PLACEMENT_WIRE);
+var SPACE_OF = invert(SPACE_WIRE);
+var spaceJson = (s) => {
+  switch (s.kind) {
+    case "IntRange":
+      return caseObj(SPACE_WIRE[s.kind], [
+        ["min", num(s.min)],
+        ["max", num(s.max)]
+      ]);
+    case "FloatRange":
+      return caseObj(SPACE_WIRE[s.kind], [
+        ["min", num(s.min)],
+        ["max", num(s.max)]
+      ]);
+    case "StringLen":
+      return caseObj(SPACE_WIRE[s.kind], [
+        ["min", num(s.minLen)],
+        ["max", num(s.maxLen)]
+      ]);
+    case "Enum":
+      return caseObj(SPACE_WIRE[s.kind], [["values", jArray(s.choices.map(str))]]);
+    case "AnyString":
+      return caseObj(SPACE_WIRE[s.kind], []);
+  }
+};
+var entryJson = (e) => {
+  const fields = [
+    ["addr", str(e.addr)],
+    ["name", str(e.name)],
+    ["kind", str(e.kind)],
+    ["required", bool(e.required)]
+  ];
+  if (e.space !== void 0) fields.push(["space", spaceJson(e.space)]);
+  if (e.slotKind !== void 0) fields.push(["slotKind", str(e.slotKind)]);
+  return jObject(fields);
+};
+var placementJson = (p) => p.kind === "ClientIsland" ? caseObj(PLACEMENT_WIRE[p.kind], [["island", str(p.island)]]) : caseObj(PLACEMENT_WIRE[p.kind], []);
+var signatureJson = (sg) => jObject([
+  ["name", str(sg.name)],
+  [
+    "effect",
+    jObject([
+      ["host", str(HOST_WIRE[sg.effect.hostEffect])],
+      ["determinism", str(DETERMINISM_WIRE[sg.effect.determinism])]
+    ])
+  ],
+  ["holes", jArray(sg.holes.map(entryJson))]
+]);
+var encodeCapabilityDeclaration = (cap) => caseObj("capability", [
+  ["id", str(cap.id)],
+  ["signature", signatureJson(cap.signature)],
+  ["determinism", str(DETERMINISM_WIRE[cap.determinism])],
+  ["placement", placementJson(cap.placement)]
+]);
+var DeclError = class extends Error {
+};
+var fail2 = (message) => {
+  throw new DeclError(message);
+};
+var asObject = (v, what) => typeof v !== "object" || v === null || Array.isArray(v) ? fail2(`${what} is not an object`) : v;
+var strAt = (o, k) => {
+  const v = o[k];
+  return typeof v === "string" ? v : fail2(`missing or non-string field: ${k}`);
+};
+var numAt = (o, k) => {
+  const v = o[k];
+  return typeof v === "number" && Number.isFinite(v) ? v : fail2(`missing or non-finite numeric field: ${k}`);
+};
+var spaceOf = (raw) => {
+  const o = asObject(raw, "value-space");
+  const tag = strAt(o, "$type");
+  const kind = SPACE_OF[tag];
+  switch (kind) {
+    case "IntRange":
+      return { kind, min: numAt(o, "min"), max: numAt(o, "max") };
+    case "FloatRange":
+      return { kind, min: numAt(o, "min"), max: numAt(o, "max") };
+    case "StringLen":
+      return { kind, minLen: numAt(o, "min"), maxLen: numAt(o, "max") };
+    case "Enum": {
+      const values = o["values"];
+      if (!Array.isArray(values) || values.some((x) => typeof x !== "string"))
+        fail2("enum values must be a string array");
+      return { kind, choices: values };
+    }
+    case "AnyString":
+      return { kind };
+    default:
+      return fail2(
+        `unknown value-space kind: ${tag}; expected one of: ${Object.values(SPACE_WIRE).join(", ")}`
+      );
+  }
+};
+var entryOf = (raw) => {
+  const o = asObject(raw, "signature hole");
+  if ("actionEffect" in o) {
+    fail2(
+      "this host's signature entry carries no action-effect axis, so a hole declaring `actionEffect` cannot round-trip"
+    );
+  }
+  const kind = strAt(o, "kind");
+  if (kind !== "value" && kind !== "slot" && kind !== "repeat")
+    fail2(`unknown hole kind: ${kind}; expected one of: value, slot, repeat`);
+  const required = o["required"];
+  if (typeof required !== "boolean") fail2("missing or non-boolean field: required");
+  return {
+    addr: strAt(o, "addr"),
+    name: strAt(o, "name"),
+    kind,
+    required,
+    ..."space" in o ? { space: spaceOf(o["space"]) } : {},
+    ..."slotKind" in o ? { slotKind: strAt(o, "slotKind") } : {}
+  };
+};
+var placementOf = (raw) => {
+  const o = asObject(raw, "placement");
+  const tag = strAt(o, "$type");
+  const kind = PLACEMENT_OF[tag];
+  if (kind === void 0)
+    fail2(`unknown placement: ${tag}; expected one of: ${Object.values(PLACEMENT_WIRE).join(", ")}`);
+  if (kind === "ClientIsland") {
+    const island = strAt(o, "island");
+    if (!ISLANDS.includes(island))
+      fail2(`unknown island kind: ${island}; expected one of: ${ISLANDS.join(", ")}`);
+    return { kind, island };
+  }
+  return { kind };
+};
+var declarationOf = (json) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return fail2("capability declaration is not well-formed JSON");
+  }
+  const o = asObject(parsed, "capability declaration");
+  const tag = o["$type"];
+  if (tag !== void 0 && tag !== "capability")
+    fail2(`not a capability declaration: $type '${String(tag)}'`);
+  const sigObj = asObject(o["signature"], "signature");
+  const effectObj = asObject(sigObj["effect"], "effect");
+  const hostTag = strAt(effectObj, "host");
+  const hostEffect = HOST_OF[hostTag];
+  if (hostEffect === void 0)
+    fail2(
+      `unknown host effect: ${hostTag}; expected one of: ${Object.values(HOST_WIRE).join(", ")}`
+    );
+  const detTag = strAt(effectObj, "determinism");
+  const determinism = DETERMINISM_OF[detTag];
+  if (determinism === void 0)
+    fail2(
+      `unknown determinism: ${detTag}; expected one of: ${Object.values(DETERMINISM_WIRE).join(", ")}`
+    );
+  const holes = sigObj["holes"];
+  if (!Array.isArray(holes)) fail2("missing or non-array field: holes");
+  const signature = {
+    name: strAt(sigObj, "name"),
+    holes: holes.map(entryOf),
+    effect: { hostEffect, determinism }
+  };
+  const wireTag = strAt(o, "determinism");
+  const expectedTag = DETERMINISM_WIRE[determinism];
+  if (wireTag !== expectedTag)
+    fail2(
+      `capability determinism disagrees with signature effect: wire '${wireTag}' vs signature '${expectedTag}'`
+    );
+  return {
+    id: strAt(o, "id"),
+    signature,
+    determinism,
+    placement: placementOf(o["placement"])
+  };
+};
+var decodeCapabilityDeclaration = (json) => {
+  try {
+    return dok2(declarationOf(json));
+  } catch (e) {
+    if (e instanceof DeclError) return derr2(e.message);
+    throw e;
+  }
+};
 
 // src/apply.ts
 var ok2 = (value) => ({ ok: true, value });
-var fail2 = (code, message, batchIndex) => ({
+var fail3 = (code, message, batchIndex) => ({
   ok: false,
   error: batchIndex === void 0 ? { code, message } : { code, message, batchIndex }
 });
@@ -9223,22 +10130,22 @@ var applyOne = (op, root, telem) => {
     case "EditNode": {
       const updatedTree = mapNode(op.target, (n) => ({ ...n, kind: op.newKind }), root);
       if (updatedTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "EditNode", targetId: op.target });
       return ok2(updatedTree);
     }
     case "UpdateProp": {
       const parsed = parsePath(op.path);
       if (!parsed.ok)
-        return fail2("PathInvalid", `Path '${op.path}' is structurally invalid: ${parsed.error}.`);
+        return fail3("PathInvalid", `Path '${op.path}' is structurally invalid: ${parsed.error}.`);
       const targetNode = findNode(op.target, root);
       if (targetNode === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const segs = parsed.value;
       const finish = (kind) => {
         const newTree = mapNode(op.target, (n) => ({ ...n, kind }), root);
         if (newTree === void 0)
-          return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+          return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
         telem.push({ op: "UpdateProp", targetId: op.target });
         return ok2(newTree);
       };
@@ -9248,14 +10155,14 @@ var applyOne = (op, root, telem) => {
           case "updated":
             return finish(outcome2.kind);
           case "unknownField":
-            return fail2("FieldNotFound", `Field '${op.path}' not found on node '${op.target}'.`);
+            return fail3("FieldNotFound", `Field '${op.path}' not found on node '${op.target}'.`);
           case "notSupported":
-            return fail2(
+            return fail3(
               "PathNotSupportedYet",
               `Path '${op.path}' on node '${op.target}' is not yet supported by the apply engine.`
             );
           case "typeMismatch":
-            return fail2(
+            return fail3(
               "KindMismatch",
               `UpdateProp value for '${op.path}' on node '${op.target}' does not match the field's expected type: ${outcome2.detail}`
             );
@@ -9267,27 +10174,27 @@ var applyOne = (op, root, telem) => {
         case "updated":
           return finish(outcome.kind);
         case "missingIndex":
-          return fail2(
+          return fail3(
             "PathInvalid",
             `Field '${outcome.listField}' on node '${op.target}' is a list \u2014 address an element with a 0-based index (the list has ${outcome.count} element(s)).`
           );
         case "indexOutOfRange":
-          return fail2(
+          return fail3(
             "PositionOutOfRange",
             `Index ${outcome.requested} is out of range for '${outcome.listField}' on node '${op.target}' (${outcome.count === 0 ? "the list is empty" : `valid: 0..${outcome.count - 1}`}).`
           );
         case "fieldNotFound":
-          return fail2(
+          return fail3(
             "FieldNotFound",
             `Field '${outcome.segment}' (in path '${op.path}') not found on node '${op.target}'. Available at this segment: ${outcome.available.join(", ")}.`
           );
         case "notSupported":
-          return fail2(
+          return fail3(
             "PathNotSupportedYet",
             `Path '${op.path}' on node '${op.target}' is not yet supported by the apply engine.`
           );
         case "typeMismatch":
-          return fail2(
+          return fail3(
             "KindMismatch",
             `UpdateProp value for '${op.path}' on node '${op.target}' does not match the field's expected type: ${outcome.detail}`
           );
@@ -9297,20 +10204,20 @@ var applyOne = (op, root, telem) => {
     case "ReplaceBinding": {
       const targetNode = findNode(op.target, root);
       if (targetNode === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const newKind = replaceBinding(op.slot, op.binding, targetNode.kind);
       if (newKind === void 0)
-        return fail2("SlotNotFound", `Binding slot '${op.slot}' not found on node '${op.target}'.`);
+        return fail3("SlotNotFound", `Binding slot '${op.slot}' not found on node '${op.target}'.`);
       const newTree = mapNode(op.target, (n) => ({ ...n, kind: newKind }), root);
       if (newTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "ReplaceBinding", targetId: op.target });
       return ok2(newTree);
     }
     case "UpdateStyle": {
       const newTree = mapNode(op.target, (n) => ({ ...n, style: op.style }), root);
       if (newTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "UpdateStyle", targetId: op.target });
       return ok2(newTree);
     }
@@ -9321,39 +10228,39 @@ var applyOne = (op, root, telem) => {
         root
       );
       if (newTree === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       telem.push({ op: "UpdateState", targetId: op.target });
       return ok2(newTree);
     }
     case "InsertChild": {
       const parent = findNode(op.parentId, root);
       if (parent === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       const children = layoutChildren(parent);
       if (children === void 0)
-        return fail2(
+        return fail3(
           "ChildlessKind",
           `Node '${op.parentId}' (kind=${parent.kind.kind}) has no children field \u2014 only Layout kinds accept structural child ops.`
         );
       const existing = new Set(allNodeIds(root));
       const duplicate = allNodeIds(op.child).find((id) => existing.has(id));
       if (duplicate !== void 0)
-        return fail2(
+        return fail3(
           "DuplicateNodeId",
           `NodeId '${duplicate}' is already present in the tree; ids must be unique.`
         );
       const newChildren = [...children, op.child];
       const newTree = mapNode(op.parentId, (n) => withLayoutChildren(n, newChildren), root);
       if (newTree === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       telem.push({ op: "InsertChild", targetId: op.parentId });
       return ok2(newTree);
     }
     case "RemoveNode": {
-      if (idOf(root) === op.target) return fail2("KindMismatch", "Cannot RemoveNode the root.");
+      if (idOf(root) === op.target) return fail3("KindMismatch", "Cannot RemoveNode the root.");
       const parent = findLayoutParent(op.target, root);
       if (parent === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const children = layoutChildren(parent);
       const newTree = mapNode(
         idOf(parent),
@@ -9364,26 +10271,26 @@ var applyOne = (op, root, telem) => {
         root
       );
       if (newTree === void 0)
-        return fail2("ParentNotFound", `Parent node '${idOf(parent)}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${idOf(parent)}' not found in tree.`);
       telem.push({ op: "RemoveNode", targetId: op.target });
       return ok2(newTree);
     }
     case "MoveNode": {
       if (op.target === op.newParentId)
-        return fail2("KindMismatch", "Cannot move a node into itself.");
+        return fail3("KindMismatch", "Cannot move a node into itself.");
       if (isAncestor(op.target, op.newParentId, root))
-        return fail2(
+        return fail3(
           "KindMismatch",
           "Cannot move a node into its own descendant (would create a cycle)."
         );
       const moving = findNode(op.target, root);
       if (moving === void 0)
-        return fail2("NodeNotFound", `Node '${op.target}' not found in tree.`);
+        return fail3("NodeNotFound", `Node '${op.target}' not found in tree.`);
       const newParent = findNode(op.newParentId, root);
       if (newParent === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.newParentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.newParentId}' not found in tree.`);
       if (layoutChildren(newParent) === void 0)
-        return fail2(
+        return fail3(
           "ChildlessKind",
           `Node '${op.newParentId}' (kind=${newParent.kind.kind}) has no children field.`
         );
@@ -9401,10 +10308,10 @@ var applyOne = (op, root, telem) => {
     case "ReorderChildren": {
       const parent = findNode(op.parentId, root);
       if (parent === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       const children = layoutChildren(parent);
       if (children === void 0)
-        return fail2(
+        return fail3(
           "ChildlessKind",
           `Node '${op.parentId}' (kind=${parent.kind.kind}) has no children field.`
         );
@@ -9412,7 +10319,7 @@ var applyOne = (op, root, telem) => {
       const sortedCurrent = [...currentIds].sort();
       const sortedNew = [...op.newOrder].map((x) => x).sort();
       if (sortedCurrent.length !== sortedNew.length || sortedCurrent.some((id, i) => id !== sortedNew[i]))
-        return fail2(
+        return fail3(
           "OrderingMismatch",
           `ReorderChildren for '${op.parentId}' did not list exactly the current child ids.`
         );
@@ -9420,7 +10327,7 @@ var applyOne = (op, root, telem) => {
       const reordered = op.newOrder.map((id) => byId.get(id)).filter((c) => c !== void 0);
       const newTree = mapNode(op.parentId, (n) => withLayoutChildren(n, reordered), root);
       if (newTree === void 0)
-        return fail2("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
+        return fail3("ParentNotFound", `Parent node '${op.parentId}' not found in tree.`);
       telem.push({ op: "ReorderChildren", targetId: op.parentId });
       return ok2(newTree);
     }
@@ -9445,7 +10352,7 @@ var applyOne = (op, root, telem) => {
       return ok2(state);
     }
   }
-  return fail2("KindMismatch", "unreachable apply branch");
+  return fail3("KindMismatch", "unreachable apply branch");
 };
 var apply = (tree, op) => {
   const telem = [];
@@ -9768,11 +10675,20 @@ var isPureAddition = (baseIds, headIds) => {
   return survive.length === baseIds.length && survive.every((v, i) => v === baseIds[i]) && headKept.length === baseIds.length && headKept.every((v, i) => v === baseIds[i]);
 };
 var eqOpt = (x, y) => (x ?? null) === (y ?? null);
-var pickField = (conflicts, nodeId, facet, baseV, aV, bV) => {
+var refusal = (nodeId, facet, cls, base, aValue, bValue) => ({
+  nodeId,
+  facet,
+  class: cls,
+  base,
+  a: { value: aValue },
+  b: { value: bValue },
+  primacyHeld: false
+});
+var pickField = (conflicts, nodeId, facet, dflt, baseV, aV, bV) => {
   const aCh = !eqOpt(aV, baseV);
   const bCh = !eqOpt(bV, baseV);
   if (aCh && bCh && !eqOpt(aV, bV)) {
-    conflicts.push({ nodeId, facet });
+    conflicts.push(refusal(nodeId, facet, "ConcurrentEdit", baseV ?? dflt, aV ?? dflt, bV ?? dflt));
     return baseV;
   }
   if (aCh) return aV;
@@ -9783,7 +10699,7 @@ var pickCanonical = (conflicts, nodeId, facet, baseC, aC, bC) => {
   const aCh = aC !== baseC;
   const bCh = bC !== baseC;
   if (aCh && bCh && aC !== bC) {
-    conflicts.push({ nodeId, facet });
+    conflicts.push(refusal(nodeId, facet, "ConcurrentEdit", baseC, aC, bC));
     return 0;
   }
   if (aCh) return 1;
@@ -9794,18 +10710,28 @@ var mergeStyle = (conflicts, id, base, a, b) => {
   const bs = base.style;
   const as_ = a.style;
   const bsB = b.style;
-  const tone = pickField(conflicts, id, "style.tone", bs.tone, as_.tone, bsB.tone);
-  const weight = pickField(conflicts, id, "style.weight", bs.weight, as_.weight, bsB.weight);
+  const d = defaults.style;
+  const tone = pickField(conflicts, id, "style.tone", d.tone, bs.tone, as_.tone, bsB.tone);
+  const weight = pickField(
+    conflicts,
+    id,
+    "style.weight",
+    d.weight,
+    bs.weight,
+    as_.weight,
+    bsB.weight
+  );
   const emphasis = pickField(
     conflicts,
     id,
     "style.emphasis",
+    d.emphasis,
     bs.emphasis,
     as_.emphasis,
     bsB.emphasis
   );
-  const role = pickField(conflicts, id, "style.role", bs.role, as_.role, bsB.role);
-  const voice = pickField(conflicts, id, "style.voice", bs.voice, as_.voice, bsB.voice);
+  const role = pickField(conflicts, id, "style.role", d.role, bs.role, as_.role, bsB.role);
+  const voice = pickField(conflicts, id, "style.voice", d.voice, bs.voice, as_.voice, bsB.voice);
   const style = { tone, weight, emphasis };
   return {
     ...style,
@@ -9861,8 +10787,15 @@ var merge3 = (conflicts, base, aOpt, bOpt) => {
     const bc = baseMap.get(cid);
     if (bc !== void 0) return merge3(conflicts, bc, aMap.get(cid), bMap.get(cid));
     const ac = aMap.get(cid);
-    if (ac !== void 0) return ac;
     const bb = bMap.get(cid);
+    if (ac !== void 0 && bb !== void 0) {
+      const acC = encodeNode(ac);
+      const bcC = encodeNode(bb);
+      if (acC === bcC) return ac;
+      conflicts.push(refusal(cid, "insert", "ConcurrentEdit", "", acC, bcC));
+      return ordinal(acC, bcC) <= 0 ? ac : bb;
+    }
+    if (ac !== void 0) return ac;
     if (bb !== void 0) return bb;
     throw new Error(`merge3: child id ${cid} vanished`);
   };
@@ -9873,6 +10806,8 @@ var merge3 = (conflicts, base, aOpt, bOpt) => {
     mergedChildren = aIds.map(recurseChild);
   } else if (!aStruct && bStruct) {
     mergedChildren = bIds.map(recurseChild);
+  } else if (JSON.stringify(aIds) === JSON.stringify(bIds)) {
+    mergedChildren = aIds.map(recurseChild);
   } else {
     const baseSet = new Set(baseIds);
     const aNew = aIds.filter((i) => !baseSet.has(i));
@@ -9884,7 +10819,16 @@ var merge3 = (conflicts, base, aOpt, bOpt) => {
       const newIds = [.../* @__PURE__ */ new Set([...aNew, ...bNew])].sort(ordinal);
       mergedChildren = [...survivors, ...newIds.map(recurseChild)];
     } else {
-      conflicts.push({ nodeId: id, facet: "children" });
+      conflicts.push(
+        refusal(
+          id,
+          "children",
+          "ReorderVsStructural",
+          baseIds.join(","),
+          aIds.join(","),
+          bIds.join(",")
+        )
+      );
       mergedChildren = baseIds.map(recurseChild);
     }
   }
@@ -9896,6 +10840,21 @@ var merge3Way = (base, a, b) => {
   const merged = merge3(conflicts, base, a, b);
   return conflicts.length === 0 ? { ok: true, tree: merged } : { ok: false, conflicts };
 };
+var sortConflictsCanonical = (conflicts) => [...conflicts].sort((x, y) => ordinal(x.nodeId, y.nodeId) || ordinal(x.facet, y.facet));
+var escapeJson = (s) => {
+  let out = '"';
+  for (const ch of s) {
+    if (ch === '"') out += '\\"';
+    else if (ch === "\\") out += "\\\\";
+    else if (ch < " ") out += `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`;
+    else out += ch;
+  }
+  return out + '"';
+};
+var encodeSide = (side) => `{"tag":${side.tag === void 0 ? "null" : escapeJson(side.tag)},"value":${escapeJson(side.value)}}`;
+var encodeMergeEnvelope = (conflicts) => "[" + sortConflictsCanonical(conflicts).map(
+  (c) => `{"a":${encodeSide(c.a)},"b":${encodeSide(c.b)},"base":${escapeJson(c.base)},"class":${escapeJson(c.class)},"facet":${escapeJson(c.facet)},"nodeId":${escapeJson(c.nodeId)},"primacyHeld":${c.primacyHeld ? "true" : "false"}}`
+).join(",") + "]";
 
 // src/versioning.ts
 var renderProfile = (p) => `${p.name}@${p.major}.${p.minor}`;
@@ -10783,6 +11742,6 @@ var withStateSeeds = (tree, sources) => {
   return { ...sources, state: { ...seeds, ...sources.state ?? {} } };
 };
 
-export { ELICITATION_KEY, ELICITATION_VERSION, HOST_RESERVED_PREFIX, PAYLOAD_KEY, PROFILE_KEY, REQUIRED_PROFILE_KEY, apply, canPlace, cellString, coerce, collectStateSeeds, coreV1, decodeDagRecord, decodeElicitation, decodeElicitationOutcome, decodeEnvelope, decodeEnvelopeAst, decodeNode, decodeNodeTolerant, decodeOp, decodeTolerant, derivedFreshIds, duplicateOp, duplicateOpWith, encodeCell, encodeColExpr, encodeDagRecord, encodeDataSource, encodeElicitation, encodeElicitationOutcome, encodeEnvelope2 as encodeEnvelope, encodeNode, encodeOp, encodePipeline, evalErrorString, evalPipeline, evalPipelineInEnv, evalPipelineWith, evalPipelineWithInEnv, evalSource, field as jsonField, liveValueToTable, merge3Way, moveOp, negotiate, negotiateEnvelope, noResolve, nudgeOp, parse, pasteOp, pasteOpWith, pipelineParams, placeOp, reencodeNode, renderAstCanonical, renderProfile, sequentialFreshIds, stepParams, substituteListParams, tryParseProfile, validateAnswer, validateAnswerAt, validateAnswerDocument, withStateSeeds };
+export { DECODED_COMPUTED_MESSAGE, ELICITATION_KEY, ELICITATION_VERSION, HOST_RESERVED_PREFIX, PAYLOAD_KEY, PROFILE_KEY, REQUIRED_PROFILE_KEY, WireSurvivabilityError, apply, canPlace, cellString, coerce, collectStateSeeds, coreV1, decodeCapabilityDeclaration, decodeDagRecord, decodeDataSource, decodeElicitation, decodeElicitationOutcome, decodeEnvelope, decodeEnvelopeAst, decodeNode, decodeNodeTolerant, decodeOp, decodeOps, decodePipelineCore as decodePipeline, decodeTolerant, derivedFreshIds, duplicateOp, duplicateOpWith, encodeCapabilityDeclaration, encodeCell, encodeColExpr, encodeDagRecord, encodeDataSource, encodeElicitation, encodeElicitationOutcome, encodeEnvelope2 as encodeEnvelope, encodeMergeEnvelope, encodeNode, encodeOp, encodePipeline, evalErrorString, evalPipeline, evalPipelineInEnv, evalPipelineWith, evalPipelineWithInEnv, evalSource, fixedText, identityFormat, field as jsonField, liveValueToTable, merge3Way, moveOp, negotiate, negotiateEnvelope, noResolve, nudgeOp, numberText, parse, pasteOp, pasteOpWith, pipelineParams, placeOp, reencodeNode, renderAstCanonical, renderProfile, scalarOfText, sequentialFreshIds, sortConflictsCanonical, stepParams, substituteListParams, tryNumberText, tryParseProfile, validateAnswer, validateAnswerAt, validateAnswerDocument, withStateSeeds };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map