@kubohiroya/turbowarp-extension-data-editor 0.1.0 → 0.2.1

package/dist/webpack4/turbowarp.js

@@ -1,12 +1,23 @@
-import "./shared-CQB3NG2A.js";
-import "./shared-WHOAW2VF.js";
+import "./shared-FYUILHED.js";
+import {
+  FIXED_INPUTS_CAPABILITY,
+  captureFixedInputDeclaration,
+  captureFixedSnapshot,
+  sameFixedSnapshot,
+  supportsFixedInputEditing,
+  validateFixedBranchChanges
+} from "./shared-P2JBRZFP.js";
 import {
   BlockEditorConflictError,
   BlockEditorStructureError,
   DEFAULT_DESCENDANT_LIMITS,
   DESCENDANT_EDITING_CAPABILITY,
   supportsDescendantEditing
-} from "./shared-KIFRVTSM.js";
+} from "./shared-BKTRZUZH.js";
+import {
+  snapshotJson
+} from "./shared-75QIWLZY.js";
+import "./shared-RN7GOT65.js";
 
 // dist/turbowarp/subtree.js
 var collectBlockEditorSubtree = ({ ScratchBlocks, reference, inspect, generation }) => {
@@ -66,17 +77,827 @@ var collectBlockEditorSubtree = ({ ScratchBlocks, reference, inspect, generation
 };
 var subtree_default = collectBlockEditorSubtree;
 
-// dist/turbowarp/host.js
+// dist/turbowarp/fixed-fields.js
 var owns = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
-var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDescendants = false, onError = console.error }) => {
+var own = (object, key) => {
+  const descriptor = object && Object.getOwnPropertyDescriptor(object, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+};
+var primitive = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var token = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
+var inherited = (object, name) => {
+  for (let current = object; current; current = Object.getPrototypeOf(current)) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, name);
+    if (descriptor)
+      return "value" in descriptor ? descriptor.value : void 0;
+  }
+  return void 0;
+};
+var storage = ["text_", "value_", "colour_", "validator_", "sourceBlock_", "hue_", "saturation_", "brightness_"];
+var methods = [
+  "getValue",
+  "getText",
+  "setValue",
+  "setText",
+  "getValidator",
+  "classValidator",
+  "callValidator",
+  "getOptions",
+  "forceRerender",
+  "updateSliderHandles_",
+  "updateDom_"
+];
+var trustedClasses = /* @__PURE__ */ new WeakMap();
+function initializeFixedFields(ScratchBlocks) {
+  for (const key of ["FieldTextInput", "FieldNumber", "FieldDropdown", "FieldColourSlider"]) {
+    const Class = ScratchBlocks[key];
+    if (typeof Class !== "function" || trustedClasses.has(Class))
+      continue;
+    const chain = [];
+    for (let prototype = Class.prototype; prototype && prototype !== Object.prototype; prototype = Object.getPrototypeOf(prototype)) {
+      chain.push({ prototype, own: methods.map((name) => [name, Object.getOwnPropertyDescriptor(prototype, name)]) });
+    }
+    trustedClasses.set(Class, {
+      prototype: Class.prototype,
+      chain,
+      methods: methods.map((name) => [name, inherited(Class.prototype, name)])
+    });
+  }
+}
+var safeField = (field, Class) => {
+  const trusted = Class && trustedClasses.get(Class);
+  if (!trusted || Class.prototype !== trusted.prototype || Object.getPrototypeOf(field) !== trusted.prototype)
+    return false;
+  let currentPrototype = trusted.prototype;
+  for (const entry of trusted.chain) {
+    if (currentPrototype !== entry.prototype)
+      return false;
+    for (const [name, expected] of entry.own) {
+      const actual = Object.getOwnPropertyDescriptor(currentPrototype, name);
+      if (Boolean(actual) !== Boolean(expected) || actual && (!("value" in actual) || !expected || !("value" in expected) || actual.value !== expected.value))
+        return false;
+    }
+    currentPrototype = Object.getPrototypeOf(currentPrototype);
+  }
+  if (currentPrototype !== Object.prototype && currentPrototype !== null)
+    return false;
+  for (const name of storage) {
+    for (let current = field; current; current = Object.getPrototypeOf(current)) {
+      const descriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (!descriptor)
+        continue;
+      if (!("value" in descriptor))
+        return false;
+      break;
+    }
+  }
+  for (const [name, expected] of trusted.methods) {
+    if (owns(field, name) || inherited(field, name) !== expected)
+      return false;
+  }
+  for (let current = field; current; current = Object.getPrototypeOf(current)) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, "validator_");
+    if (descriptor)
+      return "value" in descriptor && descriptor.value == null;
+  }
+  return false;
+};
+var arrayData = (value) => {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype)
+    return null;
+  const result = [];
+  for (let index = 0; index < value.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor || !("value" in descriptor))
+      return null;
+    result.push(descriptor.value);
+  }
+  return result;
+};
+var staticValues = (field) => {
+  const items = arrayData(own(field, "menuGenerator_"));
+  if (!items || items.length === 0)
+    return null;
+  const values = [];
+  for (const item of items) {
+    const tuple = arrayData(item);
+    if (!tuple || tuple.length !== 2 || typeof tuple[0] !== "string" || typeof tuple[1] !== "string")
+      return null;
+    values.push(tuple[1]);
+  }
+  return Object.freeze(values);
+};
+var rawKeys = ["text_", "value_", "colour_", "hue_", "saturation_", "brightness_"];
+var ownState = (object, keys) => keys.map((name) => [name, Object.getOwnPropertyDescriptor(object, name)]);
+var restoreOwnState = (object, state) => {
+  for (const [name, descriptor] of state) {
+    if (descriptor)
+      Object.defineProperty(object, name, descriptor);
+    else
+      delete object[name];
+  }
+};
+var vmFieldsIdentity = (fields, identify) => Object.keys(fields || {}).sort().map((name) => {
+  const descriptor = Object.getOwnPropertyDescriptor(fields, name);
+  if (!descriptor || !("value" in descriptor))
+    return [name, "accessor"];
+  const stored = descriptor.value;
+  if (!stored || typeof stored !== "object")
+    return [name, typeof stored, String(stored)];
+  return [name, identify(stored), ...Object.keys(stored).sort().map((key) => {
+    const item = Object.getOwnPropertyDescriptor(stored, key);
+    if (!item || !("value" in item))
+      return [key, "accessor"];
+    const value = item.value;
+    return [key, typeof value, primitive(value) ? Object.is(value, -0) ? "-0" : String(value) : value && (typeof value === "object" || typeof value === "function") ? identify(value) : String(value)];
+  })];
+});
+var colorState = (block, field) => {
+  const colors = ["getColour", "getColourSecondary", "getColourTertiary", "getColourQuaternary"];
+  return {
+    colors: colors.map((name) => typeof block[name] === "function" ? block[name]() : void 0),
+    hsv: ["hue_", "saturation_", "brightness_"].map((name) => [name, own(field, name)]),
+    blockProperties: ownState(block, ["colour_", "colourSecondary_", "colourTertiary_", "colourQuaternary_"])
+  };
+};
+function inspectFixedArgument({ ScratchBlocks, block, vmBlock, target, argument, role, identify, extensionId }) {
+  initializeFixedFields(ScratchBlocks);
+  const sourceIdentity = [argument, identify(block), identify(vmBlock)];
+  let observedFields = [];
+  const unavailable = (source, reason, raw2) => ({
+    slot: primitive(raw2) ? { kind: "literal", value: raw2 } : { kind: "reporter" },
+    metadata: { role, source, identity: JSON.stringify([...sourceIdentity, source]), reason },
+    signatureParts: [...sourceIdentity, observedFields]
+  });
+  const direct = block.getField(argument);
+  const input = block.getInput(argument);
+  const connected = input && input.connection && input.connection.targetBlock();
+  const vmInput = vmBlock.inputs && vmBlock.inputs[argument];
+  if ((connected ? connected.id : null) !== (vmInput && vmInput.block ? vmInput.block : null))
+    return null;
+  if (direct && connected)
+    return null;
+  if (connected && !connected.isShadow()) {
+    const vmReporter = target.blocks.getBlock(connected.id);
+    if (!vmReporter || vmReporter.opcode !== connected.type || vmReporter.parent !== block.id)
+      return null;
+    sourceIdentity.push(identify(connected), identify(vmReporter), connected.id, connected.type);
+    return {
+      slot: { kind: "reporter" },
+      metadata: { role, source: "reporter", identity: JSON.stringify(sourceIdentity) },
+      signatureParts: sourceIdentity
+    };
+  }
+  let owner = direct ? block : connected;
+  if (!owner) {
+    if (vmBlock.fields && owns(vmBlock.fields, argument))
+      return null;
+    return unavailable("missing", "The declared field or input is missing.");
+  }
+  const vmOwner = direct ? vmBlock : target.blocks.getBlock(owner.id);
+  if (!vmOwner || vmOwner.opcode !== owner.type)
+    return null;
+  sourceIdentity.push(identify(owner), identify(vmOwner), owner.id, owner.type);
+  observedFields = vmFieldsIdentity(vmOwner.fields, identify);
+  if (!direct && (!vmInput || vmInput.shadow !== owner.id || vmOwner.parent !== block.id))
+    return null;
+  let kind;
+  let name;
+  let Class;
+  if (direct) {
+    kind = "menu";
+    name = argument;
+    Class = ScratchBlocks.FieldDropdown;
+  } else if (owner.type === "text") {
+    kind = "text";
+    name = "TEXT";
+    Class = ScratchBlocks.FieldTextInput;
+  } else if (owner.type === "math_number") {
+    kind = "number";
+    name = "NUM";
+    Class = ScratchBlocks.FieldNumber;
+  } else if (owner.type === "colour_picker") {
+    kind = "color";
+    name = "COLOUR";
+    Class = ScratchBlocks.FieldColourSlider;
+  } else if (typeof extensionId === "string" && owner.type.startsWith(`${extensionId}_menu_`)) {
+    kind = "menu";
+    Class = ScratchBlocks.FieldDropdown;
+    const names = [];
+    for (const row of owner.inputList)
+      for (const candidate of row.fieldRow) {
+        const candidateName = own(candidate, "name");
+        if (typeof candidateName === "string" && candidateName)
+          names.push(candidateName);
+      }
+    if (names.length !== 1)
+      return unavailable("unsupported", "The menu shadow does not have one standard field.");
+    [name] = names;
+  } else
+    return unavailable("unsupported", "The shadow field family is unsupported.");
+  const field = direct || owner.getField(name);
+  const stored = vmOwner.fields && vmOwner.fields[name];
+  if (!field || !stored)
+    return null;
+  sourceIdentity.push(identify(field), name);
+  const raw = own(stored, "value");
+  if (!safeField(field, Class))
+    return unavailable("unsupported", "The field class, methods or validator is unsupported.", raw);
+  const value = inherited(Class.prototype, "getValue").call(field);
+  if (!Object.is(value, raw))
+    return null;
+  if (typeof value !== "string")
+    return unavailable("unsupported", "The native field value is not a string.", raw);
+  const allowedValues = kind === "menu" ? staticValues(field) : void 0;
+  if (kind === "menu" && !allowedValues)
+    return unavailable("unsupported", "Dynamic or nonstandard menus are unsupported.", raw);
+  sourceIdentity.push(kind, ...allowedValues || []);
+  const binding = {
+    block: owner,
+    field,
+    fieldName: name,
+    value,
+    vmBlock: vmOwner,
+    kind,
+    Class,
+    prototype: Class.prototype,
+    allowedValues,
+    restoreValue: inherited(Class.prototype, "setValue"),
+    rawState: ownState(field, rawKeys),
+    restoreHandles: inherited(Class.prototype, "updateSliderHandles_"),
+    restoreDom: inherited(Class.prototype, "updateDom_"),
+    ...kind === "color" ? { restoreState: colorState(owner, field) } : {}
+  };
+  return {
+    slot: { kind: "literal", value },
+    metadata: {
+      role,
+      source: direct ? "field" : "shadow",
+      identity: JSON.stringify(sourceIdentity),
+      field: { blockId: owner.id, name, type: { text: "FieldTextInput", number: "FieldNumber", menu: "FieldDropdown", color: "FieldColourSlider" }[kind] }
+    },
+    ...role === "editable" ? { binding } : {},
+    signatureParts: [...sourceIdentity, observedFields]
+  };
+}
+function prepareFixedChange(binding, value) {
+  if (!binding || !safeField(binding.field, binding.Class) || typeof value !== "string") {
+    throw new TypeError("Only standard native string field writes are supported.");
+  }
+  if (binding.kind === "menu") {
+    const currentValues = staticValues(binding.field);
+    if (!currentValues || currentValues.length !== binding.allowedValues.length || currentValues.some((item, index) => item !== binding.allowedValues[index])) {
+      throw new TypeError("The static menu changed before preparing the write.");
+    }
+  }
+  if (value !== binding.value) {
+    if (binding.kind === "number" && (!token.test(value.trim()) || !Number.isFinite(Number(value)))) {
+      throw new TypeError("Expected a finite numeric field token.");
+    }
+    if (binding.kind === "color" && !/^#(?:[a-f0-9]{3}|[a-f0-9]{6})$/iu.test(value)) {
+      throw new TypeError("Expected a hexadecimal color field token.");
+    }
+    if (binding.kind === "menu" && !binding.allowedValues.includes(value)) {
+      throw new TypeError("Expected a declared static menu value.");
+    }
+  }
+  return { ...binding, next: value };
+}
+function captureFixedFieldState(binding) {
+  if (!binding || !safeField(binding.field, binding.Class)) {
+    throw new TypeError("Cannot capture an unsupported native field.");
+  }
+  const value = inherited(binding.prototype, "getValue").call(binding.field);
+  if (typeof value !== "string")
+    throw new TypeError("Expected a native string field.");
+  return {
+    ...binding,
+    value,
+    rawState: ownState(binding.field, rawKeys),
+    ...binding.kind === "color" ? { restoreState: colorState(binding.block, binding.field) } : {}
+  };
+}
+function restoreFixedField(binding) {
+  let failure;
+  try {
+    binding.restoreValue.call(binding.field, binding.value);
+  } catch (error) {
+    failure = error;
+  }
+  restoreOwnState(binding.field, binding.rawState);
+  if (binding.restoreState) {
+    const colors = binding.restoreState.colors;
+    try {
+      if (colors.every((value) => typeof value === "string"))
+        binding.block.setColour(...colors);
+    } catch (error) {
+      failure = failure || error;
+    }
+    restoreOwnState(binding.block, binding.restoreState.blockProperties);
+    try {
+      binding.restoreHandles.call(binding.field);
+    } catch (error) {
+      failure = failure || error;
+    }
+    try {
+      binding.restoreDom.call(binding.field);
+    } catch (error) {
+      failure = failure || error;
+    }
+  }
+  if (failure)
+    throw failure;
+}
+
+// dist/turbowarp/fixed-transaction.js
+var own2 = (object, name) => {
+  const descriptor = object && Object.getOwnPropertyDescriptor(object, name);
+  if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+    throw new TypeError("Expected an own data property.");
+  }
+  return descriptor.value;
+};
+var inheritedData = (object, key) => {
+  for (let item = object; item; item = Object.getPrototypeOf(item)) {
+    const descriptor = Object.getOwnPropertyDescriptor(item, key);
+    if (descriptor) {
+      if (!("value" in descriptor))
+        throw new TypeError("Unsupported undo configuration.");
+      return descriptor.value;
+    }
+  }
+  return void 0;
+};
+var ensureNativeHistory = (stack) => {
+  if (!Array.isArray(stack) || !Object.isExtensible(stack) || Object.getOwnPropertySymbols(stack).length || !Object.getOwnPropertyDescriptor(stack, "length").writable) {
+    throw new TypeError("Unsupported undo history.");
+  }
+  if (Object.getOwnPropertyNames(stack).length !== stack.length + 1)
+    throw new TypeError("Unsupported undo history.");
+  for (let index = 0; index < stack.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(stack, String(index));
+    if (!descriptor || !("value" in descriptor) || !descriptor.writable || !descriptor.configurable) {
+      throw new TypeError("Unsupported undo history.");
+    }
+  }
+};
+var copyHistory = (stack) => {
+  const copy = [];
+  for (let index = 0; index < stack.length; index++)
+    copy.push(own2(stack, String(index)));
+  return copy;
+};
+var replaceHistory = (stack, values) => {
+  stack.length = 0;
+  for (const value of values)
+    Array.prototype.push.call(stack, value);
+};
+var conflict = () => {
+  throw new BlockEditorConflictError();
+};
+var aborted = Object.getOwnPropertyDescriptor(AbortSignal.prototype, "aborted").get;
+var isAborted = (signal) => aborted.call(signal);
+var optionalOwn = (object, name) => {
+  const descriptor = object && Object.getOwnPropertyDescriptor(object, name);
+  if (descriptor && !Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+    throw new TypeError("VM state must contain data properties.");
+  }
+  return descriptor && descriptor.value;
+};
+var stateToken = (value, identify, seen = /* @__PURE__ */ new Set()) => {
+  if (typeof value === "number")
+    return ["number", Object.is(value, -0) ? "-0" : String(value)];
+  if (value === void 0)
+    return ["undefined"];
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value !== "object" || seen.has(value) || seen.size > 64)
+    throw new TypeError("Unsupported VM state.");
+  seen.add(value);
+  const result = Object.getOwnPropertyNames(value).sort().map((key) => [key, stateToken(own2(value, key), identify, seen)]);
+  seen.delete(value);
+  return ["object", identify(value), result];
+};
+var untouchedState = (block, vmBlock, target, bindings, identify) => {
+  const omitted = /* @__PURE__ */ new Map();
+  for (const binding of bindings.values()) {
+    if (!omitted.has(binding.vmBlock))
+      omitted.set(binding.vmBlock, /* @__PURE__ */ new Set());
+    omitted.get(binding.vmBlock).add(binding.fieldName);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const records = [];
+  const capture = (item) => {
+    if (!item || seen.has(item))
+      return;
+    seen.add(item);
+    const fields = item.fields || {};
+    records.push([identify(item), ["id", "opcode", "parent", "next", "inputs", "mutation", "shadow", "topLevel"].map((key) => [key, stateToken(optionalOwn(item, key), identify)]), identify(fields), Object.keys(fields).sort().map((key) => {
+      var _a;
+      const field = own2(fields, key);
+      if (!((_a = omitted.get(item)) === null || _a === void 0 ? void 0 : _a.has(key)))
+        return [key, stateToken(field, identify)];
+      return [key, identify(field), Object.getOwnPropertyNames(field).sort().filter((property) => property !== "value").map((property) => [property, stateToken(own2(field, property), identify)])];
+    })]);
+  };
+  capture(vmBlock);
+  const connections = [];
+  for (const input of block.inputList) {
+    const connected = input.connection && input.connection.targetBlock();
+    connections.push([input.name || "", identify(input), input.connection ? identify(input.connection) : null, connected ? [connected.id, connected.type, identify(connected)] : null]);
+    if (connected)
+      capture(target.blocks.getBlock(connected.id));
+  }
+  const statementConnections = ["nextConnection", "previousConnection", "outputConnection"].map((name) => {
+    const connection = block[name];
+    const connected = connection && connection.targetBlock();
+    return [
+      name,
+      connection ? identify(connection) : null,
+      connection && connection.targetConnection ? identify(connection.targetConnection) : null,
+      connected ? [connected.id, connected.type, identify(connected)] : null
+    ];
+  });
+  return JSON.stringify([records, connections, statementConnections]);
+};
+var sameDeclaration = (left, right) => JSON.stringify(captureFixedInputDeclaration(left)) === JSON.stringify(captureFixedInputDeclaration(right));
+function createFixedInputPort({ ScratchBlocks, workspace, vm, registry, identify, getState, begin, markEvent, finish, onError, subscribeScope }) {
+  initializeFixedFields(ScratchBlocks);
+  const inspect = (reference, suppliedDeclaration) => {
+    const state = getState();
+    const target = vm.editingTarget;
+    if (state.disposed || !target || target.id !== reference.targetId || workspace.isFlyout || workspace.options.readOnly || workspace.isDragging && workspace.isDragging())
+      return null;
+    const block = workspace.getBlockById(reference.blockId);
+    if (!block || block.isInFlyout || block.isShadow() || !block.isEditable())
+      return null;
+    const descriptor = registry.resolve(block.type);
+    const declaration = registry.resolveFixed(block.type);
+    if (!descriptor || !declaration || !sameDeclaration(declaration, suppliedDeclaration))
+      return null;
+    const vmBlock = target.blocks.getBlock(block.id);
+    const nextBlock = block.nextConnection && block.nextConnection.targetBlock();
+    if (!vmBlock || (nextBlock ? nextBlock.id : null) !== (vmBlock.next || null) || vmBlock.opcode !== block.type || (block.getParent() ? block.getParent().id : null) !== (vmBlock.parent || null))
+      return null;
+    const arguments_ = /* @__PURE__ */ Object.create(null);
+    const inputs = /* @__PURE__ */ Object.create(null);
+    const bindings = /* @__PURE__ */ new Map();
+    const signature = [state.revision, identify(target), identify(block), identify(vmBlock), identify(declaration)];
+    for (const [role, names] of [["editable", declaration.editableArguments], ["readonly", declaration.readOnlyArguments]]) {
+      for (const argument of names) {
+        const item = inspectFixedArgument({
+          ScratchBlocks,
+          block,
+          vmBlock,
+          target,
+          argument,
+          role,
+          identify,
+          extensionId: descriptor.extensionId
+        });
+        if (!item)
+          return null;
+        arguments_[argument] = item.slot;
+        inputs[argument] = item.metadata;
+        if (role === "editable" && item.binding)
+          bindings.set(argument, item.binding);
+        signature.push(argument, item.signatureParts);
+      }
+    }
+    const untouched = untouchedState(block, vmBlock, target, bindings, identify);
+    signature.push(untouched);
+    const snapshot = captureFixedSnapshot({
+      targetId: target.id,
+      blockId: block.id,
+      opcode: block.type,
+      revision: JSON.stringify(signature),
+      arguments: arguments_,
+      fixedContext: {
+        contractId: declaration.contractId,
+        contractRevision: declaration.contractRevision,
+        generation: String(state.generation),
+        readOnlyArguments: declaration.readOnlyArguments,
+        dependencies: declaration.dependencies,
+        inputs
+      }
+    }, reference, declaration);
+    return { snapshot, bindings, declaration, target, block, vmBlock, state, untouched, runtime: vm.runtime };
+  };
+  const commit = (request) => {
+    var _a;
+    const expectedInput = own2(request, "expected");
+    const changesInput = own2(request, "changes");
+    const signal = own2(request, "signal");
+    try {
+      const contextInput = own2(request, "context");
+      const context = snapshotJson({
+        consumerId: own2(contextInput, "consumerId"),
+        nowMs: own2(contextInput, "nowMs"),
+        settings: own2(contextInput, "settings")
+      });
+      if (typeof context.consumerId !== "string" || !context.consumerId || typeof context.nowMs !== "number" || !Number.isFinite(context.nowMs)) {
+        throw new TypeError("Invalid fixed validation context.");
+      }
+    } catch (_b) {
+      throw new TypeError("Invalid fixed validation context.");
+    }
+    if (isAborted(signal))
+      conflict();
+    const expected = captureFixedSnapshot(expectedInput);
+    const current = inspect(expected, registry.resolveFixed(expected.opcode));
+    if (!current || !sameFixedSnapshot(expected, current.snapshot))
+      conflict();
+    const declaration = current.declaration;
+    captureFixedSnapshot(expected, expected, declaration);
+    if (!Array.isArray(changesInput))
+      throw new TypeError("Expected a fixed argument patch array.");
+    const prepared = [];
+    const seenNames = /* @__PURE__ */ new Set();
+    const seenFields = /* @__PURE__ */ new Set();
+    for (let i = 0; i < changesInput.length; i++) {
+      const change = own2(changesInput, String(i));
+      const name = own2(change, "argument");
+      const value = own2(change, "value");
+      if (typeof name !== "string" || seenNames.has(name) || !declaration.editableArguments.includes(name) || !current.bindings.has(name)) {
+        throw new TypeError("Only distinct editable standard fields may be changed.");
+      }
+      seenNames.add(name);
+      const binding = current.bindings.get(name);
+      if (seenFields.has(binding.field))
+        throw new TypeError("Duplicate field write.");
+      seenFields.add(binding.field);
+      if (Object.is(value, binding.value))
+        continue;
+      prepared.push({ ...prepareFixedChange(binding, value), argument: name });
+    }
+    if (validateFixedBranchChanges(declaration, expected, prepared.map((item) => ({ argument: item.argument, value: item.next }))).length) {
+      throw new TypeError("Fixed branch changes require a valid canonical branch policy.");
+    }
+    const guard = () => {
+      const state = getState();
+      if (isAborted(signal) || state.disposed || state.generation !== current.state.generation || state.externalRevision !== current.state.externalRevision || vm.editingTarget !== current.target || vm.runtime !== current.runtime || registry.resolveFixed(expected.opcode) !== declaration)
+        conflict();
+    };
+    guard();
+    const beforeWrite = inspect(expected, declaration);
+    if (!beforeWrite || !sameFixedSnapshot(expected, beforeWrite.snapshot))
+      conflict();
+    guard();
+    if (!prepared.length)
+      return;
+    const Events = ScratchBlocks.Events;
+    if (!Events.isEnabled() || !Events.recordUndo || Events.getGroup() || !Array.isArray(workspace.undoStack_) || !Array.isArray(workspace.redoStack_)) {
+      throw new Error("The workspace is busy or its undo API is unsupported.");
+    }
+    const undoStack = workspace.undoStack_;
+    const redoStack = workspace.redoStack_;
+    ensureNativeHistory(undoStack);
+    ensureNativeHistory(redoStack);
+    const configuredMaxUndo = inheritedData(workspace, "MAX_UNDO");
+    const maxUndo = configuredMaxUndo === void 0 ? Infinity : configuredMaxUndo;
+    if (maxUndo !== Infinity && (!Number.isSafeInteger(maxUndo) || maxUndo < 0)) {
+      throw new TypeError("Unsupported undo configuration.");
+    }
+    const undo = copyHistory(undoStack);
+    const redo = copyHistory(redoStack);
+    const oldGroup = Events.getGroup();
+    const runtime = current.runtime;
+    const dirty = runtime.emitProjectChanged;
+    const dirtyDescriptor = Object.getOwnPropertyDescriptor(runtime, "emitProjectChanged");
+    const savedVmFields = prepared.map((item) => ({
+      binding: item,
+      block: item.vmBlock,
+      name: item.fieldName,
+      fields: item.vmBlock.fields,
+      field: item.vmBlock.fields[item.fieldName],
+      descriptors: Object.getOwnPropertyDescriptors(item.vmBlock.fields[item.fieldName])
+    }));
+    let succeeded = false;
+    let failure;
+    let activeEvent = null;
+    const pendingHistory = [];
+    const externalWrites = /* @__PURE__ */ new Map();
+    const byField = new Map(prepared.map((item) => [JSON.stringify([item.block.id, item.fieldName]), item]));
+    let externalDirty = false;
+    const ownedEvents = /* @__PURE__ */ new WeakSet();
+    const originalDelivery = workspace.fireChangeListener;
+    const deliveryDescriptor = Object.getOwnPropertyDescriptor(workspace, "fireChangeListener");
+    const stableScope = () => {
+      const state = getState();
+      return state.generation === current.state.generation && vm.editingTarget === current.target && vm.runtime === runtime;
+    };
+    let begun = false;
+    try {
+      runtime.emitProjectChanged = () => {
+        if (!activeEvent || !ownedEvents.has(activeEvent) || !stableScope())
+          externalDirty = true;
+      };
+      workspace.fireChangeListener = function(event) {
+        const previous = activeEvent;
+        const external = event && !event.isUiEvent && !ownedEvents.has(event);
+        const edited = external && event.type === "change" && event.element === "field" && byField.get(JSON.stringify([event.blockId, event.name]));
+        if (edited && !externalWrites.has(edited.field)) {
+          if (Object.is(event.oldValue, edited.next))
+            event.oldValue = edited.value;
+          externalWrites.set(edited.field, null);
+        }
+        activeEvent = event;
+        try {
+          return originalDelivery.call(this, event);
+        } finally {
+          if (edited) {
+            const fields = edited.vmBlock.fields;
+            const field = fields && fields[edited.fieldName];
+            externalWrites.set(edited.field, {
+              binding: captureFixedFieldState(edited),
+              fields,
+              field,
+              descriptors: field && Object.getOwnPropertyDescriptors(field)
+            });
+          }
+          activeEvent = previous;
+        }
+      };
+      Events.setGroup(true);
+      Events.disable();
+      begin();
+      begun = true;
+      guard();
+      for (const item of prepared) {
+        guard();
+        item.field.setValue(item.next);
+        if (!Object.is(item.field.getValue(), item.next))
+          throw new Error("The field rejected its value.");
+        guard();
+      }
+      for (const item of prepared) {
+        guard();
+        const event = new Events.Change(item.block, "field", item.fieldName, item.value, item.next);
+        ownedEvents.add(event);
+        markEvent(event);
+        const recordUndo = event.recordUndo;
+        event.recordUndo = false;
+        try {
+          workspace.fireChangeListener(event);
+        } finally {
+          event.recordUndo = recordUndo;
+        }
+        if (recordUndo)
+          pendingHistory.push(event);
+        guard();
+      }
+      const after = inspect(expected, declaration);
+      if (!after || after.untouched !== current.untouched)
+        conflict();
+      const wantedArguments = { ...expected.arguments };
+      for (const item of prepared)
+        wantedArguments[item.argument] = { kind: "literal", value: item.next };
+      if (!sameFixedSnapshot({ ...expected, revision: after.snapshot.revision, arguments: wantedArguments }, after.snapshot))
+        conflict();
+      guard();
+      if (workspace.undoStack_ !== undoStack || workspace.redoStack_ !== redoStack || undoStack.length !== undo.length || redoStack.length !== redo.length || undo.some((entry, index) => undoStack[index] !== entry) || redo.some((entry, index) => redoStack[index] !== entry))
+        conflict();
+      ensureNativeHistory(undoStack);
+      ensureNativeHistory(redoStack);
+      try {
+        for (const event of pendingHistory)
+          Array.prototype.push.call(undoStack, event);
+        if (undoStack.length > maxUndo) {
+          Array.prototype.copyWithin.call(undoStack, 0, undoStack.length - maxUndo);
+          undoStack.length = maxUndo;
+        }
+        redoStack.length = 0;
+      } catch (error) {
+        replaceHistory(undoStack, undo);
+        replaceHistory(redoStack, redo);
+        throw error;
+      }
+      succeeded = true;
+    } catch (error) {
+      failure = error;
+      for (const item of begun ? prepared : []) {
+        try {
+          restoreFixedField(((_a = externalWrites.get(item.field)) === null || _a === void 0 ? void 0 : _a.binding) || item);
+        } catch (restoreError) {
+          try {
+            onError(restoreError);
+          } catch (_c) {
+          }
+        }
+      }
+      for (const saved of begun ? savedVmFields : []) {
+        const outside = externalWrites.get(saved.binding.field);
+        const fields = saved.block.fields;
+        if (!fields)
+          continue;
+        const field = outside ? outside.field : saved.field;
+        const descriptors = outside ? outside.descriptors : saved.descriptors;
+        if (!field) {
+          delete fields[saved.name];
+          continue;
+        }
+        fields[saved.name] = field;
+        for (const key of Object.keys(field))
+          if (!Object.hasOwn(descriptors, key))
+            delete field[key];
+        Object.defineProperties(field, descriptors);
+      }
+      if (begun && typeof current.target.blocks.resetCache === "function")
+        current.target.blocks.resetCache();
+    } finally {
+      try {
+        if (begun)
+          finish(succeeded);
+      } finally {
+        try {
+          if (!Events.isEnabled())
+            Events.enable();
+        } finally {
+          try {
+            Events.setGroup(oldGroup);
+          } finally {
+            if (deliveryDescriptor)
+              Object.defineProperty(workspace, "fireChangeListener", deliveryDescriptor);
+            else
+              delete workspace.fireChangeListener;
+            if (dirtyDescriptor)
+              Object.defineProperty(runtime, "emitProjectChanged", dirtyDescriptor);
+            else
+              delete runtime.emitProjectChanged;
+          }
+        }
+      }
+    }
+    if (succeeded || externalDirty) {
+      try {
+        dirty.call(runtime);
+      } catch (error) {
+        try {
+          onError(error);
+        } catch (_d) {
+        }
+      }
+    }
+    if (!succeeded)
+      throw failure;
+  };
+  return Object.freeze({
+    capability: FIXED_INPUTS_CAPABILITY,
+    readBlock: (reference, declaration) => {
+      var _a;
+      return ((_a = inspect(reference, declaration)) === null || _a === void 0 ? void 0 : _a.snapshot) || null;
+    },
+    commit,
+    subscribeInvalidation: (reference, declaration, listener) => {
+      const captured = inspect(reference, declaration);
+      if (!captured || typeof subscribeScope !== "function") {
+        listener(new BlockEditorConflictError());
+        return () => {
+        };
+      }
+      let active = true;
+      const check = () => {
+        const state = getState();
+        if (!active || !state.disposed && state.generation === captured.state.generation && vm.editingTarget === captured.target && vm.runtime === captured.runtime && workspace.getBlockById(reference.blockId) === captured.block && captured.target.blocks.getBlock(reference.blockId) === captured.vmBlock && registry.resolveFixed(captured.snapshot.opcode) === captured.declaration)
+          return;
+        active = false;
+        listener(new BlockEditorConflictError());
+      };
+      const unsubscribe = subscribeScope(check);
+      return () => {
+        active = false;
+        unsubscribe();
+      };
+    }
+  });
+}
+
+// dist/turbowarp/host.js
+var owns2 = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDescendants = false, enableFixedInputs = false, onError = console.error }) => {
   let disposed = false;
   let committing = false;
   let revision = 0;
   let identity = 0;
   let generation = 1;
+  let externalRevision = 0;
+  let fixedTransaction = null;
   let lastTarget = vm.editingTarget;
   const versions = /* @__PURE__ */ new Map();
   const invalidations = /* @__PURE__ */ new Set();
+  const fixedScopeListeners = /* @__PURE__ */ new Set();
+  const notifyFixedScopes = () => {
+    for (const listener of [...fixedScopeListeners]) {
+      try {
+        listener();
+      } catch (error) {
+        try {
+          onError(error);
+        } catch (_a) {
+        }
+      }
+    }
+  };
   let notifyInvalidations = () => {
   };
   const identities = /* @__PURE__ */ new WeakMap();
@@ -89,6 +910,16 @@ var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDes
     if (event && event.isUiEvent)
       return;
     revision++;
+    if (fixedTransaction && event && fixedTransaction.events.has(event)) {
+      fixedTransaction.revisions++;
+      if (enableDescendants) {
+        for (const id of /* @__PURE__ */ new Set([event.blockId, ...event.ids || []])) {
+          if (id)
+            fixedTransaction.versions.set(id, (fixedTransaction.versions.get(id) || 0) + 1);
+        }
+      }
+    } else
+      externalRevision++;
     if (enableDescendants && event) {
       const ids = /* @__PURE__ */ new Set([event.blockId, ...event.ids || []]);
       for (const id of ids)
@@ -97,6 +928,7 @@ var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDes
     }
     if (!committing)
       notifyInvalidations();
+    notifyFixedScopes();
   };
   const renew = () => {
     generation++;
@@ -122,6 +954,8 @@ var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDes
     if (!block || block.isInFlyout || block.isShadow())
       return null;
     const descriptor = registry.resolve(block.type);
+    if (typeof registry.resolveFixed === "function" && registry.resolveFixed(block.type))
+      return null;
     const vmBlock = target.blocks.getBlock(block.id);
     if (!structural && !descriptor || !block.isEditable() && (!structural || descriptor) || !vmBlock || vmBlock.opcode !== block.type)
       return null;
@@ -278,7 +1112,7 @@ var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDes
     return changes.map((change) => {
       const record = change && records.get(change.blockId);
       const key = change && JSON.stringify([change.blockId, change.argument]);
-      if (!record || typeof change.value !== "string" || seen.has(key) || !owns(record.snapshot.arguments, change.argument) || !record.fields.has(change.argument)) {
+      if (!record || typeof change.value !== "string" || seen.has(key) || !owns2(record.snapshot.arguments, change.argument) || !record.fields.has(change.argument)) {
         throw new TypeError("Only distinct standard text shadow changes are supported.");
       }
       seen.add(key);
@@ -292,10 +1126,17 @@ var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDes
   const host = {
     isCommitting: () => committing,
     readBlock: (reference) => {
+      const block = workspace.getBlockById(reference.blockId);
+      const declaration = block && typeof registry.resolveFixed === "function" && registry.resolveFixed(block.type);
+      if (declaration)
+        return host.fixedInputs ? host.fixedInputs.readBlock(reference, declaration) : null;
       const result = inspect(reference);
       return result ? result.snapshot : null;
     },
     commit: ({ expected, changes }) => {
+      if (typeof registry.resolveFixed === "function" && registry.resolveFixed(expected.opcode)) {
+        throw new TypeError("Fixed input editors require the fixed transaction port.");
+      }
       const current = inspect(expected);
       if (!current || JSON.stringify(current.snapshot) !== JSON.stringify(expected)) {
         throw new BlockEditorConflictError();
@@ -305,6 +1146,8 @@ var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDes
     invalidate: renew,
     dispose: () => {
       disposed = true;
+      notifyFixedScopes();
+      fixedScopeListeners.clear();
       notifyInvalidations();
       invalidations.clear();
       workspace.removeChangeListener(invalidate);
@@ -338,6 +1181,42 @@ var createBlockEditorHost = ({ ScratchBlocks, workspace, vm, registry, enableDes
       }
     };
   }
+  if (enableFixedInputs === true) {
+    host.fixedInputs = createFixedInputPort({
+      ScratchBlocks,
+      workspace,
+      vm,
+      registry,
+      identify,
+      onError,
+      subscribeScope: (listener) => {
+        fixedScopeListeners.add(listener);
+        return () => {
+          fixedScopeListeners.delete(listener);
+        };
+      },
+      getState: () => ({ disposed, revision, generation, externalRevision }),
+      begin: () => {
+        committing = true;
+        fixedTransaction = { events: /* @__PURE__ */ new WeakSet(), revisions: 0, versions: /* @__PURE__ */ new Map() };
+      },
+      markEvent: (event) => fixedTransaction.events.add(event),
+      finish: (succeeded) => {
+        if (!succeeded) {
+          revision -= fixedTransaction.revisions;
+          for (const [id, delta] of fixedTransaction.versions) {
+            const remaining = (versions.get(id) || 0) - delta;
+            if (remaining > 0)
+              versions.set(id, remaining);
+            else
+              versions.delete(id);
+          }
+        }
+        fixedTransaction = null;
+        committing = false;
+      }
+    });
+  }
   return host;
 };
 var host_default = createBlockEditorHost;
@@ -495,14 +1374,21 @@ var createBlockEditorErrorSession = (reference, error) => {
 var error_session_default = createBlockEditorErrorSession;
 
 // dist/turbowarp/bridge.js
-var openBlockEditorSession = ({ registry, reference, host, descendants }) => descendants && supportsDescendantEditing(host) ? registry.openDescendants(reference, host) : registry.open(reference, host);
-var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, canOpen, onOpen, onError, descendants = false }) => {
+var fixedDeclaration = (registry, snapshot) => snapshot && typeof registry.resolveFixed === "function" && registry.resolveFixed(snapshot.opcode);
+var openBlockEditorSession = ({ registry, reference, host, descendants }) => {
+  const snapshot = host.readBlock ? host.readBlock(reference) : null;
+  if (fixedDeclaration(registry, snapshot))
+    return supportsFixedInputEditing(host) ? registry.open(reference, host) : void 0;
+  return descendants && supportsDescendantEditing(host) ? registry.openDescendants(reference, host) : registry.open(reference, host);
+};
+var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, canOpen, onOpen, onError, descendants = false, fixedInputs = false }) => {
   const host = host_default({
     ScratchBlocks,
     workspace,
     vm,
     registry: service.registry,
     enableDescendants: descendants,
+    enableFixedInputs: fixedInputs,
     onError
   });
   const decorations = /* @__PURE__ */ new Map();
@@ -510,6 +1396,7 @@ var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, c
   let timer = null;
   let activeSession = null;
   let openingSnapshot = null;
+  let openingFixedDeclaration = null;
   let stopWaiting = null;
   const endSession = () => {
     const session = activeSession;
@@ -532,11 +1419,17 @@ var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, c
     }
   };
   const checkSession = () => {
+    var _a;
     if (host.isCommitting())
       return;
     if (!activeSession || !openingSnapshot || !["editing", "saving"].includes(activeSession.getState().status))
       return;
     const current = typeof activeSession.getNodes === "function" ? host.descendants.readSubtree(activeSession.reference) : host.readBlock(activeSession.reference);
+    if (openingFixedDeclaration) {
+      if (!current || ((_a = current.fixedContext) === null || _a === void 0 ? void 0 : _a.generation) !== openingSnapshot.fixedContext.generation || fixedDeclaration(service.registry, current) !== openingFixedDeclaration)
+        endSession();
+      return;
+    }
     if (!current || JSON.stringify(current) !== JSON.stringify(openingSnapshot))
       endSession();
   };
@@ -544,6 +1437,8 @@ var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, c
     if (disposed || !vm.editingTarget || !canOpen() || !service.registry.resolve(block.type))
       return false;
     const snapshot = host.readBlock({ targetId: vm.editingTarget.id, blockId: block.id });
+    if (fixedDeclaration(service.registry, snapshot))
+      return supportsFixedInputEditing(host);
     return snapshot && Object.values(snapshot.arguments).every((slot) => slot.kind === "literal");
   };
   const open = (block) => {
@@ -558,6 +1453,7 @@ var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, c
         ScratchBlocks.hideChaff();
         activeSession = session;
         openingSnapshot = typeof session.getNodes === "function" ? host.descendants.readSubtree(session.reference) : host.readBlock(session.reference);
+        openingFixedDeclaration = fixedDeclaration(service.registry, openingSnapshot) || null;
         const labels = {};
         const appearances = /* @__PURE__ */ Object.create(null);
         if (typeof session.getNodes === "function") {
@@ -574,6 +1470,7 @@ var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, c
       onError(error);
       activeSession = error_session_default(reference, error);
       openingSnapshot = null;
+      openingFixedDeclaration = null;
       onOpen(activeSession);
     }
   };
@@ -622,7 +1519,12 @@ var createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, c
     timer = setTimeout(refresh, 0);
   };
   const unregister = service.subscribe(() => {
-    if (!activeSession || typeof activeSession.getNodes !== "function") {
+    if (openingFixedDeclaration && activeSession) {
+      if (service.registry.resolveFixed(openingSnapshot.opcode) !== openingFixedDeclaration) {
+        host.invalidate();
+        endSession();
+      }
+    } else if (!activeSession || typeof activeSession.getNodes !== "function") {
       host.invalidate();
       endSession();
     }
@@ -661,6 +1563,7 @@ function attachTurboWarpBlockEditors(options) {
   const bridge = bridge_default({
     ...options,
     descendants: options.descendants === true,
+    fixedInputs: options.fixedInputs === true,
     onError: (_a = options.onError) !== null && _a !== void 0 ? _a : console.error
   });
   let disposed = false;