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

package/dist/source-schema-hints.js

@@ -0,0 +1,13 @@
+import { Ajv } from 'ajv';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import formats from 'ajv-formats';
+import { prepare } from './schema-engine.js';
+import { snapshotJson } from './schema-json.js';
+/** Resolve refs on a private view using the same URI/anchor registry as canonical validation. */
+export function prepareSourceVariant(variant) {
+    const view = snapshotJson(variant);
+    const ajv = view.schemaBundle.dialect === 'draft-07' ? new Ajv({ strict: false }) : new Ajv2020({ strict: false });
+    formats.default(ajv);
+    prepare(view.schemaBundle, ajv);
+    return view;
+}

package/dist/source-types.d.ts

@@ -0,0 +1,47 @@
+import type { SchemaBundle, SchemaJsonObject, SchemaJsonValue, SchemaValidationContext } from './schema-types.js';
+/** Source strings remain authoritative; decoded values are only an editing view. */
+export interface SourceDocument {
+    readonly source: string;
+    readonly format: 'json' | 'yaml';
+    readonly variantId: string;
+    readonly data: SchemaJsonValue;
+}
+export interface SourceVariant {
+    readonly variantId: string;
+    readonly format: 'json' | 'yaml';
+    readonly schemaBundle: SchemaBundle;
+    readonly uiSchema?: SchemaJsonObject;
+}
+export interface SourceValidation {
+    readonly source: string;
+    readonly result: {
+        readonly kind: 'valid';
+        readonly diagnostics: readonly [];
+    } | {
+        readonly kind: 'invalid' | 'execution-error' | 'schema-error';
+        readonly diagnostics: readonly {
+            readonly code: string;
+            readonly dataPath?: string;
+        }[];
+    };
+}
+export interface SourceBinding<C = null> {
+    readonly argument: string;
+    readonly label?: string;
+    readonly variants: readonly SourceVariant[];
+    /** Explicit owner-defined source-only cases, for example a valid empty scene. */
+    readonly sourceOnlyVariants?: readonly {
+        readonly variantId: string;
+        readonly format: 'json' | 'yaml';
+    }[];
+    decode(source: string): SourceDocument;
+    validateSource(source: string, context: SchemaValidationContext<C>): SourceValidation;
+}
+export interface SourceEditorOptions<C = null> {
+    readonly apiVersion: 1;
+    readonly extensionId: string;
+    readonly editorId: string;
+    readonly opcodes: readonly string[];
+    readonly bindings: readonly SourceBinding<C>[];
+    readonly validationContext: () => SchemaValidationContext<C>;
+}

package/dist/source-types.js

@@ -0,0 +1 @@
+export {};

package/dist/source-view.d.ts

@@ -0,0 +1,3 @@
+import type { CapturedBinding } from './source-editor.js';
+import type { EditorViewContext } from './types.js';
+export declare function mountSourceView<C>(container: HTMLElement, context: EditorViewContext, bindings: readonly CapturedBinding<C>[]): () => void;

package/dist/source-view.js

@@ -0,0 +1,318 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { createSourceCandidate, patchDecodedSource, readSourceDocument } from './source-editor.js';
+import { cloneJson } from './data.js';
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const pointer = (path, key) => `${path}/${key.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+const typeOf = (v) => v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v;
+const initial = (type) => {
+    switch (type) {
+        case 'object': return {};
+        case 'array': return [];
+        case 'string': return '';
+        case 'number': return 0;
+        case 'boolean': return false;
+        default: return null;
+    }
+};
+function mergeHints(left, right) {
+    const result = { ...left, ...right };
+    for (const field of ['properties', 'patternProperties']) {
+        if (!record(left[field]) && !record(right[field]))
+            continue;
+        const a = record(left[field]) ? left[field] : {};
+        const b = record(right[field]) ? right[field] : {};
+        const combined = { ...a };
+        for (const [key, child] of Object.entries(b))
+            Object.defineProperty(combined, key, {
+                value: Object.hasOwn(a, key) ? { allOf: [a[key], child] } : child, enumerable: true
+            });
+        result[field] = combined;
+    }
+    if (Array.isArray(left.enum) && Array.isArray(right.enum)) {
+        result.enum = left.enum.filter(value => right.enum.some(other => JSON.stringify(value) === JSON.stringify(other)));
+    }
+    return result;
+}
+function propertyHint(hints, key) {
+    const matches = [];
+    if (record(hints.properties) && Object.hasOwn(hints.properties, key))
+        matches.push(hints.properties[key]);
+    if (record(hints.patternProperties))
+        for (const [pattern, schema] of Object.entries(hints.patternProperties)) {
+            try {
+                if (new RegExp(pattern, 'u').test(key))
+                    matches.push(schema);
+            }
+            catch ( /* The canonical compiler rejects invalid patterns. */_a) { /* The canonical compiler rejects invalid patterns. */ }
+        }
+    return matches.length > 1 ? { allOf: matches } : matches.length ? matches[0] : hints.additionalProperties;
+}
+/** Presentation hints never replace canonical validation or remove schema constraints. */
+function resolveHints(variant, schema, data, seen = new Set()) {
+    var _a;
+    if (!record(schema) || seen.has(schema))
+        return {};
+    seen.add(schema);
+    let result = { ...schema };
+    if (typeof schema.$ref === 'string') {
+        const ref = schema.$ref;
+        const hash = ref.indexOf('#');
+        const uri = hash < 0 ? ref : ref.slice(0, hash);
+        const resources = [variant.schemaBundle.root, ...variant.schemaBundle.resources];
+        const resource = uri ? resources.find(r => r.retrievalUri === uri || (record(r.document) && r.document.$id === uri)) : variant.schemaBundle.root;
+        let target = resource === null || resource === void 0 ? void 0 : resource.document;
+        const fragment = hash < 0 ? '' : decodeURIComponent(ref.slice(hash + 1));
+        if (fragment.startsWith('/'))
+            for (const part of fragment.slice(1).split('/')) {
+                target = record(target) || Array.isArray(target) ? target[part.replace(/~1/g, '/').replace(/~0/g, '~')] : undefined;
+            }
+        if (!fragment || fragment.startsWith('/'))
+            result = mergeHints(resolveHints(variant, target, data, seen), result);
+    }
+    if (Array.isArray(schema.allOf))
+        for (const part of schema.allOf) {
+            const next = resolveHints(variant, part, data, seen);
+            result = mergeHints(result, next);
+        }
+    const alternatives = (_a = schema.oneOf) !== null && _a !== void 0 ? _a : schema.anyOf;
+    if (Array.isArray(alternatives)) {
+        const choices = alternatives.filter(part => {
+            if (!record(part))
+                return false;
+            if (typeof part.type === 'string' && part.type !== typeOf(data) && !(part.type === 'integer' && typeof data === 'number'))
+                return false;
+            if (record(part.properties) && record(data))
+                for (const [key, child] of Object.entries(part.properties)) {
+                    if (record(child) && Object.hasOwn(child, 'const') && data[key] !== child.const)
+                        return false;
+                }
+            return true;
+        });
+        if (choices.length === 1)
+            result = mergeHints(result, resolveHints(variant, choices[0], data, seen));
+    }
+    if (!Array.isArray(result.enum)) {
+        if (Object.hasOwn(result, 'const'))
+            result.enum = [result.const];
+        else if (Array.isArray(alternatives)) {
+            const enums = alternatives.map(part => resolveHints(variant, part, data, new Set(seen)));
+            if (enums.length && enums.every(part => Array.isArray(part.enum))) {
+                const values = enums.flatMap(part => part.enum);
+                result.enum = [...new Map(values.map(value => [JSON.stringify(value), value])).values()];
+            }
+        }
+    }
+    return result;
+}
+function Tree({ value, path, schema, ui, variant, invalidNumbers, change: onChange }) {
+    var _a;
+    const hints = resolveHints(variant, schema, value);
+    const uiHints = record(ui) ? ui : {};
+    const [newKey, setNewKey] = React.useState('');
+    const change = (next, edit = { path }) => onChange(next, edit);
+    const choices = Array.isArray(hints.enum) ? hints.enum : Array.isArray(uiHints['ui:enum']) ? uiHints['ui:enum'] : undefined;
+    const label = typeof hints.title === 'string' ? hints.title : path || '/';
+    const props = { 'aria-label': label };
+    const type = typeOf(value);
+    let field;
+    if (choices) {
+        const serialized = JSON.stringify(value);
+        const options = choices.map(item => JSON.stringify(item));
+        if (!options.includes(serialized))
+            options.unshift(serialized);
+        field = React.createElement("select", { ...props, value: serialized, onChange: e => change(JSON.parse(e.target.value)) }, options.map(item => React.createElement("option", { key: item, value: item }, item)));
+    }
+    else if (typeof value === 'string') {
+        field = React.createElement("textarea", { ...props, value: value, onChange: e => change(e.target.value) });
+    }
+    else if (typeof value === 'number') {
+        field = React.createElement("input", { ...props, type: "text", inputMode: "decimal", value: (_a = invalidNumbers[path]) !== null && _a !== void 0 ? _a : String(value), onChange: e => {
+                const text = e.target.value;
+                const number = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/.test(text) ? Number(text) : NaN;
+                change(Number.isFinite(number) ? number : value, { path, ...(Number.isFinite(number) ? {} : { invalidText: text }) });
+            } });
+    }
+    else if (typeof value === 'boolean') {
+        field = React.createElement("input", { ...props, type: "checkbox", checked: value, onChange: e => change(e.target.checked) });
+    }
+    else if (Array.isArray(value)) {
+        field = React.createElement("div", null,
+            value.map((child, index) => {
+                var _a;
+                return React.createElement("div", { key: index },
+                    React.createElement(Tree, { invalidNumbers: invalidNumbers, value: child, path: pointer(path, String(index)), variant: variant, schema: Array.isArray(hints.prefixItems) ? (_a = hints.prefixItems[index]) !== null && _a !== void 0 ? _a : hints.items : Array.isArray(hints.items) ? hints.items[index] : hints.items, ui: uiHints.items, change: (next, edit) => { const copy = [...value]; copy[index] = next; change(copy, edit); } }),
+                    React.createElement("button", { type: "button", "aria-label": `Remove ${pointer(path, String(index))}`, onClick: () => change(value.filter((_, i) => i !== index), { path, removeIndex: index }) }, "Remove"),
+                    React.createElement("button", { type: "button", disabled: index === 0, "aria-label": `Move up ${pointer(path, String(index))}`, onClick: () => {
+                            const copy = [...value];
+                            [copy[index - 1], copy[index]] = [copy[index], copy[index - 1]];
+                            change(copy, { path, swap: [index - 1, index] });
+                        } }, "\u2191"));
+            }),
+            React.createElement("button", { type: "button", "aria-label": `Add item ${path || '/'}`, onClick: () => change([...value, null], { path: pointer(path, String(value.length)) }) }, "Add item"));
+    }
+    else if (value !== null && typeof value === 'object') {
+        const properties = record(hints.properties) ? hints.properties : {};
+        field = React.createElement("div", null,
+            Object.entries(value).map(([key, child]) => React.createElement("div", { key: key },
+                React.createElement(Tree, { invalidNumbers: invalidNumbers, value: child, path: pointer(path, key), variant: variant, schema: propertyHint(hints, key), ui: uiHints[key], change: (next, edit) => {
+                        const copy = cloneJson(value);
+                        Object.defineProperty(copy, key, { value: next, enumerable: true, writable: true, configurable: true });
+                        change(copy, edit);
+                    } }),
+                React.createElement("button", { type: "button", "aria-label": `Remove ${pointer(path, key)}`, onClick: () => {
+                        const copy = cloneJson(value);
+                        delete copy[key];
+                        change(copy, { path: pointer(path, key) });
+                    } }, "Remove"))),
+            React.createElement("label", null,
+                "Property ",
+                React.createElement("input", { "aria-label": `New property ${path || '/'}`, value: newKey, onChange: e => setNewKey(e.target.value) })),
+            React.createElement("select", { "aria-label": `Known property ${path || '/'}`, value: "", onChange: e => setNewKey(e.target.value) },
+                React.createElement("option", { value: "" }, "Choose property"),
+                Object.keys(properties).filter(key => !Object.hasOwn(value, key)).map(key => React.createElement("option", { key: key }, key))),
+            React.createElement("button", { type: "button", disabled: !newKey || Object.hasOwn(value, newKey), onClick: () => {
+                    const copy = cloneJson(value);
+                    Object.defineProperty(copy, newKey, { value: null, enumerable: true, writable: true, configurable: true });
+                    change(copy, { path: pointer(path, newKey) });
+                    setNewKey('');
+                } }, "Add property"));
+    }
+    else
+        field = React.createElement("span", null, "null");
+    return React.createElement("fieldset", { "data-source-path": path },
+        React.createElement("legend", null, label),
+        React.createElement("select", { "aria-label": `Type ${path || '/'}`, value: type, onChange: e => change(initial(e.target.value)) }, ['object', 'array', 'string', 'number', 'boolean', 'null'].map(t => React.createElement("option", { key: t }, t))),
+        field);
+}
+function liveIssues(draft, bindings) {
+    const issues = [];
+    const sources = draft.sources;
+    for (const binding of bindings) {
+        const entry = sources[binding.argument];
+        try {
+            if (entry.invalidForm === true)
+                throw new TypeError();
+            const doc = record(entry.creating)
+                ? { ...entry.creating, data: entry.data }
+                : readSourceDocument(binding, entry.source);
+            const validator = binding.validators.get(JSON.stringify([doc.format, doc.variantId]));
+            if (validator && validator.validate((entry.mode === 'form' ? entry.data : doc.data)).kind !== 'valid') {
+                issues.push({ message: 'Value does not satisfy the schema.', path: `/${binding.argument}` });
+            }
+        }
+        catch (_a) {
+            issues.push({ message: 'Repair the invalid source or form value.', path: `/${binding.argument}` });
+        }
+    }
+    return issues;
+}
+function SourceView({ context, bindings }) {
+    const [, redraw] = React.useState(0);
+    const [creating, selectCreateVariant] = React.useState({});
+    React.useEffect(() => {
+        const stop = context.subscribe(() => redraw(n => n + 1));
+        context.setValidationIssues(liveIssues(context.getDraft(), bindings));
+        return stop;
+    }, [context, bindings]);
+    const state = context.getState();
+    if (state.status !== 'editing' && state.status !== 'saving')
+        return React.createElement(React.Fragment, null);
+    const draft = context.getDraft();
+    const sources = draft.sources;
+    const disabled = context.getState().status !== 'editing';
+    const update = (argument, entry) => {
+        const next = context.getDraft();
+        const nextSources = next.sources;
+        Object.defineProperty(nextSources, argument, { value: entry, enumerable: true, configurable: true, writable: true });
+        context.setDraft(next);
+        context.setValidationIssues(liveIssues(next, bindings));
+    };
+    return React.createElement("div", { className: "block-editor-source-forms" }, bindings.map(binding => {
+        var _a, _b;
+        const entry = sources[binding.argument];
+        const selectedCreation = Object.hasOwn(creating, binding.argument) ? creating[binding.argument] : '';
+        let document;
+        let variant;
+        try {
+            document = readSourceDocument(binding, entry.source);
+            variant = binding.presentationVariants.find(v => v.format === document.format && v.variantId === document.variantId);
+        }
+        catch ( /* The Source textarea remains available for repair. */_c) { /* The Source textarea remains available for repair. */ }
+        if (record(entry.creating)) {
+            const creation = entry.creating;
+            variant = binding.presentationVariants.find(v => v.format === creation.format && v.variantId === creation.variantId);
+        }
+        return React.createElement("fieldset", { key: binding.argument, disabled: disabled },
+            React.createElement("legend", null, (_a = binding.label) !== null && _a !== void 0 ? _a : binding.argument),
+            React.createElement("button", { type: "button", "aria-pressed": entry.mode === 'source', onClick: () => {
+                    try {
+                        if (entry.invalidForm === true)
+                            throw new TypeError();
+                        const source = record(entry.creating)
+                            ? createSourceCandidate(entry.creating.format, entry.data)
+                            : entry.mode === 'form' && document && Object.hasOwn(entry, 'data')
+                                ? patchDecodedSource(document, entry.data, source => readSourceDocument(binding, source)) : entry.source;
+                        const next = { ...entry, mode: 'source', source, invalidForm: false, invalidNumbers: {} };
+                        delete next.creating;
+                        update(binding.argument, next);
+                    }
+                    catch (_a) {
+                        context.setValidationIssues([{ message: 'This edit cannot preserve the source. Repair the Source explicitly.' }]);
+                    }
+                } }, "Source"),
+            React.createElement("select", { "aria-label": `${binding.argument} New format and variant`, value: selectedCreation, onChange: e => selectCreateVariant({ ...creating, [binding.argument]: e.target.value }) },
+                React.createElement("option", { value: "" }, "Choose new format and variant"),
+                binding.presentationVariants.map(v => React.createElement("option", { key: JSON.stringify([v.format, v.variantId]), value: JSON.stringify([v.format, v.variantId]) },
+                    v.format,
+                    " / ",
+                    v.variantId))),
+            React.createElement("button", { type: "button", disabled: !selectedCreation, onClick: () => {
+                    const [format, variantId] = JSON.parse(selectedCreation);
+                    const chosen = binding.presentationVariants.find(v => v.format === format && v.variantId === variantId);
+                    const root = chosen.schemaBundle.root.document;
+                    const type = record(root) && typeof root.type === 'string' ? root.type : 'null';
+                    update(binding.argument, { mode: 'form', source: entry.source, sourceEdited: true, creating: { format, variantId }, data: initial(type) });
+                } }, "Create document (replace source)"),
+            React.createElement("button", { type: "button", disabled: !variant, "aria-pressed": entry.mode === 'form', onClick: () => {
+                    if (document || entry.creating)
+                        update(binding.argument, { ...entry, mode: 'form', data: Object.hasOwn(entry, 'data') ? entry.data : document.data });
+                } }, "Form"),
+            entry.mode === 'form' && React.createElement("button", { type: "button", onClick: () => { var _a; return update(binding.argument, { mode: 'source', source: entry.source, sourceEdited: (_a = entry.sourceEdited) !== null && _a !== void 0 ? _a : false }); } }, "Discard form edits"),
+            entry.mode === 'form' && variant && Object.hasOwn(entry, 'data')
+                ? React.createElement(Tree, { invalidNumbers: ((_b = entry.invalidNumbers) !== null && _b !== void 0 ? _b : {}), value: entry.data, path: "", schema: variant.schemaBundle.root.document, ui: variant.uiSchema, variant: variant, change: (data, edit = { path: '' }) => {
+                        var _a;
+                        const pending = ((_a = entry.invalidNumbers) !== null && _a !== void 0 ? _a : {});
+                        const invalidNumbers = {};
+                        const prefix = `${edit.path}/`;
+                        for (const [path, text] of Object.entries(pending)) {
+                            let target = path;
+                            if (edit.removeIndex !== undefined || edit.swap) {
+                                if (path.startsWith(prefix)) {
+                                    const [head, ...tail] = path.slice(prefix.length).split('/');
+                                    let index = Number(head);
+                                    if (index === edit.removeIndex)
+                                        continue;
+                                    if (edit.removeIndex !== undefined && index > edit.removeIndex)
+                                        index--;
+                                    if (edit.swap)
+                                        index = index === edit.swap[0] ? edit.swap[1] : index === edit.swap[1] ? edit.swap[0] : index;
+                                    target = `${prefix}${index}${tail.length ? '/' + tail.join('/') : ''}`;
+                                }
+                            }
+                            else if (path === edit.path || path.startsWith(prefix))
+                                continue;
+                            Object.defineProperty(invalidNumbers, target, { value: text, enumerable: true });
+                        }
+                        if (edit.invalidText !== undefined)
+                            Object.defineProperty(invalidNumbers, edit.path, { value: edit.invalidText, enumerable: true });
+                        update(binding.argument, { ...entry, data, invalidNumbers, invalidForm: Object.keys(invalidNumbers).length > 0 });
+                    } })
+                : React.createElement("textarea", { "aria-label": `${binding.argument} Source`, value: entry.source, onChange: e => update(binding.argument, { mode: 'source', source: e.target.value, sourceEdited: true }) }),
+            entry.invalidForm === true && React.createElement("p", { role: "alert" }, "Enter a valid JSON number."));
+    }));
+}
+export function mountSourceView(container, context, bindings) {
+    ReactDOM.render(React.createElement(SourceView, { context: context, bindings: bindings }), container);
+    return () => { ReactDOM.unmountComponentAtNode(container); };
+}

package/dist/turbowarp/bridge.d.ts

@@ -1,5 +1,5 @@
 export default createBlockEditorBridge;
-declare function createBlockEditorBridge({ ScratchBlocks, workspace, vm, service, label, canOpen, onOpen, onError, descendants }: {
+declare function createBlockEditorBridge({ ScratchBlocks, workspace, vm, service, label, canOpen, onOpen, onError, descendants, fixedInputs }: {
     ScratchBlocks: any;
     workspace: any;
     vm: any;
@@ -9,6 +9,7 @@ declare function createBlockEditorBridge({ ScratchBlocks, workspace, vm, service
     onOpen: any;
     onError: any;
     descendants?: boolean | undefined;
+    fixedInputs?: boolean | undefined;
 }): {
     refresh: () => void;
     dispose: () => void;

package/dist/turbowarp/bridge.js

@@ -1,22 +1,32 @@
 import createBlockEditorHost from './host.js';
 import bindBlockEditorIcon from './icon.js';
 import readBlockEditorAppearance from './appearance.js';
-import { supportsDescendantEditing } from '../index.js';
+import { supportsDescendantEditing, supportsFixedInputEditing } from '../index.js';
 import createBlockEditorErrorSession from './error-session.js';
-const openBlockEditorSession = ({ registry, reference, host, descendants }) => (descendants && supportsDescendantEditing(host) ?
-    registry.openDescendants(reference, host) : registry.open(reference, host));
-const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, canOpen, onOpen, onError, descendants = false }) => {
+const fixedDeclaration = (registry, snapshot) => snapshot && typeof registry.resolveFixed === 'function' &&
+    registry.resolveFixed(snapshot.opcode);
+const openBlockEditorSession = ({ registry, reference, host, descendants }) => {
+    const snapshot = host.readBlock ? host.readBlock(reference) : null;
+    // A fixed registration owns only this block; legacy aggregate traversal stays fail-closed.
+    if (fixedDeclaration(registry, snapshot))
+        return supportsFixedInputEditing(host) ? registry.open(reference, host) : undefined;
+    return descendants && supportsDescendantEditing(host) ?
+        registry.openDescendants(reference, host) : registry.open(reference, host);
+};
+const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label, canOpen, onOpen, onError, descendants = false, fixedInputs = false }) => {
     const host = createBlockEditorHost({ ScratchBlocks,
         workspace,
         vm,
         registry: service.registry,
         enableDescendants: descendants,
+        enableFixedInputs: fixedInputs,
         onError });
     const decorations = new Map();
     let disposed = false;
     let timer = null;
     let activeSession = null;
     let openingSnapshot = null;
+    let openingFixedDeclaration = null;
     let stopWaiting = null;
     const endSession = () => {
         const session = activeSession;
@@ -41,6 +51,7 @@ const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label,
         }
     };
     const checkSession = () => {
+        var _a;
         // The host owns rollback. Its synchronous transaction must retain the draft on failure.
         if (host.isCommitting())
             return;
@@ -49,6 +60,14 @@ const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label,
             return;
         const current = typeof activeSession.getNodes === 'function' ?
             host.descendants.readSubtree(activeSession.reference) : host.readBlock(activeSession.reference);
+        if (openingFixedDeclaration) {
+            // Same-target external edits conflict at save while the session retains its draft.
+            // Project/target/registration replacement ends the session and drops that draft.
+            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();
     };
@@ -56,6 +75,8 @@ const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label,
         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 => {
@@ -71,6 +92,7 @@ const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label,
                 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 = Object.create(null);
                 if (typeof session.getNodes === 'function') {
@@ -88,6 +110,7 @@ const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label,
             onError(error);
             activeSession = createBlockEditorErrorSession(reference, error);
             openingSnapshot = null;
+            openingFixedDeclaration = null;
             onOpen(activeSession);
         }
     };
@@ -137,7 +160,13 @@ const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label,
     };
     const unregister = service.subscribe(() => {
         // Aggregate sessions observe relevant registry changes themselves.
-        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();
         }

package/dist/turbowarp/fixed-fields.d.ts

@@ -0,0 +1,82 @@
+/** Freeze native method identities once when the host attaches, before opening editors. */
+export function initializeFixedFields(ScratchBlocks: any): void;
+/** Native objects stay local; only primitive metadata is returned in snapshots. */
+export function inspectFixedArgument({ ScratchBlocks, block, vmBlock, target, argument, role, identify, extensionId }: {
+    ScratchBlocks: any;
+    block: any;
+    vmBlock: any;
+    target: any;
+    argument: any;
+    role: any;
+    identify: any;
+    extensionId: any;
+}): {
+    slot: {
+        kind: string;
+        value: string | number | boolean;
+    } | {
+        kind: string;
+        value?: never;
+    };
+    metadata: {
+        role: any;
+        source: any;
+        identity: string;
+        reason: any;
+    };
+    signatureParts: any[];
+} | {
+    slot: {
+        kind: string;
+        value?: never;
+    };
+    metadata: {
+        role: any;
+        source: string;
+        identity: string;
+        field?: never;
+    };
+    signatureParts: any[];
+} | {
+    signatureParts: any[];
+    binding?: {
+        restoreState?: {
+            colors: any[];
+            hsv: any[][];
+            blockProperties: any;
+        };
+        block: any;
+        field: any;
+        fieldName: any;
+        value: string;
+        vmBlock: any;
+        kind: string;
+        Class: any;
+        prototype: any;
+        allowedValues: readonly string[] | null | undefined;
+        restoreValue: any;
+        rawState: any;
+        restoreHandles: any;
+        restoreDom: any;
+    };
+    slot: {
+        kind: string;
+        value: string;
+    };
+    metadata: {
+        role: any;
+        source: string;
+        identity: string;
+        field: {
+            blockId: any;
+            name: any;
+            type: string | undefined;
+        };
+    };
+} | null;
+/** Validate the exact saved primitive; native setters must not silently normalize it. */
+export function prepareFixedChange(binding: any, value: any): any;
+/** Capture a later external value without invoking replacement field methods. */
+export function captureFixedFieldState(binding: any): any;
+/** Restore raw text and the standard color field's additional block/UI state. */
+export function restoreFixedField(binding: any): void;