@kubohiroya/turbowarp-extension-data-editor 0.2.0 → 0.2.2

package/dist/webpack4/shared-P2JBRZFP.js

@@ -0,0 +1,2206 @@
+import {
+  BlockEditorConflictError,
+  BlockEditorStructureError,
+  DEFAULT_DESCENDANT_LIMITS,
+  DescendantNodeError,
+  EDITOR_API_VERSION,
+  supportsDescendantEditing
+} from "./shared-BKTRZUZH.js";
+import {
+  compileSchemaBundle,
+  isJsonRecord,
+  parseFixedNumberInput,
+  snapshotJson
+} from "./shared-75QIWLZY.js";
+
+// dist/data.js
+function isLiteral(value) {
+  return typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function cloneJson(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const visit = (item, depth) => {
+    if (depth > 100)
+      throw new TypeError("JSON data exceeds the maximum depth.");
+    if (item === null || isLiteral(item))
+      return item;
+    if (typeof item !== "object")
+      throw new TypeError("Expected JSON-compatible data.");
+    if (ancestors.has(item))
+      throw new TypeError("JSON data must not contain cycles.");
+    ancestors.add(item);
+    try {
+      if (Array.isArray(item))
+        return Array.from(item, (child) => visit(child, depth + 1));
+      const prototype = Object.getPrototypeOf(item);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError("JSON objects must be plain objects.");
+      }
+      if (Object.getOwnPropertySymbols(item).length > 0) {
+        throw new TypeError("JSON objects must not have symbol properties.");
+      }
+      return Object.fromEntries(Object.entries(item).map(([key, child]) => [key, visit(child, depth + 1)]));
+    } finally {
+      ancestors.delete(item);
+    }
+  };
+  return visit(value, 0);
+}
+function captureReference(reference) {
+  if (!reference || typeof reference.targetId !== "string" || !reference.targetId || typeof reference.blockId !== "string" || !reference.blockId) {
+    throw new TypeError("A target ID and block ID are required.");
+  }
+  return Object.freeze({ targetId: reference.targetId, blockId: reference.blockId });
+}
+function captureSnapshot(snapshot, reference) {
+  if (snapshot.targetId !== reference.targetId || snapshot.blockId !== reference.blockId || typeof snapshot.opcode !== "string" || !snapshot.opcode || typeof snapshot.revision !== "string" || !snapshot.revision || !snapshot.arguments || typeof snapshot.arguments !== "object" || Array.isArray(snapshot.arguments)) {
+    throw new TypeError("The host returned an invalid block snapshot.");
+  }
+  const entries = Object.entries(snapshot.arguments).map(([name, slot]) => {
+    if (!slot || slot.kind !== "reporter" && slot.kind !== "literal" || slot.kind === "literal" && !isLiteral(slot.value)) {
+      throw new TypeError(`Invalid argument slot: ${name}`);
+    }
+    const copy = slot.kind === "reporter" ? Object.freeze({ kind: "reporter" }) : Object.freeze({ kind: "literal", value: slot.value });
+    return [name, copy];
+  });
+  return Object.freeze({
+    ...captureReference(reference),
+    opcode: snapshot.opcode,
+    revision: snapshot.revision,
+    arguments: Object.freeze(Object.fromEntries(entries))
+  });
+}
+function sameSnapshot(left, right) {
+  const names3 = Object.keys(left.arguments);
+  return left.targetId === right.targetId && left.blockId === right.blockId && left.opcode === right.opcode && left.revision === right.revision && names3.length === Object.keys(right.arguments).length && names3.every((name) => {
+    const a = left.arguments[name];
+    const b = Object.hasOwn(right.arguments, name) ? right.arguments[name] : void 0;
+    return b !== void 0 && a.kind === b.kind && (a.kind === "reporter" || b.kind === "literal" && a.value === b.value);
+  });
+}
+
+// dist/fixed-input-branches.js
+var fail = () => {
+  throw new TypeError("Invalid fixed branch declaration.");
+};
+var names = (value) => {
+  if (!Array.isArray(value) || !value.length || value.some((item) => typeof item !== "string" || !item) || new Set(value).size !== value.length)
+    return fail();
+  return Object.freeze(value);
+};
+var object = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return fail();
+  return value;
+};
+var normalize = (value, rule) => {
+  var _a, _b;
+  const text2 = ((_a = rule.normalize) === null || _a === void 0 ? void 0 : _a.trim) ? value.trim() : value;
+  return ((_b = rule.normalize) === null || _b === void 0 ? void 0 : _b.lowercase) ? text2.toLowerCase() : text2;
+};
+function captureFixedBranchRules(value, dependencies2, readOnlyArguments) {
+  if (value === void 0)
+    return Object.freeze([]);
+  const captured = snapshotJson(value);
+  if (!Array.isArray(captured))
+    return fail();
+  const selectors = /* @__PURE__ */ new Set();
+  const occupied = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of captured) {
+    const rule = object(item);
+    if (typeof rule.selector !== "string" || selectors.has(rule.selector))
+      return fail();
+    const group = dependencies2.find((dependency) => dependency.selector === rule.selector);
+    if (!group)
+      return fail();
+    for (const argument of [group.selector, ...group.dependents]) {
+      if (occupied.has(argument) || dependencies2.some((other) => other !== group && (other.selector === argument || other.dependents.includes(argument))))
+        return fail();
+      occupied.add(argument);
+    }
+    selectors.add(rule.selector);
+    let normalization;
+    if (rule.normalize !== void 0) {
+      const input = object(rule.normalize);
+      if (Object.keys(input).some((key) => key !== "trim" && key !== "lowercase") || Object.values(input).some((value2) => typeof value2 !== "boolean"))
+        return fail();
+      normalization = Object.freeze({ ...input });
+    }
+    const shell = { selector: rule.selector, cases: [], ...normalization ? { normalize: normalization } : {} };
+    if (!Array.isArray(rule.cases) || !rule.cases.length)
+      return fail();
+    const values = /* @__PURE__ */ new Set();
+    const cases = [];
+    for (const input of rule.cases) {
+      const branch = object(input);
+      const caseValues = names(branch.values);
+      const normalized = caseValues.map((value2) => normalize(value2, shell));
+      if (normalized.some((value2) => !value2 || values.has(value2)))
+        return fail();
+      for (const value2 of normalized)
+        values.add(value2);
+      if (new Set(normalized).size !== normalized.length)
+        return fail();
+      if (!Array.isArray(branch.activeDependents))
+        return fail();
+      const active = branch.activeDependents.length ? names(branch.activeDependents) : Object.freeze([]);
+      if (active.some((argument) => !group.dependents.includes(argument)))
+        return fail();
+      const requirements = [];
+      if (branch.requireOnSelectorChange !== void 0) {
+        if (!Array.isArray(branch.requireOnSelectorChange))
+          return fail();
+        const required = /* @__PURE__ */ new Set();
+        for (const input2 of branch.requireOnSelectorChange) {
+          const requirement = object(input2);
+          if (typeof requirement.argument !== "string" || !readOnlyArguments.includes(requirement.argument) || required.has(requirement.argument) || requirement.rule !== "literal" && requirement.rule !== "nonempty-string")
+            return fail();
+          required.add(requirement.argument);
+          requirements.push(Object.freeze({ argument: requirement.argument, rule: requirement.rule }));
+        }
+      }
+      cases.push(Object.freeze({
+        values: caseValues,
+        activeDependents: active,
+        ...branch.requireOnSelectorChange === void 0 ? {} : { requireOnSelectorChange: Object.freeze(requirements) }
+      }));
+    }
+    result.push(Object.freeze({ ...shell, cases: Object.freeze(cases) }));
+  }
+  return Object.freeze(result);
+}
+function resolveFixedBranches(declaration, snapshot, arguments_ = snapshot.arguments) {
+  var _a;
+  return Object.freeze(((_a = declaration.branchRules) !== null && _a !== void 0 ? _a : []).map((rule) => {
+    const metadata = snapshot.fixedContext.inputs[rule.selector];
+    const slot = arguments_[rule.selector];
+    let status;
+    if (!metadata || metadata.source === "missing")
+      status = "missing";
+    else if (metadata.source === "reporter" || (slot === null || slot === void 0 ? void 0 : slot.kind) === "reporter")
+      status = "reporter";
+    else if (metadata.source !== "field" && metadata.source !== "shadow" || metadata.role !== "editable")
+      status = "unsupported";
+    else if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== "literal" || typeof slot.value !== "string")
+      status = "unknown";
+    else {
+      const value = normalize(slot.value, rule);
+      const selected = rule.cases.find((branch) => branch.values.some((item) => normalize(item, rule) === value));
+      if (selected)
+        return Object.freeze({
+          selector: rule.selector,
+          rule,
+          selected,
+          status: slot.value === selected.values[0] ? "known" : "alias",
+          value: selected.values[0]
+        });
+      status = "unknown";
+    }
+    return Object.freeze({ selector: rule.selector, rule, status });
+  }));
+}
+var writableLiteral = (snapshot, arguments_, name) => {
+  var _a;
+  const metadata = snapshot.fixedContext.inputs[name];
+  return ((_a = arguments_[name]) === null || _a === void 0 ? void 0 : _a.kind) === "literal" && (metadata === null || metadata === void 0 ? void 0 : metadata.role) === "editable" && (metadata.source === "field" || metadata.source === "shadow");
+};
+var diagnostic = (declaration, code, argument) => Object.freeze({
+  message: `Fixed branch validation failed: ${code}; contract=${JSON.stringify(declaration.contractId)}.`,
+  path: `/${argument.replace(/~/g, "~0").replace(/\//g, "~1")}`
+});
+function validateFixedBranchChanges(declaration, snapshot, changes) {
+  var _a;
+  const issues = [];
+  const finalArguments = { ...snapshot.arguments };
+  const changed = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    if (seen.has(change.argument) || !["string", "number", "boolean"].includes(typeof change.value) || !declaration.editableArguments.includes(change.argument) || !writableLiteral(snapshot, snapshot.arguments, change.argument)) {
+      issues.push(diagnostic(declaration, "disallowed-change", change.argument));
+      continue;
+    }
+    seen.add(change.argument);
+    const original = snapshot.arguments[change.argument];
+    if ((original === null || original === void 0 ? void 0 : original.kind) === "literal" && Object.is(original.value, change.value))
+      continue;
+    changed.add(change.argument);
+    Object.defineProperty(finalArguments, change.argument, { value: { kind: "literal", value: change.value }, enumerable: true, configurable: true });
+  }
+  const resolved = resolveFixedBranches(declaration, snapshot, finalArguments);
+  for (const group of declaration.dependencies) {
+    if (![group.selector, ...group.dependents].some((name) => changed.has(name)))
+      continue;
+    const branch = resolved.find((item) => item.selector === group.selector);
+    if (!(branch === null || branch === void 0 ? void 0 : branch.selected)) {
+      issues.push(diagnostic(declaration, branch ? "selector-unavailable" : "fixed-dependency-validation-unavailable", group.selector));
+      continue;
+    }
+    for (const argument of group.dependents) {
+      if (changed.has(argument) && !branch.selected.activeDependents.includes(argument)) {
+        issues.push(diagnostic(declaration, "inactive-change", argument));
+      }
+    }
+    if (!changed.has(group.selector))
+      continue;
+    for (const argument of branch.selected.activeDependents) {
+      if (!writableLiteral(snapshot, finalArguments, argument))
+        issues.push(diagnostic(declaration, "dependency-unverifiable", argument));
+    }
+    for (const requirement of (_a = branch.selected.requireOnSelectorChange) !== null && _a !== void 0 ? _a : []) {
+      const metadata = snapshot.fixedContext.inputs[requirement.argument];
+      const slot = finalArguments[requirement.argument];
+      if (!metadata || metadata.role !== "readonly" || metadata.source !== "field" && metadata.source !== "shadow" || (slot === null || slot === void 0 ? void 0 : slot.kind) !== "literal") {
+        issues.push(diagnostic(declaration, "dependency-unverifiable", requirement.argument));
+      } else if (requirement.rule === "nonempty-string" && (typeof slot.value !== "string" || !slot.value.trim())) {
+        issues.push(diagnostic(declaration, "dependency-invalid", requirement.argument));
+      }
+    }
+  }
+  return Object.freeze(issues);
+}
+
+// dist/fixed-input-snapshot.js
+function fail2() {
+  throw new TypeError("Invalid fixed-input contract or snapshot.");
+}
+function own(value, key) {
+  if (!value || typeof value !== "object")
+    return fail2();
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  if (!descriptor || !("value" in descriptor))
+    return fail2();
+  return descriptor.value;
+}
+function text(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return fail2();
+  return value;
+}
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return fail2();
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    return fail2();
+  if (Object.getOwnPropertySymbols(value).length)
+    return fail2();
+  return value;
+}
+function names2(value) {
+  if (!Array.isArray(value))
+    return fail2();
+  const items = [];
+  for (let i = 0; i < value.length; i++)
+    items.push(text(own(value, String(i))));
+  if (new Set(items).size !== items.length)
+    return fail2();
+  return Object.freeze(items);
+}
+function dependencies(value, editable) {
+  if (!Array.isArray(value))
+    return fail2();
+  const selectors = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let i = 0; i < value.length; i++) {
+    const item = record(own(value, String(i)));
+    const selector = text(own(item, "selector"));
+    const dependents = names2(own(item, "dependents"));
+    if (!editable.has(selector) || selectors.has(selector) || dependents.length === 0 || dependents.some((name) => name === selector || !editable.has(name)))
+      return fail2();
+    selectors.add(selector);
+    result.push(Object.freeze({ selector, dependents }));
+  }
+  return Object.freeze(result);
+}
+function captureFixedInputDeclaration(value) {
+  const policy = Object.getOwnPropertyDescriptor(value, "branchRules");
+  if (policy && !("value" in policy))
+    return fail2();
+  const captured = record(snapshotJson({
+    contractId: own(value, "contractId"),
+    contractRevision: own(value, "contractRevision"),
+    editableArguments: own(value, "editableArguments"),
+    readOnlyArguments: own(value, "readOnlyArguments"),
+    dependencies: own(value, "dependencies")
+  }));
+  const editableArguments = names2(captured.editableArguments);
+  const readOnlyArguments = names2(captured.readOnlyArguments);
+  const editable = new Set(editableArguments);
+  if (editable.size === 0 || readOnlyArguments.some((name) => editable.has(name)))
+    return fail2();
+  const groups = dependencies(captured.dependencies, editable);
+  const branchRules = captureFixedBranchRules(policy === null || policy === void 0 ? void 0 : policy.value, groups, readOnlyArguments);
+  return Object.freeze({
+    contractId: text(captured.contractId),
+    contractRevision: text(captured.contractRevision),
+    editableArguments,
+    readOnlyArguments,
+    dependencies: groups,
+    ...(policy === null || policy === void 0 ? void 0 : policy.value) === void 0 ? {} : { branchRules }
+  });
+}
+function canonical(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  const item = value;
+  return `{${Object.keys(item).sort().map((key) => `${JSON.stringify(key)}:${canonical(item[key])}`).join(",")}}`;
+}
+function sameNames(left, right) {
+  return left.length === right.length && left.every((name) => right.includes(name));
+}
+function captureFixedSnapshot(value, reference, declaration) {
+  record(value);
+  const targetId = text(own(value, "targetId"));
+  const blockId = text(own(value, "blockId"));
+  if (reference && (targetId !== own(reference, "targetId") || blockId !== own(reference, "blockId")))
+    return fail2();
+  const opcode = text(own(value, "opcode"));
+  const revision = text(own(value, "revision"));
+  const inputArguments = record(own(value, "arguments"));
+  const argumentsCopy = /* @__PURE__ */ Object.create(null);
+  for (const name of Object.keys(inputArguments)) {
+    const item = record(own(inputArguments, name));
+    const kind = own(item, "kind");
+    if (kind === "reporter")
+      argumentsCopy[name] = Object.freeze({ kind });
+    else if (kind === "literal") {
+      const raw = own(item, "value");
+      if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "boolean")
+        return fail2();
+      argumentsCopy[name] = Object.freeze({ kind, value: raw });
+    } else
+      return fail2();
+  }
+  const context = record(snapshotJson(own(value, "fixedContext")));
+  const contractId = text(context.contractId);
+  const contractRevision = text(context.contractRevision);
+  const generation = text(context.generation);
+  const readOnlyArguments = names2(context.readOnlyArguments);
+  const inputMetadata = record(context.inputs);
+  const editable = /* @__PURE__ */ new Set();
+  const inputs = /* @__PURE__ */ Object.create(null);
+  for (const name of Object.keys(inputMetadata)) {
+    const item = record(inputMetadata[name]);
+    if (item.role !== "editable" && item.role !== "readonly")
+      return fail2();
+    const role = item.role;
+    if (role === "readonly" !== readOnlyArguments.includes(name))
+      return fail2();
+    if (role === "editable")
+      editable.add(name);
+    const source = item.source;
+    if (source !== "shadow" && source !== "field" && source !== "reporter" && source !== "unsupported" && source !== "missing")
+      return fail2();
+    const slot = argumentsCopy[name];
+    if ((source === "shadow" || source === "field") && (slot === null || slot === void 0 ? void 0 : slot.kind) !== "literal")
+      return fail2();
+    if (source === "reporter" && (slot === null || slot === void 0 ? void 0 : slot.kind) !== "reporter")
+      return fail2();
+    if (source === "missing" && (slot === null || slot === void 0 ? void 0 : slot.kind) === "literal")
+      return fail2();
+    let field;
+    if (source === "shadow" || source === "field") {
+      const capturedField = record(item.field);
+      field = Object.freeze({ blockId: text(capturedField.blockId), name: text(capturedField.name), type: text(capturedField.type) });
+    } else if (item.field !== void 0)
+      return fail2();
+    if (item.reason !== void 0 && typeof item.reason !== "string")
+      return fail2();
+    if ((source === "unsupported" || source === "missing") && !item.reason)
+      return fail2();
+    inputs[name] = Object.freeze({
+      role,
+      source,
+      identity: text(item.identity),
+      ...field ? { field } : {},
+      ...item.reason === void 0 ? {} : { reason: item.reason }
+    });
+  }
+  if (readOnlyArguments.some((name) => !Object.hasOwn(inputs, name)))
+    return fail2();
+  const capturedDependencies = dependencies(context.dependencies, editable);
+  if (declaration) {
+    const expected = captureFixedInputDeclaration(declaration);
+    if (contractId !== expected.contractId || contractRevision !== expected.contractRevision || !sameNames([...editable], expected.editableArguments) || !sameNames(readOnlyArguments, expected.readOnlyArguments) || canonical(capturedDependencies) !== canonical(expected.dependencies))
+      return fail2();
+  }
+  return Object.freeze({
+    targetId,
+    blockId,
+    opcode,
+    revision,
+    arguments: Object.freeze(argumentsCopy),
+    fixedContext: Object.freeze({
+      contractId,
+      contractRevision,
+      generation,
+      readOnlyArguments,
+      dependencies: capturedDependencies,
+      inputs: Object.freeze(inputs)
+    })
+  });
+}
+function sameFixedSnapshot(left, right) {
+  const a = captureFixedSnapshot(left);
+  const b = captureFixedSnapshot(right);
+  const keys = Object.keys(a.arguments);
+  return a.targetId === b.targetId && a.blockId === b.blockId && a.opcode === b.opcode && a.revision === b.revision && canonical(a.fixedContext) === canonical(b.fixedContext) && keys.length === Object.keys(b.arguments).length && keys.every((name) => {
+    const x = a.arguments[name];
+    const y = b.arguments[name];
+    return !!y && x.kind === y.kind && (x.kind === "reporter" || y.kind === "literal" && Object.is(x.value, y.value));
+  });
+}
+
+// dist/fixed-input-editor.js
+function fixedDeclarationError() {
+  throw new TypeError("Invalid fixed editor declaration.");
+}
+function plainDeclaration(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null || Object.getOwnPropertySymbols(value).length)
+    fixedDeclarationError();
+}
+function ownData(value, key, optional = false) {
+  if (!value || typeof value !== "object")
+    return fixedDeclarationError();
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  if (!descriptor) {
+    if (optional)
+      return void 0;
+    return fixedDeclarationError();
+  }
+  if (!("value" in descriptor))
+    return fixedDeclarationError();
+  return descriptor.value;
+}
+function declarationText(value) {
+  if (typeof value !== "string" || !value)
+    return fixedDeclarationError();
+  return value;
+}
+function declarationArray(value) {
+  if (!Array.isArray(value) || Object.getOwnPropertySymbols(value).length)
+    return fixedDeclarationError();
+  const length = ownData(value, "length");
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > 1e5)
+    return fixedDeclarationError();
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (key !== "length" && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= length))
+      return fixedDeclarationError();
+  }
+  const items = [];
+  for (let i = 0; i < length; i++)
+    items.push(ownData(value, String(i)));
+  return Object.freeze(items);
+}
+function declarationJson(value) {
+  try {
+    return snapshotJson(value);
+  } catch (_a) {
+    return fixedDeclarationError();
+  }
+}
+function fixedDeclaration(value) {
+  try {
+    return captureFixedInputDeclaration(value);
+  } catch (_a) {
+    return fixedDeclarationError();
+  }
+}
+function captureOpcodes(value, extensionId) {
+  const items = declarationJson(value);
+  if (!Array.isArray(items) || !items.length || items.some((opcode) => typeof opcode !== "string" || !opcode.startsWith(`${extensionId}_`) || opcode === `${extensionId}_`) || new Set(items).size !== items.length)
+    return fixedDeclarationError();
+  return Object.freeze(items);
+}
+function captureFixedInputEditorDefinition(value) {
+  plainDeclaration(value);
+  const apiVersion = ownData(value, "apiVersion");
+  const extensionId = declarationText(ownData(value, "extensionId"));
+  const editorId = declarationText(ownData(value, "editorId"));
+  const saveContract = ownData(value, "saveContract");
+  if (apiVersion !== 1 || saveContract !== "prepared-fixed-v1")
+    return fixedDeclarationError();
+  const opcodes = captureOpcodes(ownData(value, "opcodes"), extensionId);
+  const branchRules = ownData(value, "branchRules", true);
+  const declaration = fixedDeclaration({
+    contractId: declarationText(ownData(value, "contractId")),
+    contractRevision: declarationText(ownData(value, "contractRevision")),
+    editableArguments: ownData(value, "editableArguments"),
+    readOnlyArguments: ownData(value, "readOnlyArguments"),
+    dependencies: ownData(value, "dependencies"),
+    ...branchRules === void 0 ? {} : { branchRules }
+  });
+  const read = ownData(value, "read");
+  const validate = ownData(value, "validate");
+  const createPatch = ownData(value, "createPatch");
+  const readFixed = ownData(value, "readFixed");
+  const prepareFixedSave = ownData(value, "prepareFixedSave");
+  const mount = ownData(value, "mount", true);
+  const describeFixed = ownData(value, "describeFixed", true);
+  if (typeof read !== "function" || typeof validate !== "function" || typeof createPatch !== "function" || typeof readFixed !== "function" || typeof prepareFixedSave !== "function" || mount !== void 0 && typeof mount !== "function" || describeFixed !== void 0 && typeof describeFixed !== "function")
+    return fixedDeclarationError();
+  return Object.freeze({
+    apiVersion,
+    extensionId,
+    editorId,
+    opcodes,
+    saveContract,
+    ...declaration,
+    read,
+    validate,
+    createPatch,
+    readFixed,
+    prepareFixedSave,
+    ...describeFixed === void 0 ? {} : { describeFixed },
+    ...mount === void 0 ? {} : { mount }
+  });
+}
+function drain(value) {
+  try {
+    void Promise.prototype.then.call(value, () => void 0, () => void 0);
+  } catch (_a) {
+  }
+}
+function copySync(value) {
+  try {
+    return snapshotJson(value);
+  } catch (error) {
+    drain(value);
+    throw error;
+  }
+}
+function freeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+  }
+}
+function sameProjection(left, right) {
+  if (Object.is(left, right))
+    return true;
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+    return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameProjection(value, right[index]));
+  }
+  const names3 = Object.keys(left);
+  return names3.length === Object.keys(right).length && names3.every((name) => Object.hasOwn(right, name) && sameProjection(left[name], right[name]));
+}
+var pointer = (name) => `/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+function isFixedInputEditor(definition) {
+  return definition.saveContract === "prepared-fixed-v1";
+}
+function captureFixedPreparedSave(definition, draft, snapshot) {
+  const value = copySync(definition.prepareFixedSave(draft, snapshot));
+  if (!isJsonRecord(value))
+    throw new TypeError("Invalid fixed prepared save.");
+  if (value.kind === "invalid" && Array.isArray(value.issues) && value.issues.length > 0) {
+    const issues = [];
+    for (let i = 0; i < value.issues.length; i++) {
+      const issue = value.issues[i];
+      if (!isJsonRecord(issue) || typeof issue.message !== "string" || issue.path !== void 0 && typeof issue.path !== "string")
+        throw new TypeError("Invalid fixed issue.");
+      issues.push(Object.freeze({ message: issue.message, ...issue.path === void 0 ? {} : { path: issue.path } }));
+    }
+    return Object.freeze({ kind: "invalid", issues: Object.freeze(issues) });
+  }
+  if (value.kind !== "ready" || !Array.isArray(value.changes) || !isJsonRecord(value.context) || typeof value.context.consumerId !== "string" || !value.context.consumerId || typeof value.context.nowMs !== "number" || !Number.isFinite(value.context.nowMs) || !Object.hasOwn(value.context, "settings"))
+    throw new TypeError("Invalid fixed prepared save.");
+  const changes = [];
+  for (let i = 0; i < value.changes.length; i++) {
+    const change = value.changes[i];
+    if (!isJsonRecord(change) || typeof change.argument !== "string" || !isLiteral(change.value))
+      throw new TypeError("Invalid fixed change.");
+    changes.push(Object.freeze({ argument: change.argument, value: change.value }));
+  }
+  freeze(value.context);
+  return Object.freeze({ kind: "ready", changes: Object.freeze(changes), context: value.context });
+}
+function createFixedInputEditor(options) {
+  var _a;
+  plainDeclaration(options);
+  const apiVersion = ownData(options, "apiVersion");
+  const extensionId = declarationText(ownData(options, "extensionId"));
+  const editorId = declarationText(ownData(options, "editorId"));
+  const contractId = declarationText(ownData(options, "contractId"));
+  const contractRevision = declarationText(ownData(options, "contractRevision"));
+  const contextProvider = ownData(options, "validationContext");
+  const opcodes = captureOpcodes(ownData(options, "opcodes"), extensionId);
+  const inputBindings = declarationArray(ownData(options, "bindings"));
+  const readOnlyArguments = ownData(options, "readOnlyArguments", true);
+  const dependencies2 = ownData(options, "dependencies", true);
+  const branchPolicies = ownData(options, "branchPolicies", true);
+  if (apiVersion !== 1 || !inputBindings.length || typeof contextProvider !== "function")
+    throw new TypeError("Invalid fixed editor options.");
+  const provider = contextProvider;
+  const compileBinding = (binding) => {
+    plainDeclaration(binding);
+    const argument = declarationText(ownData(binding, "argument"));
+    const read = ownData(binding, "read");
+    const encode = ownData(binding, "encode");
+    const validateCandidate = ownData(binding, "validateCandidate");
+    const schemaBundle = declarationJson(ownData(binding, "schemaBundle"));
+    const inputControl = ownData(binding, "control", true);
+    let control;
+    if (inputControl !== void 0) {
+      const item = declarationJson(inputControl);
+      if (!isJsonRecord(item) || !["text", "number", "enum", "color"].includes(item.kind) || item.label !== void 0 && typeof item.label !== "string" || item.choices !== void 0 && (!Array.isArray(item.choices) || item.choices.some((choice) => !isJsonRecord(choice) || !Object.hasOwn(choice, "value") || choice.label !== void 0 && typeof choice.label !== "string")))
+        return fixedDeclarationError();
+      freeze(item);
+      control = item;
+    }
+    if (typeof read !== "function" || typeof encode !== "function" || typeof validateCandidate !== "function")
+      throw new TypeError("Invalid fixed binding callbacks.");
+    const result = compileSchemaBundle(schemaBundle);
+    if (result.kind !== "compiled")
+      throw new TypeError("Invalid fixed input schema.");
+    freeze(schemaBundle);
+    return Object.freeze({
+      argument,
+      read,
+      encode,
+      validateCandidate,
+      validator: result.validator,
+      schemaBundle,
+      ...control === void 0 ? {} : { control }
+    });
+  };
+  const bindings = inputBindings.map(compileBinding);
+  const policyBindings = [];
+  const policyRules = [];
+  if (branchPolicies !== void 0) {
+    for (const input of declarationArray(branchPolicies)) {
+      plainDeclaration(input);
+      const selector = declarationText(ownData(input, "selector"));
+      const normalization = ownData(input, "normalize", true);
+      const cases = [];
+      const variants = [];
+      for (const caseInput of declarationArray(ownData(input, "cases"))) {
+        plainDeclaration(caseInput);
+        const requirements = ownData(caseInput, "requireOnSelectorChange", true);
+        const overrides = ownData(caseInput, "bindings", true);
+        cases.push({
+          values: declarationJson(ownData(caseInput, "values")),
+          activeDependents: declarationJson(ownData(caseInput, "activeDependents")),
+          ...requirements === void 0 ? {} : { requireOnSelectorChange: declarationJson(requirements) }
+        });
+        variants.push(overrides === void 0 ? [] : declarationArray(overrides).map(compileBinding));
+      }
+      policyRules.push({ selector, cases, ...normalization === void 0 ? {} : { normalize: declarationJson(normalization) } });
+      policyBindings.push(variants);
+    }
+  }
+  const declaration = fixedDeclaration({
+    contractId,
+    contractRevision,
+    editableArguments: bindings.map((binding) => binding.argument),
+    readOnlyArguments: readOnlyArguments !== null && readOnlyArguments !== void 0 ? readOnlyArguments : [],
+    dependencies: dependencies2 !== null && dependencies2 !== void 0 ? dependencies2 : [],
+    ...branchPolicies === void 0 ? {} : { branchRules: policyRules }
+  });
+  for (const [index, rule] of ((_a = declaration.branchRules) !== null && _a !== void 0 ? _a : []).entries()) {
+    const group = declaration.dependencies.find((item) => item.selector === rule.selector);
+    for (const variants of policyBindings[index]) {
+      if (new Set(variants.map((binding) => binding.argument)).size !== variants.length || variants.some((binding) => !group.dependents.includes(binding.argument)))
+        return fixedDeclarationError();
+    }
+  }
+  const diagnostic2 = (code, argument) => Object.freeze({
+    message: `Fixed input validation failed: ${code}; contract=${JSON.stringify(contractId)}${argument === void 0 ? "" : `; argument=${JSON.stringify(argument)}`}.`,
+    ...argument === void 0 ? {} : { path: pointer(argument) }
+  });
+  const literal = (snapshot, argument) => {
+    var _a2;
+    const metadata = snapshot.fixedContext.inputs[argument];
+    return ((_a2 = snapshot.arguments[argument]) === null || _a2 === void 0 ? void 0 : _a2.kind) === "literal" && (metadata === null || metadata === void 0 ? void 0 : metadata.role) === "editable" && (metadata.source === "field" || metadata.source === "shadow");
+  };
+  const project = (binding, snapshot) => {
+    const slot = snapshot.arguments[binding.argument];
+    if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== "literal" || !literal(snapshot, binding.argument))
+      return { readOnly: true };
+    try {
+      return { value: copySync(binding.read(slot.value)), changed: false };
+    } catch (_a2) {
+      return { readOnly: true };
+    }
+  };
+  const entryFor = (draft, argument) => {
+    const entry = isJsonRecord(draft.inputs) && Object.hasOwn(draft.inputs, argument) ? draft.inputs[argument] : void 0;
+    return isJsonRecord(entry) ? entry : void 0;
+  };
+  const selection = (snapshot, draft) => {
+    var _a2;
+    const arguments_ = { ...snapshot.arguments };
+    if (draft)
+      for (const rule of (_a2 = declaration.branchRules) !== null && _a2 !== void 0 ? _a2 : []) {
+        const entry = entryFor(draft, rule.selector);
+        if ((entry === null || entry === void 0 ? void 0 : entry.changed) === true && Object.hasOwn(entry, "value") && isLiteral(entry.value)) {
+          Object.defineProperty(arguments_, rule.selector, { value: { kind: "literal", value: entry.value }, enumerable: true });
+        }
+      }
+    const branches = resolveFixedBranches(declaration, snapshot, arguments_);
+    const selected = new Map(bindings.map((binding) => [binding.argument, binding]));
+    const states = /* @__PURE__ */ new Map();
+    const unruled = /* @__PURE__ */ new Set();
+    for (const group of declaration.dependencies) {
+      if (branches.some((branch) => branch.selector === group.selector))
+        continue;
+      for (const argument of [group.selector, ...group.dependents]) {
+        states.set(argument, "readonly");
+        unruled.add(argument);
+      }
+    }
+    for (const [policyIndex, branch] of branches.entries()) {
+      const group = declaration.dependencies.find((item) => item.selector === branch.selector);
+      if (!branch.selected) {
+        for (const argument of group.dependents)
+          states.set(argument, "readonly");
+        continue;
+      }
+      for (const argument of group.dependents)
+        if (!branch.selected.activeDependents.includes(argument))
+          states.set(argument, "hidden");
+      const caseIndex = branch.rule.cases.indexOf(branch.selected);
+      for (const binding of policyBindings[policyIndex][caseIndex])
+        selected.set(binding.argument, binding);
+    }
+    return { branches, bindings: [...selected.values()], states, unruled };
+  };
+  const initialProjection = (argument, snapshot) => {
+    const binding = selection(snapshot).bindings.find((item) => item.argument === argument);
+    return project(binding, snapshot);
+  };
+  const parseEntry = (_binding, entry, original) => {
+    if (original.readOnly === true) {
+      if (sameProjection(original, entry))
+        return { changed: false, value: null };
+      if (entry.repair !== true)
+        throw new TypeError();
+    }
+    if (!Object.hasOwn(entry, "value") || typeof entry.changed !== "boolean" || entry.readOnly === true)
+      throw new TypeError();
+    let value = copySync(entry.value);
+    let token;
+    if (Object.hasOwn(entry, "buffer")) {
+      if (!entry.changed || typeof entry.buffer !== "string")
+        throw new TypeError();
+      const parsed = parseFixedNumberInput(entry.buffer);
+      if (parsed.kind !== "valid" || typeof value !== "number" || !Object.is(parsed.value, value))
+        throw new TypeError();
+      token = parsed.token;
+      value = token;
+    }
+    if (token === void 0 && original.readOnly !== true && sameProjection(original.value, value))
+      return { changed: false, value };
+    if (!entry.changed)
+      throw new TypeError();
+    return { changed: true, value, ...token === void 0 ? {} : { token } };
+  };
+  const validateExact = (binding, candidate, context, snapshot) => {
+    const projectedCandidate = copySync(binding.read(candidate));
+    if (binding.validator.validate(projectedCandidate, { consumerId: context.consumerId }).kind !== "valid")
+      return diagnostic2("schema-data-invalid", binding.argument);
+    const owner = copySync(binding.validateCandidate(candidate, context, snapshot));
+    if (!Array.isArray(owner))
+      throw new TypeError();
+    for (const issue of owner) {
+      if (!isJsonRecord(issue) || typeof issue.message !== "string" || issue.path !== void 0 && typeof issue.path !== "string")
+        throw new TypeError();
+    }
+    return owner.length ? diagnostic2("owner-input-invalid", binding.argument) : void 0;
+  };
+  const description = (draft, snapshot) => {
+    const current = selection(snapshot, draft);
+    const inputs = /* @__PURE__ */ Object.create(null);
+    const issues = [];
+    const changes = [];
+    const describe = (argument, binding) => {
+      var _a2, _b, _c, _d;
+      const metadata = snapshot.fixedContext.inputs[argument];
+      const slot = snapshot.arguments[argument];
+      const entry = entryFor(draft, argument);
+      const projected = binding ? project(binding, snapshot) : void 0;
+      const schema = binding === null || binding === void 0 ? void 0 : binding.schemaBundle.root.document;
+      const schemaType = schema && typeof schema === "object" && !Array.isArray(schema) ? schema.type : void 0;
+      const value = (_a2 = entry === null || entry === void 0 ? void 0 : entry.value) !== null && _a2 !== void 0 ? _a2 : projected === null || projected === void 0 ? void 0 : projected.value;
+      const valueType = schemaType === "number" || schemaType === "integer" ? "number" : schemaType === "string" ? "string" : typeof value === "number" ? "number" : "string";
+      const explicit = binding === null || binding === void 0 ? void 0 : binding.control;
+      const state = (_b = current.states.get(argument)) !== null && _b !== void 0 ? _b : binding && literal(snapshot, argument) ? "editable" : "readonly";
+      const schemaEnum = schema && typeof schema === "object" && !Array.isArray(schema) ? schema.enum : void 0;
+      const choices = (_c = explicit === null || explicit === void 0 ? void 0 : explicit.choices) !== null && _c !== void 0 ? _c : Array.isArray(schemaEnum) ? schemaEnum.map((value2) => ({ value: value2 })) : void 0;
+      const control = (_d = explicit === null || explicit === void 0 ? void 0 : explicit.kind) !== null && _d !== void 0 ? _d : choices ? "enum" : valueType === "number" ? "number" : "text";
+      const rawDisplay = (slot === null || slot === void 0 ? void 0 : slot.kind) === "literal" ? String(slot.value) : void 0;
+      const reason = state === "hidden" ? "Inactive branch; its draft is retained and is not saved." : current.states.get(argument) === "readonly" ? "The selector is unavailable; the dependent input is read-only." : state === "readonly" ? "This input is read-only; connected expressions are not evaluated." : void 0;
+      inputs[argument] = Object.freeze({
+        state,
+        control,
+        valueType,
+        ...rawDisplay === void 0 ? {} : { rawDisplay },
+        ...(explicit === null || explicit === void 0 ? void 0 : explicit.label) === void 0 ? {} : { label: explicit.label },
+        ...choices === void 0 ? {} : { choices },
+        ...explicit && Object.hasOwn(explicit, "reset") ? { reset: explicit.reset } : {},
+        ...reason === void 0 ? {} : { reason },
+        ...(metadata === null || metadata === void 0 ? void 0 : metadata.source) === "reporter" ? { unverified: true } : {}
+      });
+      if (!binding || state !== "editable" || !entry)
+        return;
+      try {
+        const parsed = parseEntry(binding, entry, initialProjection(argument, snapshot));
+        if (!parsed.changed)
+          return;
+        const projection = parsed.token === void 0 ? parsed.value : parseFixedNumberInput(parsed.token);
+        const data = typeof projection === "object" && projection !== null && "kind" in projection && projection.kind === "valid" ? projection.value : projection;
+        if (binding.validator.validate(data, { consumerId: contractId }).kind !== "valid")
+          issues.push(diagnostic2("schema-data-invalid", argument));
+        if (isLiteral(parsed.value))
+          changes.push({ argument, value: parsed.value });
+      } catch (_e) {
+        issues.push(diagnostic2("fixed-input-invalid", argument));
+      }
+    };
+    for (const binding of current.bindings)
+      describe(binding.argument, binding);
+    for (const argument of declaration.readOnlyArguments)
+      describe(argument);
+    issues.push(...validateFixedBranchChanges(declaration, snapshot, changes));
+    for (const branch of current.branches) {
+      if (!branch.selected || !changes.some((change) => change.argument === branch.selector))
+        continue;
+      for (const argument of branch.selected.activeDependents) {
+        if (changes.some((change) => change.argument === argument))
+          continue;
+        const binding = current.bindings.find((binding2) => binding2.argument === argument);
+        const slot = snapshot.arguments[argument];
+        if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== "literal")
+          continue;
+        try {
+          const projected = copySync(binding.read(slot.value));
+          if (binding.validator.validate(projected, { consumerId: contractId }).kind !== "valid")
+            issues.push(diagnostic2("schema-data-invalid", argument));
+        } catch (_a2) {
+          issues.push(diagnostic2("fixed-input-invalid", argument));
+        }
+      }
+    }
+    return Object.freeze({ inputs: Object.freeze(inputs), issues: Object.freeze(issues), branches: Object.freeze(current.branches.map(({ selector, status, value }) => Object.freeze({ selector, status, ...value === void 0 ? {} : { value } }))) });
+  };
+  return Object.freeze({
+    apiVersion,
+    extensionId,
+    editorId,
+    opcodes,
+    ...declaration,
+    saveContract: "prepared-fixed-v1",
+    read: () => {
+      throw new TypeError("Fixed editors require a compatible host.");
+    },
+    validate: () => [diagnostic2("fixed-host-required")],
+    createPatch: () => {
+      throw new TypeError("Fixed editors require a compatible host.");
+    },
+    readFixed: (snapshot) => {
+      const inputs = {};
+      for (const binding of selection(snapshot).bindings)
+        Object.defineProperty(inputs, binding.argument, { value: project(binding, snapshot), enumerable: true });
+      return { inputs };
+    },
+    describeFixed: description,
+    prepareFixedSave: (draft, snapshot) => {
+      const issues = [];
+      const changes = [];
+      let context;
+      try {
+        const value = copySync(provider());
+        if (!isJsonRecord(value) || typeof value.consumerId !== "string" || !value.consumerId || typeof value.nowMs !== "number" || !Number.isFinite(value.nowMs) || !Object.hasOwn(value, "settings"))
+          throw new TypeError();
+        freeze(value);
+        context = value;
+      } catch (_a2) {
+        return { kind: "invalid", issues: [diagnostic2("owner-context-invalid")] };
+      }
+      const current = selection(snapshot, draft);
+      const candidates = /* @__PURE__ */ new Map();
+      const finalArguments = { ...snapshot.arguments };
+      for (const binding of current.bindings) {
+        const { argument } = binding;
+        try {
+          const entry = entryFor(draft, argument);
+          if (!entry)
+            throw new TypeError();
+          if (current.states.get(argument) === "hidden")
+            continue;
+          if (current.states.get(argument) === "readonly") {
+            if (sameProjection(project(binding, snapshot), entry))
+              continue;
+            if (current.unruled.has(argument)) {
+              issues.push(diagnostic2("fixed-dependency-validation-unavailable", argument));
+              continue;
+            }
+            throw new TypeError();
+          }
+          const original = initialProjection(argument, snapshot);
+          if (!literal(snapshot, argument)) {
+            if (sameProjection(original, entry))
+              continue;
+            throw new TypeError();
+          }
+          const parsed = parseEntry(binding, entry, original);
+          if (!parsed.changed)
+            continue;
+          const raw = binding.encode(parsed.value, context);
+          if (!isLiteral(raw)) {
+            drain(raw);
+            throw new TypeError();
+          }
+          if (parsed.token !== void 0 && raw !== parsed.token)
+            throw new TypeError();
+          candidates.set(argument, raw);
+          Object.defineProperty(finalArguments, argument, { value: { kind: "literal", value: raw }, enumerable: true, configurable: true });
+          const slot = snapshot.arguments[argument];
+          if ((slot === null || slot === void 0 ? void 0 : slot.kind) === "literal" && !Object.is(raw, slot.value))
+            changes.push(Object.freeze({ argument, value: raw }));
+        } catch (_b) {
+          issues.push(diagnostic2("fixed-input-invalid", argument));
+        }
+      }
+      issues.push(...validateFixedBranchChanges(declaration, snapshot, changes));
+      const finalBranches = resolveFixedBranches(declaration, snapshot, finalArguments);
+      for (let index = 0; index < current.branches.length; index++) {
+        if (current.branches[index].selected !== finalBranches[index].selected)
+          issues.push(diagnostic2("selector-codec-mismatch", current.branches[index].selector));
+      }
+      const validateNames = new Set(candidates.keys());
+      for (const branch of finalBranches)
+        if (branch.selected && changes.some((change) => change.argument === branch.selector)) {
+          for (const argument of branch.selected.activeDependents)
+            validateNames.add(argument);
+        }
+      const finalSnapshot = captureFixedSnapshot({ ...snapshot, arguments: finalArguments }, snapshot, declaration);
+      for (const argument of validateNames) {
+        const binding = current.bindings.find((binding2) => binding2.argument === argument);
+        const slot = finalArguments[argument];
+        if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== "literal")
+          continue;
+        try {
+          const issue = validateExact(binding, slot.value, context, finalSnapshot);
+          if (issue)
+            issues.push(issue);
+        } catch (_c) {
+          issues.push(diagnostic2("fixed-input-invalid", argument));
+        }
+      }
+      return issues.length ? { kind: "invalid", issues } : { kind: "ready", changes, context };
+    }
+  });
+}
+
+// dist/fixed-input-types.js
+var FIXED_INPUTS_CAPABILITY = "fixed-inputs-v1";
+function supportsFixedInputs(host) {
+  const data = (object2, key) => {
+    let item = object2;
+    for (let depth = 0; item && (typeof item === "object" || typeof item === "function") && depth < 64; depth++) {
+      const descriptor = Object.getOwnPropertyDescriptor(item, key);
+      if (descriptor)
+        return "value" in descriptor ? descriptor.value : void 0;
+      item = Object.getPrototypeOf(item);
+    }
+    return void 0;
+  };
+  try {
+    const port = data(host, "fixedInputs");
+    return data(port, "capability") === FIXED_INPUTS_CAPABILITY && typeof data(port, "readBlock") === "function" && typeof data(port, "commit") === "function";
+  } catch (_a) {
+    return false;
+  }
+}
+var supportsFixedInputEditing = supportsFixedInputs;
+
+// dist/view.js
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var _EditorView_unmount;
+var _EditorView_mounting;
+var EditorView = class {
+  constructor() {
+    _EditorView_unmount.set(this, void 0);
+    _EditorView_mounting.set(this, false);
+  }
+  mount(container, mount, owner) {
+    if (owner.getState().status !== "editing" || __classPrivateFieldGet(this, _EditorView_unmount, "f") || __classPrivateFieldGet(this, _EditorView_mounting, "f")) {
+      throw new Error("The session cannot mount another view.");
+    }
+    if (!mount)
+      throw new Error("No editor view is registered.");
+    let active = true;
+    const subscriptions = /* @__PURE__ */ new Set();
+    const assertMounted = () => {
+      if (!active)
+        throw new Error("The editor view is unmounted.");
+    };
+    const release = () => {
+      active = false;
+      for (const unsubscribe of subscriptions)
+        unsubscribe();
+      subscriptions.clear();
+    };
+    const context = Object.freeze({
+      getDraft: () => owner.getDraft(),
+      ...owner.getFixedInputView ? { getFixedInputView: () => {
+        assertMounted();
+        return owner.getFixedInputView();
+      } } : {},
+      setDraft: (draft) => {
+        assertMounted();
+        owner.setDraft(draft);
+      },
+      setValidationIssues: (issues) => {
+        assertMounted();
+        owner.setValidationIssues(issues);
+      },
+      getState: () => owner.getState(),
+      subscribe: (listener) => {
+        assertMounted();
+        const unsubscribe = owner.subscribe(() => {
+          if (active)
+            listener();
+        });
+        const remove = () => {
+          subscriptions.delete(remove);
+          unsubscribe();
+        };
+        subscriptions.add(remove);
+        return remove;
+      }
+    });
+    __classPrivateFieldSet(this, _EditorView_mounting, true, "f");
+    let cleanup;
+    try {
+      cleanup = mount(container, context);
+      if (typeof cleanup !== "function")
+        throw new TypeError("mount() must return a cleanup function.");
+    } catch (error) {
+      release();
+      throw error;
+    } finally {
+      __classPrivateFieldSet(this, _EditorView_mounting, false, "f");
+    }
+    if (owner.getState().status !== "editing" && owner.getState().status !== "saving") {
+      release();
+      cleanup();
+      return () => {
+      };
+    }
+    const unmount = () => {
+      if (!active)
+        return;
+      release();
+      __classPrivateFieldSet(this, _EditorView_unmount, void 0, "f");
+      cleanup();
+    };
+    __classPrivateFieldSet(this, _EditorView_unmount, unmount, "f");
+    return unmount;
+  }
+  unmount() {
+    var _a;
+    (_a = __classPrivateFieldGet(this, _EditorView_unmount, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+  }
+};
+_EditorView_unmount = /* @__PURE__ */ new WeakMap(), _EditorView_mounting = /* @__PURE__ */ new WeakMap();
+
+// dist/prepared-save.js
+function isPreparedEditor(definition) {
+  return definition.saveContract === "prepared-source-v1";
+}
+function capturePreparedSave(definition, draft, snapshot) {
+  const output = definition.prepareSave(draft, snapshot);
+  try {
+    const value = snapshotJson(output);
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new TypeError("Invalid prepared save.");
+    const result = value;
+    if (result.kind === "ready" && Array.isArray(result.changes)) {
+      const changes = [];
+      for (let i = 0; i < result.changes.length; i++) {
+        const change = result.changes[i];
+        if (!change || typeof change.argument !== "string" || !(typeof change.value === "string" || typeof change.value === "boolean" || typeof change.value === "number" && Number.isFinite(change.value))) {
+          throw new TypeError("Invalid prepared change.");
+        }
+        changes.push(Object.freeze({ argument: change.argument, value: change.value }));
+      }
+      return Object.freeze({ kind: "ready", changes: Object.freeze(changes) });
+    }
+    if (result.kind === "invalid" && Array.isArray(result.issues) && result.issues.length > 0) {
+      const issues = [];
+      for (let i = 0; i < result.issues.length; i++) {
+        const issue = result.issues[i];
+        if (!issue || typeof issue.message !== "string" || issue.path !== void 0 && typeof issue.path !== "string") {
+          throw new TypeError("Invalid prepared issue.");
+        }
+        issues.push(Object.freeze({ message: issue.message, ...issue.path === void 0 ? {} : { path: issue.path } }));
+      }
+      return Object.freeze({ kind: "invalid", issues: Object.freeze(issues) });
+    }
+    throw new TypeError("Invalid prepared save.");
+  } catch (error) {
+    try {
+      void Promise.prototype.then.call(output, () => void 0, () => void 0);
+    } catch (_a) {
+    }
+    throw error;
+  }
+}
+
+// dist/session.js
+var __classPrivateFieldSet2 = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet2 = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EditorSession_instances;
+var _EditorSession_draft;
+var _EditorSession_status;
+var _EditorSession_issues;
+var _EditorSession_error;
+var _EditorSession_listeners;
+var _EditorSession_view;
+var _EditorSession_definition;
+var _EditorSession_snapshot;
+var _EditorSession_host;
+var _EditorSession_fixedPort;
+var _EditorSession_isRegistered;
+var _EditorSession_subscribeRegistrationChanges;
+var _EditorSession_unsubscribeFixedScope;
+var _EditorSession_unsubscribeFixedRegistration;
+var _EditorSession_fixedSavingController;
+var _EditorSession_saveFixed;
+var _EditorSession_prepareChanges;
+var _EditorSession_copyIssues;
+var _EditorSession_copyDraft;
+var _EditorSession_assertOpen;
+var _EditorSession_finish;
+var _EditorSession_notify;
+var _EditorSession_reportObserverError;
+var EditorSession = class {
+  /** Use EditorRegistry.open() to construct sessions from a captured host snapshot. */
+  constructor(definition, snapshot, host, isRegistered, subscribeRegistrationChanges) {
+    _EditorSession_instances.add(this);
+    _EditorSession_draft.set(this, void 0);
+    _EditorSession_status.set(this, "editing");
+    _EditorSession_issues.set(this, []);
+    _EditorSession_error.set(this, void 0);
+    _EditorSession_listeners.set(this, /* @__PURE__ */ new Set());
+    _EditorSession_view.set(this, new EditorView());
+    _EditorSession_definition.set(this, void 0);
+    _EditorSession_snapshot.set(this, void 0);
+    _EditorSession_host.set(this, void 0);
+    _EditorSession_fixedPort.set(this, void 0);
+    _EditorSession_isRegistered.set(this, void 0);
+    _EditorSession_subscribeRegistrationChanges.set(this, void 0);
+    _EditorSession_unsubscribeFixedScope.set(this, void 0);
+    _EditorSession_unsubscribeFixedRegistration.set(this, void 0);
+    _EditorSession_fixedSavingController.set(this, void 0);
+    __classPrivateFieldSet2(this, _EditorSession_isRegistered, isRegistered, "f");
+    __classPrivateFieldSet2(this, _EditorSession_subscribeRegistrationChanges, subscribeRegistrationChanges, "f");
+    __classPrivateFieldSet2(this, _EditorSession_definition, definition, "f");
+    __classPrivateFieldSet2(this, _EditorSession_snapshot, isFixedInputEditor(definition) ? captureFixedSnapshot(snapshot, captureReference(snapshot), definition) : captureSnapshot(snapshot, captureReference(snapshot)), "f");
+    __classPrivateFieldSet2(this, _EditorSession_host, host, "f");
+    __classPrivateFieldSet2(this, _EditorSession_fixedPort, isFixedInputEditor(definition) && supportsFixedInputEditing(host) ? host.fixedInputs : void 0, "f");
+    if (isFixedInputEditor(definition) && !supportsFixedInputEditing(host))
+      throw new TypeError("Fixed input editors require a compatible host.");
+    __classPrivateFieldSet2(this, _EditorSession_draft, __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, isFixedInputEditor(definition) ? definition.readFixed(__classPrivateFieldGet2(this, _EditorSession_snapshot, "f")) : definition.read(__classPrivateFieldGet2(this, _EditorSession_snapshot, "f"))), "f");
+    if (isFixedInputEditor(definition) && __classPrivateFieldGet2(this, _EditorSession_subscribeRegistrationChanges, "f")) {
+      const unsubscribe = __classPrivateFieldGet2(this, _EditorSession_subscribeRegistrationChanges, "f").call(this, () => {
+        var _a;
+        if (__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this) && (__classPrivateFieldGet2(this, _EditorSession_status, "f") === "editing" || __classPrivateFieldGet2(this, _EditorSession_status, "f") === "saving")) {
+          (_a = __classPrivateFieldGet2(this, _EditorSession_fixedSavingController, "f")) === null || _a === void 0 ? void 0 : _a.abort(new BlockEditorConflictError());
+          __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "disposed");
+        }
+      });
+      if (__classPrivateFieldGet2(this, _EditorSession_status, "f") === "editing")
+        __classPrivateFieldSet2(this, _EditorSession_unsubscribeFixedRegistration, unsubscribe, "f");
+      else
+        unsubscribe();
+    }
+    try {
+      if (isFixedInputEditor(definition) && __classPrivateFieldGet2(this, _EditorSession_fixedPort, "f")) {
+        let subscribe;
+        for (let item = __classPrivateFieldGet2(this, _EditorSession_fixedPort, "f"), depth = 0; item && depth < 64; item = Object.getPrototypeOf(item), depth++) {
+          const property = Object.getOwnPropertyDescriptor(item, "subscribeInvalidation");
+          if (property) {
+            subscribe = "value" in property ? property.value : void 0;
+            break;
+          }
+        }
+        if (typeof subscribe === "function") {
+          const unsubscribe = subscribe.call(__classPrivateFieldGet2(this, _EditorSession_fixedPort, "f"), this.reference, definition, () => {
+            var _a;
+            if (__classPrivateFieldGet2(this, _EditorSession_status, "f") !== "editing" && __classPrivateFieldGet2(this, _EditorSession_status, "f") !== "saving")
+              return;
+            (_a = __classPrivateFieldGet2(this, _EditorSession_fixedSavingController, "f")) === null || _a === void 0 ? void 0 : _a.abort(new BlockEditorConflictError());
+            __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "disposed");
+          });
+          if (typeof unsubscribe !== "function")
+            throw new TypeError("Invalid fixed scope subscription.");
+          if (__classPrivateFieldGet2(this, _EditorSession_status, "f") === "editing")
+            __classPrivateFieldSet2(this, _EditorSession_unsubscribeFixedScope, unsubscribe, "f");
+          else
+            unsubscribe();
+        }
+      }
+    } catch (error) {
+      __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "disposed");
+      throw error;
+    }
+  }
+  /** Stable instance identity remains available after the session closes. */
+  get reference() {
+    return captureReference(__classPrivateFieldGet2(this, _EditorSession_snapshot, "f"));
+  }
+  getDraft() {
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_assertOpen).call(this);
+    return cloneJson(__classPrivateFieldGet2(this, _EditorSession_draft, "f"));
+  }
+  getFixedInputView() {
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_assertOpen).call(this);
+    const definition = __classPrivateFieldGet2(this, _EditorSession_definition, "f");
+    if (!isFixedInputEditor(definition) || !definition.describeFixed)
+      return void 0;
+    let description;
+    try {
+      description = definition.describeFixed(__classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, __classPrivateFieldGet2(this, _EditorSession_draft, "f")), __classPrivateFieldGet2(this, _EditorSession_snapshot, "f"));
+      const captured = snapshotJson(description);
+      if (!isJsonRecord(captured) || !isJsonRecord(captured.inputs) || !Array.isArray(captured.issues) || !Array.isArray(captured.branches)) {
+        throw new TypeError("Invalid fixed input presentation.");
+      }
+      const freeze2 = (value) => {
+        if (value && typeof value === "object") {
+          Object.values(value).forEach(freeze2);
+          Object.freeze(value);
+        }
+      };
+      freeze2(captured);
+      return captured;
+    } catch (_a) {
+      try {
+        void Promise.prototype.then.call(description, () => void 0, () => void 0);
+      } catch (_b) {
+      }
+      throw new TypeError("Invalid fixed input presentation.");
+    }
+  }
+  setDraft(draft) {
+    if (__classPrivateFieldGet2(this, _EditorSession_status, "f") !== "editing")
+      throw new Error("The session is not editable.");
+    __classPrivateFieldSet2(this, _EditorSession_draft, __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, draft), "f");
+    __classPrivateFieldSet2(this, _EditorSession_issues, [], "f");
+    __classPrivateFieldSet2(this, _EditorSession_error, void 0, "f");
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
+  }
+  setValidationIssues(issues) {
+    if (__classPrivateFieldGet2(this, _EditorSession_status, "f") !== "editing")
+      throw new Error("The session is not editable.");
+    __classPrivateFieldSet2(this, _EditorSession_issues, __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_copyIssues).call(this, issues), "f");
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
+  }
+  getState() {
+    return Object.freeze({
+      status: __classPrivateFieldGet2(this, _EditorSession_status, "f"),
+      canSave: __classPrivateFieldGet2(this, _EditorSession_status, "f") === "editing" && __classPrivateFieldGet2(this, _EditorSession_issues, "f").length === 0,
+      issues: __classPrivateFieldGet2(this, _EditorSession_issues, "f"),
+      error: __classPrivateFieldGet2(this, _EditorSession_error, "f")
+    });
+  }
+  subscribe(listener) {
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_assertOpen).call(this);
+    __classPrivateFieldGet2(this, _EditorSession_listeners, "f").add(listener);
+    return () => {
+      __classPrivateFieldGet2(this, _EditorSession_listeners, "f").delete(listener);
+    };
+  }
+  mount(container) {
+    return __classPrivateFieldGet2(this, _EditorSession_view, "f").mount(container, __classPrivateFieldGet2(this, _EditorSession_definition, "f").mount, this);
+  }
+  async save() {
+    if (__classPrivateFieldGet2(this, _EditorSession_status, "f") === "saving")
+      return { status: "busy" };
+    if (__classPrivateFieldGet2(this, _EditorSession_status, "f") !== "editing")
+      return { status: "closed" };
+    __classPrivateFieldSet2(this, _EditorSession_status, "saving", "f");
+    __classPrivateFieldSet2(this, _EditorSession_issues, [], "f");
+    __classPrivateFieldSet2(this, _EditorSession_error, void 0, "f");
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
+    try {
+      if (__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this))
+        throw new BlockEditorConflictError("The source editor registration expired.");
+      if (isFixedInputEditor(__classPrivateFieldGet2(this, _EditorSession_definition, "f")))
+        return await __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_saveFixed).call(this);
+      const prepared = isPreparedEditor(__classPrivateFieldGet2(this, _EditorSession_definition, "f")) ? capturePreparedSave(__classPrivateFieldGet2(this, _EditorSession_definition, "f"), cloneJson(__classPrivateFieldGet2(this, _EditorSession_draft, "f")), __classPrivateFieldGet2(this, _EditorSession_snapshot, "f")) : void 0;
+      const issues = prepared ? prepared.kind === "invalid" ? prepared.issues : [] : await __classPrivateFieldGet2(this, _EditorSession_definition, "f").validate(cloneJson(__classPrivateFieldGet2(this, _EditorSession_draft, "f")), __classPrivateFieldGet2(this, _EditorSession_snapshot, "f"));
+      if (!Array.isArray(issues))
+        throw new TypeError("validate() must return an issue array.");
+      if (issues.length > 0) {
+        __classPrivateFieldSet2(this, _EditorSession_issues, __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_copyIssues).call(this, issues), "f");
+        return { status: "invalid", issues: __classPrivateFieldGet2(this, _EditorSession_issues, "f") };
+      }
+      const changes = __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_prepareChanges).call(this, (prepared === null || prepared === void 0 ? void 0 : prepared.kind) === "ready" ? prepared.changes : __classPrivateFieldGet2(this, _EditorSession_definition, "f").createPatch(cloneJson(__classPrivateFieldGet2(this, _EditorSession_draft, "f")), __classPrivateFieldGet2(this, _EditorSession_snapshot, "f")));
+      if (__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this))
+        throw new BlockEditorConflictError("The source editor registration expired.");
+      const current = __classPrivateFieldGet2(this, _EditorSession_host, "f").readBlock(__classPrivateFieldGet2(this, _EditorSession_snapshot, "f"));
+      if (!current || !sameSnapshot(__classPrivateFieldGet2(this, _EditorSession_snapshot, "f"), captureSnapshot(current, __classPrivateFieldGet2(this, _EditorSession_snapshot, "f")))) {
+        throw new BlockEditorConflictError();
+      }
+      if (__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this))
+        throw new BlockEditorConflictError("The source editor registration expired.");
+      if (changes.length > 0) {
+        await __classPrivateFieldGet2(this, _EditorSession_host, "f").commit(Object.freeze({ expected: __classPrivateFieldGet2(this, _EditorSession_snapshot, "f"), changes }));
+      }
+      __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "saved");
+      return { status: "saved", changed: changes.length > 0 };
+    } catch (error) {
+      __classPrivateFieldSet2(this, _EditorSession_error, error, "f");
+      return error instanceof BlockEditorConflictError ? { status: "conflict", error } : { status: "failed", error };
+    } finally {
+      if (__classPrivateFieldGet2(this, _EditorSession_status, "f") === "saving") {
+        __classPrivateFieldSet2(this, _EditorSession_status, "editing", "f");
+        __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
+      }
+    }
+  }
+  /** Closing is refused while saving; the host must keep the modal open. */
+  cancel() {
+    if (__classPrivateFieldGet2(this, _EditorSession_status, "f") !== "editing")
+      return false;
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "cancelled");
+    return true;
+  }
+  dispose() {
+    if (__classPrivateFieldGet2(this, _EditorSession_status, "f") === "saving")
+      return false;
+    if (__classPrivateFieldGet2(this, _EditorSession_status, "f") === "editing")
+      __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "disposed");
+    return true;
+  }
+};
+_EditorSession_draft = /* @__PURE__ */ new WeakMap(), _EditorSession_status = /* @__PURE__ */ new WeakMap(), _EditorSession_issues = /* @__PURE__ */ new WeakMap(), _EditorSession_error = /* @__PURE__ */ new WeakMap(), _EditorSession_listeners = /* @__PURE__ */ new WeakMap(), _EditorSession_view = /* @__PURE__ */ new WeakMap(), _EditorSession_definition = /* @__PURE__ */ new WeakMap(), _EditorSession_snapshot = /* @__PURE__ */ new WeakMap(), _EditorSession_host = /* @__PURE__ */ new WeakMap(), _EditorSession_fixedPort = /* @__PURE__ */ new WeakMap(), _EditorSession_isRegistered = /* @__PURE__ */ new WeakMap(), _EditorSession_subscribeRegistrationChanges = /* @__PURE__ */ new WeakMap(), _EditorSession_unsubscribeFixedScope = /* @__PURE__ */ new WeakMap(), _EditorSession_unsubscribeFixedRegistration = /* @__PURE__ */ new WeakMap(), _EditorSession_fixedSavingController = /* @__PURE__ */ new WeakMap(), _EditorSession_instances = /* @__PURE__ */ new WeakSet(), _EditorSession_saveFixed = async function _EditorSession_saveFixed2() {
+  var _a;
+  const definition = __classPrivateFieldGet2(this, _EditorSession_definition, "f");
+  if (!isFixedInputEditor(definition))
+    throw new TypeError("Fixed input capability is unavailable.");
+  if (!supportsFixedInputEditing(__classPrivateFieldGet2(this, _EditorSession_host, "f")) || __classPrivateFieldGet2(this, _EditorSession_host, "f").fixedInputs !== __classPrivateFieldGet2(this, _EditorSession_fixedPort, "f")) {
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "disposed");
+    throw new BlockEditorConflictError("The fixed input capability changed.");
+  }
+  const snapshot = __classPrivateFieldGet2(this, _EditorSession_snapshot, "f");
+  const prepared = captureFixedPreparedSave(definition, __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, __classPrivateFieldGet2(this, _EditorSession_draft, "f")), snapshot);
+  if (__classPrivateFieldGet2(this, _EditorSession_status, "f") !== "saving")
+    throw new BlockEditorConflictError();
+  if (prepared.kind === "invalid") {
+    __classPrivateFieldSet2(this, _EditorSession_issues, __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_copyIssues).call(this, prepared.issues), "f");
+    return { status: "invalid", issues: __classPrivateFieldGet2(this, _EditorSession_issues, "f") };
+  }
+  const changes = __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_prepareChanges).call(this, prepared.changes);
+  const port = __classPrivateFieldGet2(this, _EditorSession_host, "f").fixedInputs;
+  if (__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this))
+    throw new BlockEditorConflictError("The fixed editor registration expired.");
+  const current = port.readBlock(snapshot, definition);
+  if (!current)
+    throw new BlockEditorConflictError();
+  try {
+    const captured = captureFixedSnapshot(current, snapshot, definition);
+    if (captured.fixedContext.generation !== snapshot.fixedContext.generation) {
+      __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "disposed");
+      throw new BlockEditorConflictError();
+    }
+    if (!sameFixedSnapshot(snapshot, captured))
+      throw new BlockEditorConflictError();
+  } catch (_b) {
+    throw new BlockEditorConflictError();
+  }
+  if (!supportsFixedInputEditing(__classPrivateFieldGet2(this, _EditorSession_host, "f")) || __classPrivateFieldGet2(this, _EditorSession_host, "f").fixedInputs !== port || __classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this))
+    throw new BlockEditorConflictError("The fixed editor registration expired.");
+  if (changes.length > 0) {
+    const controller = new AbortController();
+    __classPrivateFieldSet2(this, _EditorSession_fixedSavingController, controller, "f");
+    const context = prepared.context;
+    const unsubscribe = (_a = __classPrivateFieldGet2(this, _EditorSession_subscribeRegistrationChanges, "f")) === null || _a === void 0 ? void 0 : _a.call(this, () => {
+      if (__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this))
+        controller.abort(new BlockEditorConflictError("The fixed editor registration expired."));
+    });
+    try {
+      if (__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet2(this, _EditorSession_isRegistered, "f").call(this))
+        throw new BlockEditorConflictError("The fixed editor registration expired.");
+      await port.commit(Object.freeze({ expected: snapshot, changes, context, signal: controller.signal }));
+      if (controller.signal.aborted)
+        throw new BlockEditorConflictError("The fixed editor registration expired.");
+    } catch (error) {
+      if (controller.signal.aborted)
+        throw new BlockEditorConflictError("The fixed editor registration expired.");
+      throw error;
+    } finally {
+      unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+      __classPrivateFieldSet2(this, _EditorSession_fixedSavingController, void 0, "f");
+    }
+  }
+  __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, "saved");
+  return { status: "saved", changed: changes.length > 0 };
+}, _EditorSession_prepareChanges = function _EditorSession_prepareChanges2(patch) {
+  if (!Array.isArray(patch))
+    throw new TypeError("createPatch() must return an array.");
+  const seen = /* @__PURE__ */ new Set();
+  const changes = [];
+  for (const change of patch) {
+    if (!change || !__classPrivateFieldGet2(this, _EditorSession_definition, "f").editableArguments.includes(change.argument) || seen.has(change.argument) || !isLiteral(change.value)) {
+      throw new TypeError("Patch contains an invalid, duplicate or disallowed argument.");
+    }
+    seen.add(change.argument);
+    const slot = Object.hasOwn(__classPrivateFieldGet2(this, _EditorSession_snapshot, "f").arguments, change.argument) ? __classPrivateFieldGet2(this, _EditorSession_snapshot, "f").arguments[change.argument] : void 0;
+    if (!slot || slot.kind !== "literal") {
+      throw new TypeError("Only existing literal arguments can be changed.");
+    }
+    if (isFixedInputEditor(__classPrivateFieldGet2(this, _EditorSession_definition, "f"))) {
+      const metadata = __classPrivateFieldGet2(this, _EditorSession_snapshot, "f").fixedContext.inputs[change.argument];
+      if (!metadata || metadata.role !== "editable" || metadata.source !== "field" && metadata.source !== "shadow")
+        throw new TypeError("Fixed patches require editable literal fields.");
+      if (!Object.is(slot.value, change.value)) {
+        changes.push(Object.freeze({ argument: change.argument, value: change.value }));
+      }
+    } else if (slot.value !== change.value)
+      changes.push(Object.freeze({ ...change }));
+  }
+  if (isFixedInputEditor(__classPrivateFieldGet2(this, _EditorSession_definition, "f")) && validateFixedBranchChanges(__classPrivateFieldGet2(this, _EditorSession_definition, "f"), __classPrivateFieldGet2(this, _EditorSession_snapshot, "f"), changes).length)
+    throw new TypeError("Fixed dependency validation is unavailable.");
+  return Object.freeze(changes);
+}, _EditorSession_copyIssues = function _EditorSession_copyIssues2(issues) {
+  if (isFixedInputEditor(__classPrivateFieldGet2(this, _EditorSession_definition, "f")))
+    issues = snapshotJson(issues);
+  if (!Array.isArray(issues))
+    throw new TypeError("Expected a validation issue array.");
+  return Object.freeze(issues.map((issue) => {
+    if (!issue || typeof issue.message !== "string" || issue.path !== void 0 && typeof issue.path !== "string") {
+      throw new TypeError("Invalid validation issue.");
+    }
+    return Object.freeze({ ...issue });
+  }));
+}, _EditorSession_copyDraft = function _EditorSession_copyDraft2(draft) {
+  if (!draft || typeof draft !== "object" || Array.isArray(draft)) {
+    throw new TypeError("The editor draft must be a JSON object.");
+  }
+  if (!isFixedInputEditor(__classPrivateFieldGet2(this, _EditorSession_definition, "f")))
+    return cloneJson(draft);
+  try {
+    return snapshotJson(draft);
+  } catch (error) {
+    try {
+      void Promise.prototype.then.call(draft, () => void 0, () => void 0);
+    } catch (_a) {
+    }
+    throw error;
+  }
+}, _EditorSession_assertOpen = function _EditorSession_assertOpen2() {
+  if (__classPrivateFieldGet2(this, _EditorSession_status, "f") !== "editing" && __classPrivateFieldGet2(this, _EditorSession_status, "f") !== "saving") {
+    throw new Error("The session is closed.");
+  }
+}, _EditorSession_finish = function _EditorSession_finish2(status) {
+  __classPrivateFieldSet2(this, _EditorSession_status, status, "f");
+  __classPrivateFieldSet2(this, _EditorSession_draft, {}, "f");
+  const unsubscribe = __classPrivateFieldGet2(this, _EditorSession_unsubscribeFixedScope, "f");
+  __classPrivateFieldSet2(this, _EditorSession_unsubscribeFixedScope, void 0, "f");
+  try {
+    unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+  } catch (error) {
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_reportObserverError).call(this, error);
+  }
+  const unsubscribeRegistration = __classPrivateFieldGet2(this, _EditorSession_unsubscribeFixedRegistration, "f");
+  __classPrivateFieldSet2(this, _EditorSession_unsubscribeFixedRegistration, void 0, "f");
+  try {
+    unsubscribeRegistration === null || unsubscribeRegistration === void 0 ? void 0 : unsubscribeRegistration();
+  } catch (error) {
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_reportObserverError).call(this, error);
+  }
+  __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
+  try {
+    __classPrivateFieldGet2(this, _EditorSession_view, "f").unmount();
+  } catch (error) {
+    __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_reportObserverError).call(this, error);
+  }
+  __classPrivateFieldGet2(this, _EditorSession_listeners, "f").clear();
+}, _EditorSession_notify = function _EditorSession_notify2() {
+  for (const listener of [...__classPrivateFieldGet2(this, _EditorSession_listeners, "f")]) {
+    try {
+      listener();
+    } catch (error) {
+      __classPrivateFieldGet2(this, _EditorSession_instances, "m", _EditorSession_reportObserverError).call(this, error);
+    }
+  }
+}, _EditorSession_reportObserverError = function _EditorSession_reportObserverError2(error) {
+  console.error("Block editor view callback failed:", error);
+};
+
+// dist/subtree.js
+function descendantLimits(limits = {}) {
+  const result = { ...DEFAULT_DESCENDANT_LIMITS, ...limits };
+  if (!Number.isSafeInteger(result.maxDepth) || result.maxDepth < 0 || result.maxDepth > DEFAULT_DESCENDANT_LIMITS.maxDepth || !Number.isSafeInteger(result.maxNodes) || result.maxNodes < 1 || result.maxNodes > DEFAULT_DESCENDANT_LIMITS.maxNodes) {
+    throw new BlockEditorStructureError("Limits must be integers: depth 0\u201332, nodes 1\u2013500.", "limit");
+  }
+  return Object.freeze(result);
+}
+function captureSubtree(source, reference, limits) {
+  const invalid = (message) => {
+    throw new BlockEditorStructureError(message, "invalid-structure");
+  };
+  if (!source || source.targetId !== reference.targetId || source.blockId !== reference.blockId || typeof source.generation !== "string" || !source.generation || !Array.isArray(source.nodes) || source.nodes.length === 0)
+    invalid("The host returned an invalid subtree snapshot.");
+  if (source.nodes.length > limits.maxNodes) {
+    throw new BlockEditorStructureError("The subtree exceeds the node limit.", "limit");
+  }
+  const entries = /* @__PURE__ */ new Map();
+  let edges = 0;
+  for (const node of source.nodes) {
+    if (!(node === null || node === void 0 ? void 0 : node.block) || !Array.isArray(node.branches))
+      invalid("Invalid subtree node.");
+    const block = (() => {
+      try {
+        return captureSnapshot(node.block, { targetId: reference.targetId, blockId: node.block.blockId });
+      } catch (_a) {
+        return invalid("Invalid subtree block snapshot or target identity.");
+      }
+    })();
+    if (entries.has(block.blockId))
+      invalid("Duplicate block ID in subtree.");
+    const inputs = /* @__PURE__ */ new Set();
+    const branches = node.branches.map((branch) => {
+      if (!branch || typeof branch.input !== "string" || !branch.input || inputs.has(branch.input) || !Array.isArray(branch.blockIds))
+        invalid("Invalid or duplicate statement input.");
+      inputs.add(branch.input);
+      edges += branch.blockIds.length;
+      if (edges >= source.nodes.length)
+        invalid("Subtree connections contain a cycle or duplicate parent.");
+      const blockIds = branch.blockIds.map((id) => {
+        if (typeof id !== "string" || !id)
+          invalid("Invalid statement block ID.");
+        return id;
+      });
+      return Object.freeze({ input: branch.input, blockIds: Object.freeze(blockIds) });
+    });
+    entries.set(block.blockId, Object.freeze({ block, branches: Object.freeze(branches) }));
+  }
+  const paths = /* @__PURE__ */ new Map();
+  const ordered = [];
+  const stack = [{ id: reference.blockId, path: Object.freeze([]) }];
+  while (stack.length) {
+    const { id, path } = stack.pop();
+    if (paths.has(id))
+      throw new BlockEditorStructureError("Cycle or repeated subtree node.", "cycle");
+    if (path.length > limits.maxDepth) {
+      throw new BlockEditorStructureError("The subtree exceeds the depth limit.", "limit");
+    }
+    const node = entries.get(id);
+    if (!node)
+      invalid(`Missing subtree node: ${id}`);
+    paths.set(id, path);
+    ordered.push(node);
+    for (let branchIndex = node.branches.length - 1; branchIndex >= 0; branchIndex--) {
+      const branch = node.branches[branchIndex];
+      for (let index = branch.blockIds.length - 1; index >= 0; index--) {
+        stack.push({ id: branch.blockIds[index], path: Object.freeze([
+          ...path,
+          Object.freeze({ blockId: id, input: branch.input, index })
+        ]) });
+      }
+    }
+  }
+  if (paths.size !== entries.size)
+    invalid("Subtree includes disconnected or out-of-scope nodes.");
+  return {
+    snapshot: Object.freeze({
+      ...captureReference(reference),
+      generation: source.generation,
+      nodes: Object.freeze(ordered)
+    }),
+    paths
+  };
+}
+function sameSubtree(left, right) {
+  return left.targetId === right.targetId && left.blockId === right.blockId && left.generation === right.generation && left.nodes.length === right.nodes.length && left.nodes.every((node, index) => {
+    const other = right.nodes[index];
+    return sameSnapshot(node.block, other.block) && node.branches.length === other.branches.length && node.branches.every((branch, branchIndex) => {
+      const b = other.branches[branchIndex];
+      return branch.input === b.input && branch.blockIds.length === b.blockIds.length && branch.blockIds.every((id, i) => id === b.blockIds[i]);
+    });
+  });
+}
+
+// dist/descendants.js
+var __classPrivateFieldSet3 = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet3 = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DescendantSession_instances;
+var _DescendantSession_snapshot;
+var _DescendantSession_host;
+var _DescendantSession_limits;
+var _DescendantSession_lookup;
+var _DescendantSession_bindings;
+var _DescendantSession_records;
+var _DescendantSession_nodes;
+var _DescendantSession_listeners;
+var _DescendantSession_detach;
+var _DescendantSession_abort;
+var _DescendantSession_status;
+var _DescendantSession_committing;
+var _DescendantSession_error;
+var _DescendantSession_createRecord;
+var _DescendantSession_isOpen;
+var _DescendantSession_closedSaveResult;
+var _DescendantSession_assertOpen;
+var _DescendantSession_assertEditable;
+var _DescendantSession_bindingsCurrent;
+var _DescendantSession_checkBindings;
+var _DescendantSession_assertSaving;
+var _DescendantSession_notify;
+var _DescendantSession_watch;
+var _DescendantSession_finish;
+function copyDraft(draft) {
+  if (!draft || typeof draft !== "object" || Array.isArray(draft)) {
+    throw new TypeError("The editor draft must be a JSON object.");
+  }
+  return cloneJson(draft);
+}
+function copyIssues(issues) {
+  if (!Array.isArray(issues))
+    throw new TypeError("Expected a validation issue array.");
+  return Object.freeze(issues.map((issue) => {
+    if (!issue || typeof issue.message !== "string" || issue.path !== void 0 && typeof issue.path !== "string") {
+      throw new TypeError("Invalid validation issue.");
+    }
+    return Object.freeze({ message: issue.message, ...issue.path === void 0 ? {} : { path: issue.path } });
+  }));
+}
+function observe(listeners) {
+  for (const listener of [...listeners]) {
+    try {
+      listener();
+    } catch (error) {
+      report(error);
+    }
+  }
+}
+function report(error) {
+  console.error("Block editor view callback failed:", error);
+}
+function abortable(value, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve(value).then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+    if (signal.aborted) {
+      signal.removeEventListener("abort", abort);
+      abort();
+    }
+  });
+}
+var DescendantSession = class {
+  /** Use EditorRegistry.openDescendants() to negotiate and capture the scope. */
+  constructor(captured, host, lookup, subscribeRegistry, limits) {
+    _DescendantSession_instances.add(this);
+    _DescendantSession_snapshot.set(this, void 0);
+    _DescendantSession_host.set(this, void 0);
+    _DescendantSession_limits.set(this, void 0);
+    _DescendantSession_lookup.set(this, void 0);
+    _DescendantSession_bindings.set(this, /* @__PURE__ */ new Map());
+    _DescendantSession_records.set(this, /* @__PURE__ */ new Map());
+    _DescendantSession_nodes.set(this, void 0);
+    _DescendantSession_listeners.set(this, /* @__PURE__ */ new Set());
+    _DescendantSession_detach.set(this, /* @__PURE__ */ new Set());
+    _DescendantSession_abort.set(this, new AbortController());
+    _DescendantSession_status.set(this, "editing");
+    _DescendantSession_committing.set(this, false);
+    _DescendantSession_error.set(this, void 0);
+    __classPrivateFieldSet3(this, _DescendantSession_snapshot, captured.snapshot, "f");
+    __classPrivateFieldSet3(this, _DescendantSession_host, host, "f");
+    __classPrivateFieldSet3(this, _DescendantSession_lookup, lookup, "f");
+    __classPrivateFieldSet3(this, _DescendantSession_limits, limits, "f");
+    for (const node of captured.snapshot.nodes)
+      __classPrivateFieldGet3(this, _DescendantSession_bindings, "f").set(node.block.opcode, lookup(node.block.opcode));
+    __classPrivateFieldSet3(this, _DescendantSession_nodes, Object.freeze(captured.snapshot.nodes.map((node) => {
+      const definition = __classPrivateFieldGet3(this, _DescendantSession_bindings, "f").get(node.block.opcode);
+      const descriptor = Object.freeze({
+        reference: captureReference(node.block),
+        opcode: node.block.opcode,
+        inputPath: captured.paths.get(node.block.blockId),
+        ...definition ? { editor: Object.freeze({
+          apiVersion: definition.apiVersion,
+          extensionId: definition.extensionId,
+          editorId: definition.editorId,
+          opcodes: definition.opcodes,
+          editableArguments: definition.editableArguments
+        }) } : {}
+      });
+      if (definition) {
+        try {
+          __classPrivateFieldGet3(this, _DescendantSession_records, "f").set(node.block.blockId, __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_createRecord).call(this, descriptor, definition, node.block));
+        } catch (cause) {
+          throw new DescendantNodeError(descriptor.reference, descriptor.inputPath, cause);
+        }
+      }
+      return descriptor;
+    })), "f");
+    try {
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_watch).call(this, () => subscribeRegistry(() => {
+        if (!__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_bindingsCurrent).call(this))
+          this.invalidate(new BlockEditorConflictError("An editor registration changed."));
+      }));
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_checkBindings).call(this);
+      if (host.subscribeInvalidation) {
+        __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_watch).call(this, () => host.subscribeInvalidation(this.reference, (reason) => this.invalidate(reason)));
+      }
+    } catch (error) {
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_finish).call(this, "disposed");
+      throw error;
+    }
+  }
+  get reference() {
+    return captureReference(__classPrivateFieldGet3(this, _DescendantSession_snapshot, "f"));
+  }
+  get generation() {
+    return __classPrivateFieldGet3(this, _DescendantSession_snapshot, "f").generation;
+  }
+  getNodes() {
+    return __classPrivateFieldGet3(this, _DescendantSession_nodes, "f");
+  }
+  getEditor(blockId) {
+    var _a;
+    return (_a = __classPrivateFieldGet3(this, _DescendantSession_records, "f").get(blockId)) === null || _a === void 0 ? void 0 : _a.editor;
+  }
+  getState() {
+    const issues = Object.freeze([...__classPrivateFieldGet3(this, _DescendantSession_records, "f").values()].flatMap((record2) => record2.issues.map((issue) => Object.freeze({ ...issue, reference: record2.descriptor.reference, inputPath: record2.descriptor.inputPath }))));
+    return Object.freeze({
+      status: __classPrivateFieldGet3(this, _DescendantSession_status, "f"),
+      canSave: __classPrivateFieldGet3(this, _DescendantSession_status, "f") === "editing" && issues.length === 0,
+      issues,
+      error: __classPrivateFieldGet3(this, _DescendantSession_error, "f")
+    });
+  }
+  subscribe(listener) {
+    __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertOpen).call(this);
+    __classPrivateFieldGet3(this, _DescendantSession_listeners, "f").add(listener);
+    return () => {
+      __classPrivateFieldGet3(this, _DescendantSession_listeners, "f").delete(listener);
+    };
+  }
+  async save() {
+    if (__classPrivateFieldGet3(this, _DescendantSession_status, "f") === "saving")
+      return { status: "busy" };
+    if (__classPrivateFieldGet3(this, _DescendantSession_status, "f") !== "editing")
+      return { status: "closed" };
+    __classPrivateFieldSet3(this, _DescendantSession_status, "saving", "f");
+    __classPrivateFieldSet3(this, _DescendantSession_error, void 0, "f");
+    for (const record2 of __classPrivateFieldGet3(this, _DescendantSession_records, "f").values())
+      record2.issues = [];
+    __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_notify).call(this);
+    try {
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+      const prepared = /* @__PURE__ */ new Map();
+      for (const record2 of __classPrivateFieldGet3(this, _DescendantSession_records, "f").values()) {
+        try {
+          const result = isPreparedEditor(record2.definition) ? capturePreparedSave(record2.definition, cloneJson(record2.draft), record2.snapshot) : void 0;
+          if (result)
+            prepared.set(record2.snapshot.blockId, result);
+          const issues2 = result ? result.kind === "invalid" ? result.issues : [] : await abortable(record2.definition.validate(cloneJson(record2.draft), record2.snapshot), __classPrivateFieldGet3(this, _DescendantSession_abort, "f").signal);
+          __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+          record2.issues = copyIssues(issues2);
+        } catch (cause) {
+          __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+          throw new DescendantNodeError(record2.descriptor.reference, record2.descriptor.inputPath, cause);
+        }
+      }
+      const issues = this.getState().issues;
+      if (issues.length)
+        return { status: "invalid", issues };
+      const changes = [];
+      const destinations = /* @__PURE__ */ new Set();
+      for (const record2 of __classPrivateFieldGet3(this, _DescendantSession_records, "f").values()) {
+        try {
+          const result = prepared.get(record2.snapshot.blockId);
+          const patch = (result === null || result === void 0 ? void 0 : result.kind) === "ready" ? result.changes : record2.definition.createPatch(cloneJson(record2.draft), record2.snapshot);
+          __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+          if (!Array.isArray(patch))
+            throw new TypeError("createPatch() must return an array.");
+          for (const change of patch) {
+            if (!change || !record2.definition.editableArguments.includes(change.argument) || !isLiteral(change.value)) {
+              throw new TypeError("Patch contains an invalid or disallowed argument.");
+            }
+            const destination = JSON.stringify([record2.snapshot.blockId, change.argument]);
+            if (destinations.has(destination))
+              throw new TypeError("Duplicate subtree write destination.");
+            destinations.add(destination);
+            const slot = Object.hasOwn(record2.snapshot.arguments, change.argument) ? record2.snapshot.arguments[change.argument] : void 0;
+            if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== "literal")
+              throw new TypeError("Only existing literal arguments can be changed.");
+            if (slot.value !== change.value)
+              changes.push(Object.freeze({
+                blockId: record2.snapshot.blockId,
+                argument: change.argument,
+                value: change.value
+              }));
+          }
+        } catch (cause) {
+          __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+          throw new DescendantNodeError(record2.descriptor.reference, record2.descriptor.inputPath, cause);
+        }
+      }
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+      const live = __classPrivateFieldGet3(this, _DescendantSession_host, "f").readSubtree(this.reference);
+      let matches = false;
+      if (live) {
+        try {
+          matches = sameSubtree(__classPrivateFieldGet3(this, _DescendantSession_snapshot, "f"), captureSubtree(live, this.reference, __classPrivateFieldGet3(this, _DescendantSession_limits, "f")).snapshot);
+        } catch (_a) {
+        }
+      }
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+      if (!matches)
+        throw new BlockEditorConflictError("The subtree changed or is no longer editable.");
+      if (changes.length) {
+        __classPrivateFieldSet3(this, _DescendantSession_committing, true, "f");
+        await abortable(__classPrivateFieldGet3(this, _DescendantSession_host, "f").commitSubtree(Object.freeze({
+          expected: __classPrivateFieldGet3(this, _DescendantSession_snapshot, "f"),
+          changes: Object.freeze(changes),
+          signal: __classPrivateFieldGet3(this, _DescendantSession_abort, "f").signal
+        })), __classPrivateFieldGet3(this, _DescendantSession_abort, "f").signal);
+        __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+      }
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_finish).call(this, "saved");
+      return { status: "saved", changed: changes.length > 0 };
+    } catch (error) {
+      if (!__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_isOpen).call(this))
+        return __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_closedSaveResult).call(this);
+      __classPrivateFieldSet3(this, _DescendantSession_error, error, "f");
+      return error instanceof BlockEditorConflictError ? { status: "conflict", error } : { status: "failed", error };
+    } finally {
+      __classPrivateFieldSet3(this, _DescendantSession_committing, false, "f");
+      if (__classPrivateFieldGet3(this, _DescendantSession_status, "f") === "saving") {
+        __classPrivateFieldSet3(this, _DescendantSession_status, "editing", "f");
+        __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_notify).call(this);
+      }
+    }
+  }
+  /** Validation may be cancelled; an already dispatched commit must finish atomically. */
+  cancel() {
+    if (!__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_isOpen).call(this) || __classPrivateFieldGet3(this, _DescendantSession_committing, "f"))
+      return false;
+    __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_finish).call(this, "cancelled");
+    return true;
+  }
+  dispose() {
+    if (__classPrivateFieldGet3(this, _DescendantSession_committing, "f") && __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_isOpen).call(this))
+      return false;
+    if (__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_isOpen).call(this))
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_finish).call(this, "disposed");
+    return true;
+  }
+  /** The host must observe the abort signal before any deferred write. */
+  invalidate(reason = new BlockEditorConflictError("The subtree session was invalidated.")) {
+    if (!__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_isOpen).call(this))
+      return false;
+    __classPrivateFieldSet3(this, _DescendantSession_error, reason, "f");
+    __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_finish).call(this, "invalidated");
+    return true;
+  }
+};
+_DescendantSession_snapshot = /* @__PURE__ */ new WeakMap(), _DescendantSession_host = /* @__PURE__ */ new WeakMap(), _DescendantSession_limits = /* @__PURE__ */ new WeakMap(), _DescendantSession_lookup = /* @__PURE__ */ new WeakMap(), _DescendantSession_bindings = /* @__PURE__ */ new WeakMap(), _DescendantSession_records = /* @__PURE__ */ new WeakMap(), _DescendantSession_nodes = /* @__PURE__ */ new WeakMap(), _DescendantSession_listeners = /* @__PURE__ */ new WeakMap(), _DescendantSession_detach = /* @__PURE__ */ new WeakMap(), _DescendantSession_abort = /* @__PURE__ */ new WeakMap(), _DescendantSession_status = /* @__PURE__ */ new WeakMap(), _DescendantSession_committing = /* @__PURE__ */ new WeakMap(), _DescendantSession_error = /* @__PURE__ */ new WeakMap(), _DescendantSession_instances = /* @__PURE__ */ new WeakSet(), _DescendantSession_createRecord = function _DescendantSession_createRecord2(descriptor, definition, snapshot) {
+  const view = new EditorView();
+  const listeners = /* @__PURE__ */ new Set();
+  const editor = Object.freeze({
+    reference: descriptor.reference,
+    getDraft: () => {
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertOpen).call(this);
+      return cloneJson(record2.draft);
+    },
+    setDraft: (draft) => {
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertEditable).call(this);
+      record2.draft = copyDraft(draft);
+      record2.issues = [];
+      __classPrivateFieldSet3(this, _DescendantSession_error, void 0, "f");
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_notify).call(this, record2);
+    },
+    setValidationIssues: (issues) => {
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertEditable).call(this);
+      record2.issues = copyIssues(issues);
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_notify).call(this, record2);
+    },
+    getState: () => Object.freeze({
+      status: __classPrivateFieldGet3(this, _DescendantSession_status, "f") === "invalidated" ? "disposed" : __classPrivateFieldGet3(this, _DescendantSession_status, "f"),
+      canSave: __classPrivateFieldGet3(this, _DescendantSession_status, "f") === "editing" && record2.issues.length === 0,
+      issues: record2.issues,
+      error: __classPrivateFieldGet3(this, _DescendantSession_error, "f")
+    }),
+    subscribe: (listener) => {
+      __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_assertOpen).call(this);
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    mount: (container) => view.mount(container, definition.mount, editor)
+  });
+  const record2 = {
+    descriptor,
+    definition,
+    snapshot,
+    view,
+    listeners,
+    editor,
+    draft: copyDraft(definition.read(snapshot)),
+    issues: []
+  };
+  return record2;
+}, _DescendantSession_isOpen = function _DescendantSession_isOpen2() {
+  return __classPrivateFieldGet3(this, _DescendantSession_status, "f") === "editing" || __classPrivateFieldGet3(this, _DescendantSession_status, "f") === "saving";
+}, _DescendantSession_closedSaveResult = function _DescendantSession_closedSaveResult2() {
+  return __classPrivateFieldGet3(this, _DescendantSession_status, "f") === "invalidated" ? { status: "invalidated" } : { status: "closed" };
+}, _DescendantSession_assertOpen = function _DescendantSession_assertOpen2() {
+  if (!__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_isOpen).call(this))
+    throw new Error("The session is closed.");
+}, _DescendantSession_assertEditable = function _DescendantSession_assertEditable2() {
+  if (__classPrivateFieldGet3(this, _DescendantSession_status, "f") !== "editing")
+    throw new Error("The session is not editable.");
+}, _DescendantSession_bindingsCurrent = function _DescendantSession_bindingsCurrent2() {
+  return [...__classPrivateFieldGet3(this, _DescendantSession_bindings, "f")].every(([opcode, definition]) => __classPrivateFieldGet3(this, _DescendantSession_lookup, "f").call(this, opcode) === definition);
+}, _DescendantSession_checkBindings = function _DescendantSession_checkBindings2() {
+  if (!__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_bindingsCurrent).call(this))
+    throw new BlockEditorConflictError("An editor registration changed.");
+}, _DescendantSession_assertSaving = function _DescendantSession_assertSaving2() {
+  if (__classPrivateFieldGet3(this, _DescendantSession_status, "f") !== "saving")
+    throw new Error("The save was cancelled or invalidated.");
+  __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_checkBindings).call(this);
+}, _DescendantSession_notify = function _DescendantSession_notify2(record2) {
+  if (record2)
+    observe(record2.listeners);
+  else
+    for (const node of __classPrivateFieldGet3(this, _DescendantSession_records, "f").values())
+      observe(node.listeners);
+  observe(__classPrivateFieldGet3(this, _DescendantSession_listeners, "f"));
+}, _DescendantSession_watch = function _DescendantSession_watch2(subscribe) {
+  const detach = subscribe();
+  if (typeof detach !== "function")
+    throw new TypeError("Invalidation subscriptions must return a cleanup function.");
+  if (__classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_isOpen).call(this))
+    __classPrivateFieldGet3(this, _DescendantSession_detach, "f").add(detach);
+  else
+    detach();
+}, _DescendantSession_finish = function _DescendantSession_finish2(status) {
+  __classPrivateFieldSet3(this, _DescendantSession_status, status, "f");
+  __classPrivateFieldGet3(this, _DescendantSession_abort, "f").abort(__classPrivateFieldGet3(this, _DescendantSession_error, "f"));
+  __classPrivateFieldGet3(this, _DescendantSession_instances, "m", _DescendantSession_notify).call(this);
+  for (const record2 of __classPrivateFieldGet3(this, _DescendantSession_records, "f").values()) {
+    try {
+      record2.view.unmount();
+    } catch (error) {
+      report(error);
+    }
+    record2.draft = {};
+    record2.issues = [];
+    record2.listeners.clear();
+  }
+  for (const detach of __classPrivateFieldGet3(this, _DescendantSession_detach, "f")) {
+    try {
+      detach();
+    } catch (error) {
+      report(error);
+    }
+  }
+  __classPrivateFieldGet3(this, _DescendantSession_detach, "f").clear();
+  __classPrivateFieldGet3(this, _DescendantSession_listeners, "f").clear();
+};
+
+// dist/registry.js
+var __classPrivateFieldGet4 = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EditorRegistry_instances;
+var _EditorRegistry_editors;
+var _EditorRegistry_opcodes;
+var _EditorRegistry_fixedDeclarations;
+var _EditorRegistry_changes;
+var _EditorRegistry_register;
+var _EditorRegistry_notifyChanges;
+var EditorRegistry = class {
+  constructor() {
+    _EditorRegistry_instances.add(this);
+    _EditorRegistry_editors.set(this, /* @__PURE__ */ new Map());
+    _EditorRegistry_opcodes.set(this, /* @__PURE__ */ new Map());
+    _EditorRegistry_fixedDeclarations.set(this, /* @__PURE__ */ new Map());
+    _EditorRegistry_changes.set(this, /* @__PURE__ */ new Set());
+  }
+  register(definition) {
+    if (isFixedInputEditor(definition))
+      throw new TypeError("Fixed input editors require registerFixed().");
+    if (isPreparedEditor(definition))
+      throw new TypeError("Prepared editors require registerPrepared().");
+    return __classPrivateFieldGet4(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, definition);
+  }
+  registerPrepared(definition) {
+    if (!isPreparedEditor(definition) || typeof definition.prepareSave !== "function") {
+      throw new TypeError("Expected a prepared source editor.");
+    }
+    return __classPrivateFieldGet4(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, definition);
+  }
+  registerFixed(definition) {
+    return __classPrivateFieldGet4(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, captureFixedInputEditorDefinition(definition));
+  }
+  resolve(opcode) {
+    const entry = __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").get(opcode);
+    if (!entry)
+      return void 0;
+    return Object.freeze({
+      apiVersion: entry.apiVersion,
+      extensionId: entry.extensionId,
+      editorId: entry.editorId,
+      opcodes: entry.opcodes,
+      editableArguments: entry.editableArguments
+    });
+  }
+  /** Stable, callback-free authority for this exact registration, never caller metadata. */
+  resolveFixed(opcode) {
+    const entry = __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").get(opcode);
+    return entry ? __classPrivateFieldGet4(this, _EditorRegistry_fixedDeclarations, "f").get(entry) : void 0;
+  }
+  open(reference, host) {
+    const capturedReference = captureReference(reference);
+    const live = host.readBlock(capturedReference);
+    if (!live)
+      return void 0;
+    const entry = __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").get(live.opcode);
+    if (!entry) {
+      captureSnapshot(live, capturedReference);
+      return void 0;
+    }
+    if (isFixedInputEditor(entry)) {
+      if (!supportsFixedInputEditing(host))
+        return void 0;
+      const fixed = host.fixedInputs.readBlock(capturedReference, entry);
+      if (!fixed || fixed.opcode !== live.opcode)
+        return void 0;
+      const snapshot2 = captureFixedSnapshot(fixed, capturedReference, entry);
+      return new EditorSession(entry, snapshot2, host, () => __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").get(snapshot2.opcode) === entry, (listener) => {
+        __classPrivateFieldGet4(this, _EditorRegistry_changes, "f").add(listener);
+        return () => {
+          __classPrivateFieldGet4(this, _EditorRegistry_changes, "f").delete(listener);
+        };
+      });
+    }
+    const snapshot = captureSnapshot(live, capturedReference);
+    return new EditorSession(entry, snapshot, host, isPreparedEditor(entry) ? () => __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry : void 0);
+  }
+  openDescendants(reference, host, limits) {
+    if (!supportsDescendantEditing(host))
+      return void 0;
+    const port = host.descendants;
+    const capturedReference = captureReference(reference);
+    const resolvedLimits = descendantLimits(limits);
+    const live = port.readSubtree(capturedReference);
+    if (!live)
+      return void 0;
+    const captured = captureSubtree(live, capturedReference, resolvedLimits);
+    const root = __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").get(captured.snapshot.nodes[0].block.opcode);
+    if (!root || isFixedInputEditor(root))
+      return void 0;
+    return new DescendantSession(captured, port, (opcode) => {
+      const entry = __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").get(opcode);
+      return entry && !isFixedInputEditor(entry) ? entry : void 0;
+    }, (listener) => {
+      __classPrivateFieldGet4(this, _EditorRegistry_changes, "f").add(listener);
+      return () => {
+        __classPrivateFieldGet4(this, _EditorRegistry_changes, "f").delete(listener);
+      };
+    }, resolvedLimits);
+  }
+};
+_EditorRegistry_editors = /* @__PURE__ */ new WeakMap(), _EditorRegistry_opcodes = /* @__PURE__ */ new WeakMap(), _EditorRegistry_fixedDeclarations = /* @__PURE__ */ new WeakMap(), _EditorRegistry_changes = /* @__PURE__ */ new WeakMap(), _EditorRegistry_instances = /* @__PURE__ */ new WeakSet(), _EditorRegistry_register = function _EditorRegistry_register2(definition) {
+  if (definition.apiVersion !== EDITOR_API_VERSION)
+    throw new TypeError("Unsupported editor API version.");
+  if (!/^[a-z0-9]+$/i.test(definition.extensionId) || !/^[a-z0-9][a-z0-9._-]*$/i.test(definition.editorId)) {
+    throw new TypeError("Invalid extension ID or editor ID.");
+  }
+  if (!Array.isArray(definition.opcodes) || definition.opcodes.length === 0 || new Set(definition.opcodes).size !== definition.opcodes.length || definition.opcodes.some((opcode) => typeof opcode !== "string" || !opcode.startsWith(`${definition.extensionId}_`) || opcode === `${definition.extensionId}_`)) {
+    throw new TypeError("Expected distinct full opcodes belonging to the extension.");
+  }
+  if (!Array.isArray(definition.editableArguments) || new Set(definition.editableArguments).size !== definition.editableArguments.length || definition.editableArguments.some((name) => typeof name !== "string" || !name)) {
+    throw new TypeError("Expected distinct editable argument names.");
+  }
+  if (typeof definition.read !== "function" || typeof definition.validate !== "function" || typeof definition.createPatch !== "function" || definition.mount !== void 0 && typeof definition.mount !== "function") {
+    throw new TypeError("Invalid editor callbacks.");
+  }
+  const key = JSON.stringify([definition.extensionId, definition.editorId]);
+  if (__classPrivateFieldGet4(this, _EditorRegistry_editors, "f").has(key) || definition.opcodes.some((opcode) => __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").has(opcode))) {
+    throw new Error("The editor ID or an opcode is already registered.");
+  }
+  const entry = Object.freeze({
+    ...definition,
+    opcodes: Object.freeze([...definition.opcodes]),
+    editableArguments: Object.freeze([...definition.editableArguments])
+  });
+  if (isFixedInputEditor(entry))
+    __classPrivateFieldGet4(this, _EditorRegistry_fixedDeclarations, "f").set(entry, captureFixedInputDeclaration(entry));
+  __classPrivateFieldGet4(this, _EditorRegistry_editors, "f").set(key, entry);
+  for (const opcode of entry.opcodes)
+    __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").set(opcode, entry);
+  __classPrivateFieldGet4(this, _EditorRegistry_instances, "m", _EditorRegistry_notifyChanges).call(this);
+  return () => {
+    if (__classPrivateFieldGet4(this, _EditorRegistry_editors, "f").get(key) !== entry)
+      return;
+    __classPrivateFieldGet4(this, _EditorRegistry_editors, "f").delete(key);
+    for (const opcode of entry.opcodes)
+      __classPrivateFieldGet4(this, _EditorRegistry_opcodes, "f").delete(opcode);
+    __classPrivateFieldGet4(this, _EditorRegistry_fixedDeclarations, "f").delete(entry);
+    __classPrivateFieldGet4(this, _EditorRegistry_instances, "m", _EditorRegistry_notifyChanges).call(this);
+  };
+}, _EditorRegistry_notifyChanges = function _EditorRegistry_notifyChanges2() {
+  for (const listener of [...__classPrivateFieldGet4(this, _EditorRegistry_changes, "f")])
+    listener();
+};
+
+export {
+  cloneJson,
+  validateFixedBranchChanges,
+  captureFixedInputDeclaration,
+  captureFixedSnapshot,
+  sameFixedSnapshot,
+  createFixedInputEditor,
+  FIXED_INPUTS_CAPABILITY,
+  supportsFixedInputs,
+  supportsFixedInputEditing,
+  EditorSession,
+  DescendantSession,
+  EditorRegistry
+};
+//# sourceMappingURL=shared-P2JBRZFP.js.map