@fuaran-ui/ops 0.21.0 → 0.23.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)]);
@@ -487,6 +513,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)],
@@ -561,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);
   }
@@ -1343,15 +1382,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)]);
@@ -1360,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);
 };
@@ -1642,10 +1702,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)]] : []
               ])
             )
           )
@@ -1740,6 +1804,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) => {
@@ -2895,6 +2960,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;
@@ -2925,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");
@@ -2978,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)) {
@@ -3084,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);
@@ -3143,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);
 
@@ -3194,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);
@@ -3355,6 +3605,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,
@@ -3432,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)");
@@ -3446,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;
@@ -3545,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"
       );
   }
 };
@@ -3703,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) {
@@ -3734,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":
@@ -4437,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);
@@ -4535,14 +5073,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;
@@ -4557,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,
@@ -4568,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": {
@@ -4648,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,
@@ -4702,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;
@@ -5045,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);
@@ -5118,6 +5718,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;
@@ -7105,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;
@@ -7122,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 } : {}
   });
 };
@@ -7820,11 +8478,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);
@@ -8170,13 +8846,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) => {
@@ -8385,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 }
 });
@@ -9225,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);
       };
@@ -9250,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}`
             );
@@ -9269,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}`
           );
@@ -9299,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);
     }
@@ -9323,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),
@@ -9366,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.`
         );
@@ -9403,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.`
         );
@@ -9414,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.`
         );
@@ -9422,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);
     }
@@ -9447,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 = [];
@@ -9770,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;
@@ -9785,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;
@@ -9796,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,
@@ -9863,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`);
   };
@@ -9875,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));
@@ -9886,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);
     }
   }
@@ -9898,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}`;
@@ -10785,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;
@@ -10805,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;
@@ -10816,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;
@@ -10825,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;
@@ -10833,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;
@@ -10841,9 +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;