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

package/dist/schema.d.ts

@@ -6,3 +6,5 @@ export { validateSchemaInput } from './schema-compose.js';
 export declare function toValidationIssues(diagnostics: readonly InputDiagnostic[]): readonly ValidationIssue[];
 export type * from './source-types.js';
 export { jsonValueSchema, jsonValueSchemaBundle } from './json-value.js';
+export { parseFixedNumberInput } from './fixed-input-schema.js';
+export type { FixedNumberInputResult } from './fixed-input-schema.js';

package/dist/schema.js

@@ -84,3 +84,4 @@ export function toValidationIssues(diagnostics) {
     }
 }
 export { jsonValueSchema, jsonValueSchemaBundle } from './json-value.js';
+export { parseFixedNumberInput } from './fixed-input-schema.js';

package/dist/session.d.ts

@@ -1,11 +1,13 @@
+import type { FixedInputViewDescription } from './fixed-input-types.js';
 import type { BlockEditorHost, BlockReference, BlockSnapshot, EditorDefinition, EditorViewContext, JsonObject, SaveResult, SessionState, ValidationIssue } from './types.js';
 export declare class EditorSession implements EditorViewContext {
     #private;
     /** Use EditorRegistry.open() to construct sessions from a captured host snapshot. */
-    constructor(definition: EditorDefinition, snapshot: BlockSnapshot, host: BlockEditorHost, isRegistered?: () => boolean);
+    constructor(definition: EditorDefinition, snapshot: BlockSnapshot, host: BlockEditorHost, isRegistered?: () => boolean, subscribeRegistrationChanges?: (listener: () => void) => () => void);
     /** Stable instance identity remains available after the session closes. */
     get reference(): BlockReference;
     getDraft(): JsonObject;
+    getFixedInputView(): FixedInputViewDescription | undefined;
     setDraft(draft: JsonObject): void;
     setValidationIssues(issues: readonly ValidationIssue[]): void;
     getState(): SessionState;

package/dist/session.js

@@ -9,14 +9,19 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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, _EditorSession_draft, _EditorSession_status, _EditorSession_issues, _EditorSession_error, _EditorSession_listeners, _EditorSession_view, _EditorSession_definition, _EditorSession_snapshot, _EditorSession_host, _EditorSession_isRegistered, _EditorSession_prepareChanges, _EditorSession_copyIssues, _EditorSession_copyDraft, _EditorSession_assertOpen, _EditorSession_finish, _EditorSession_notify, _EditorSession_reportObserverError;
+var _EditorSession_instances, _EditorSession_draft, _EditorSession_status, _EditorSession_issues, _EditorSession_error, _EditorSession_listeners, _EditorSession_view, _EditorSession_definition, _EditorSession_snapshot, _EditorSession_host, _EditorSession_fixedPort, _EditorSession_isRegistered, _EditorSession_subscribeRegistrationChanges, _EditorSession_unsubscribeFixedScope, _EditorSession_unsubscribeFixedRegistration, _EditorSession_fixedSavingController, _EditorSession_saveFixed, _EditorSession_prepareChanges, _EditorSession_copyIssues, _EditorSession_copyDraft, _EditorSession_assertOpen, _EditorSession_finish, _EditorSession_notify, _EditorSession_reportObserverError;
 import { captureReference, captureSnapshot, cloneJson, isLiteral, sameSnapshot } from './data.js';
 import { BlockEditorConflictError } from './types.js';
 import { EditorView } from './view.js';
 import { isPreparedEditor, capturePreparedSave } from './prepared-save.js';
+import { isFixedInputEditor, captureFixedPreparedSave } from './fixed-input-editor.js';
+import { captureFixedSnapshot, sameFixedSnapshot } from './fixed-input-snapshot.js';
+import { supportsFixedInputEditing } from './fixed-input-types.js';
+import { snapshotJson, isJsonRecord } from './schema-json.js';
+import { validateFixedBranchChanges } from './fixed-input-branches.js';
 export class EditorSession {
     /** Use EditorRegistry.open() to construct sessions from a captured host snapshot. */
-    constructor(definition, snapshot, host, isRegistered) {
+    constructor(definition, snapshot, host, isRegistered, subscribeRegistrationChanges) {
         _EditorSession_instances.add(this);
         _EditorSession_draft.set(this, void 0);
         _EditorSession_status.set(this, 'editing');
@@ -27,12 +32,68 @@ export class EditorSession {
         _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);
         __classPrivateFieldSet(this, _EditorSession_isRegistered, isRegistered, "f");
+        __classPrivateFieldSet(this, _EditorSession_subscribeRegistrationChanges, subscribeRegistrationChanges, "f");
         __classPrivateFieldSet(this, _EditorSession_definition, definition, "f");
-        __classPrivateFieldSet(this, _EditorSession_snapshot, captureSnapshot(snapshot, captureReference(snapshot)), "f");
+        __classPrivateFieldSet(this, _EditorSession_snapshot, isFixedInputEditor(definition)
+            ? captureFixedSnapshot(snapshot, captureReference(snapshot), definition)
+            : captureSnapshot(snapshot, captureReference(snapshot)), "f");
         __classPrivateFieldSet(this, _EditorSession_host, host, "f");
-        __classPrivateFieldSet(this, _EditorSession_draft, __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, definition.read(__classPrivateFieldGet(this, _EditorSession_snapshot, "f"))), "f");
+        __classPrivateFieldSet(this, _EditorSession_fixedPort, isFixedInputEditor(definition) && supportsFixedInputEditing(host) ? host.fixedInputs : undefined, "f");
+        if (isFixedInputEditor(definition) && !supportsFixedInputEditing(host))
+            throw new TypeError('Fixed input editors require a compatible host.');
+        __classPrivateFieldSet(this, _EditorSession_draft, __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, isFixedInputEditor(definition)
+            ? definition.readFixed(__classPrivateFieldGet(this, _EditorSession_snapshot, "f")) : definition.read(__classPrivateFieldGet(this, _EditorSession_snapshot, "f"))), "f");
+        if (isFixedInputEditor(definition) && __classPrivateFieldGet(this, _EditorSession_subscribeRegistrationChanges, "f")) {
+            const unsubscribe = __classPrivateFieldGet(this, _EditorSession_subscribeRegistrationChanges, "f").call(this, () => {
+                var _a;
+                if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this) && (__classPrivateFieldGet(this, _EditorSession_status, "f") === 'editing' || __classPrivateFieldGet(this, _EditorSession_status, "f") === 'saving')) {
+                    (_a = __classPrivateFieldGet(this, _EditorSession_fixedSavingController, "f")) === null || _a === void 0 ? void 0 : _a.abort(new BlockEditorConflictError());
+                    __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, 'disposed');
+                }
+            });
+            if (__classPrivateFieldGet(this, _EditorSession_status, "f") === 'editing')
+                __classPrivateFieldSet(this, _EditorSession_unsubscribeFixedRegistration, unsubscribe, "f");
+            else
+                unsubscribe();
+        }
+        try {
+            if (isFixedInputEditor(definition) && __classPrivateFieldGet(this, _EditorSession_fixedPort, "f")) {
+                let subscribe;
+                for (let item = __classPrivateFieldGet(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 : undefined;
+                        break;
+                    }
+                }
+                if (typeof subscribe === 'function') {
+                    const unsubscribe = subscribe.call(__classPrivateFieldGet(this, _EditorSession_fixedPort, "f"), this.reference, definition, () => {
+                        var _a;
+                        if (__classPrivateFieldGet(this, _EditorSession_status, "f") !== 'editing' && __classPrivateFieldGet(this, _EditorSession_status, "f") !== 'saving')
+                            return;
+                        (_a = __classPrivateFieldGet(this, _EditorSession_fixedSavingController, "f")) === null || _a === void 0 ? void 0 : _a.abort(new BlockEditorConflictError());
+                        __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, 'disposed');
+                    });
+                    if (typeof unsubscribe !== 'function')
+                        throw new TypeError('Invalid fixed scope subscription.');
+                    if (__classPrivateFieldGet(this, _EditorSession_status, "f") === 'editing')
+                        __classPrivateFieldSet(this, _EditorSession_unsubscribeFixedScope, unsubscribe, "f");
+                    else
+                        unsubscribe();
+                }
+            }
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, 'disposed');
+            throw error;
+        }
     }
     /** Stable instance identity remains available after the session closes. */
     get reference() {
@@ -42,6 +103,36 @@ export class EditorSession {
         __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_assertOpen).call(this);
         return cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f"));
     }
+    getFixedInputView() {
+        __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_assertOpen).call(this);
+        const definition = __classPrivateFieldGet(this, _EditorSession_definition, "f");
+        if (!isFixedInputEditor(definition) || !definition.describeFixed)
+            return undefined;
+        let description;
+        try {
+            description = definition.describeFixed(__classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, __classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(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 freeze = (value) => {
+                if (value && typeof value === 'object') {
+                    Object.values(value).forEach(freeze);
+                    Object.freeze(value);
+                }
+            };
+            freeze(captured);
+            return captured;
+        }
+        catch (_a) {
+            try {
+                void Promise.prototype.then.call(description, () => undefined, () => undefined);
+            }
+            catch ( /* Never inspect arbitrary thenables. */_b) { /* Never inspect arbitrary thenables. */ }
+            throw new TypeError('Invalid fixed input presentation.');
+        }
+    }
     setDraft(draft) {
         if (__classPrivateFieldGet(this, _EditorSession_status, "f") !== 'editing')
             throw new Error('The session is not editable.');
@@ -82,6 +173,8 @@ export class EditorSession {
         try {
             if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this))
                 throw new BlockEditorConflictError('The source editor registration expired.');
+            if (isFixedInputEditor(__classPrivateFieldGet(this, _EditorSession_definition, "f")))
+                return await __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_saveFixed).call(this);
             const prepared = isPreparedEditor(__classPrivateFieldGet(this, _EditorSession_definition, "f"))
                 ? capturePreparedSave(__classPrivateFieldGet(this, _EditorSession_definition, "f"), cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f")) : undefined;
             const issues = prepared ? (prepared.kind === 'invalid' ? prepared.issues : [])
@@ -135,7 +228,73 @@ export class EditorSession {
         return true;
     }
 }
-_EditorSession_draft = new WeakMap(), _EditorSession_status = new WeakMap(), _EditorSession_issues = new WeakMap(), _EditorSession_error = new WeakMap(), _EditorSession_listeners = new WeakMap(), _EditorSession_view = new WeakMap(), _EditorSession_definition = new WeakMap(), _EditorSession_snapshot = new WeakMap(), _EditorSession_host = new WeakMap(), _EditorSession_isRegistered = new WeakMap(), _EditorSession_instances = new WeakSet(), _EditorSession_prepareChanges = function _EditorSession_prepareChanges(patch) {
+_EditorSession_draft = new WeakMap(), _EditorSession_status = new WeakMap(), _EditorSession_issues = new WeakMap(), _EditorSession_error = new WeakMap(), _EditorSession_listeners = new WeakMap(), _EditorSession_view = new WeakMap(), _EditorSession_definition = new WeakMap(), _EditorSession_snapshot = new WeakMap(), _EditorSession_host = new WeakMap(), _EditorSession_fixedPort = new WeakMap(), _EditorSession_isRegistered = new WeakMap(), _EditorSession_subscribeRegistrationChanges = new WeakMap(), _EditorSession_unsubscribeFixedScope = new WeakMap(), _EditorSession_unsubscribeFixedRegistration = new WeakMap(), _EditorSession_fixedSavingController = new WeakMap(), _EditorSession_instances = new WeakSet(), _EditorSession_saveFixed = async function _EditorSession_saveFixed() {
+    var _a;
+    const definition = __classPrivateFieldGet(this, _EditorSession_definition, "f");
+    if (!isFixedInputEditor(definition))
+        throw new TypeError('Fixed input capability is unavailable.');
+    if (!supportsFixedInputEditing(__classPrivateFieldGet(this, _EditorSession_host, "f")) || __classPrivateFieldGet(this, _EditorSession_host, "f").fixedInputs !== __classPrivateFieldGet(this, _EditorSession_fixedPort, "f")) {
+        __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, 'disposed');
+        throw new BlockEditorConflictError('The fixed input capability changed.');
+    }
+    const snapshot = __classPrivateFieldGet(this, _EditorSession_snapshot, "f");
+    const prepared = captureFixedPreparedSave(definition, __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_copyDraft).call(this, __classPrivateFieldGet(this, _EditorSession_draft, "f")), snapshot);
+    if (__classPrivateFieldGet(this, _EditorSession_status, "f") !== 'saving')
+        throw new BlockEditorConflictError();
+    if (prepared.kind === 'invalid') {
+        __classPrivateFieldSet(this, _EditorSession_issues, __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_copyIssues).call(this, prepared.issues), "f");
+        return { status: 'invalid', issues: __classPrivateFieldGet(this, _EditorSession_issues, "f") };
+    }
+    const changes = __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_prepareChanges).call(this, prepared.changes);
+    const port = __classPrivateFieldGet(this, _EditorSession_host, "f").fixedInputs;
+    if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(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) {
+            __classPrivateFieldGet(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(__classPrivateFieldGet(this, _EditorSession_host, "f")) || __classPrivateFieldGet(this, _EditorSession_host, "f").fixedInputs !== port ||
+        (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this)))
+        throw new BlockEditorConflictError('The fixed editor registration expired.');
+    if (changes.length > 0) {
+        const controller = new AbortController();
+        __classPrivateFieldSet(this, _EditorSession_fixedSavingController, controller, "f");
+        const context = prepared.context;
+        const unsubscribe = (_a = __classPrivateFieldGet(this, _EditorSession_subscribeRegistrationChanges, "f")) === null || _a === void 0 ? void 0 : _a.call(this, () => {
+            if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this))
+                controller.abort(new BlockEditorConflictError('The fixed editor registration expired.'));
+        });
+        try {
+            if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(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();
+            __classPrivateFieldSet(this, _EditorSession_fixedSavingController, undefined, "f");
+        }
+    }
+    __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_finish).call(this, 'saved');
+    return { status: 'saved', changed: changes.length > 0 };
+}, _EditorSession_prepareChanges = function _EditorSession_prepareChanges(patch) {
     if (!Array.isArray(patch))
         throw new TypeError('createPatch() must return an array.');
     const seen = new Set();
@@ -151,11 +310,23 @@ _EditorSession_draft = new WeakMap(), _EditorSession_status = new WeakMap(), _Ed
         if (!slot || slot.kind !== 'literal') {
             throw new TypeError('Only existing literal arguments can be changed.');
         }
-        if (slot.value !== change.value)
+        if (isFixedInputEditor(__classPrivateFieldGet(this, _EditorSession_definition, "f"))) {
+            const metadata = __classPrivateFieldGet(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(__classPrivateFieldGet(this, _EditorSession_definition, "f")) && validateFixedBranchChanges(__classPrivateFieldGet(this, _EditorSession_definition, "f"), __classPrivateFieldGet(this, _EditorSession_snapshot, "f"), changes).length)
+        throw new TypeError('Fixed dependency validation is unavailable.');
     return Object.freeze(changes);
 }, _EditorSession_copyIssues = function _EditorSession_copyIssues(issues) {
+    if (isFixedInputEditor(__classPrivateFieldGet(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 => {
@@ -169,7 +340,18 @@ _EditorSession_draft = new WeakMap(), _EditorSession_status = new WeakMap(), _Ed
     if (!draft || typeof draft !== 'object' || Array.isArray(draft)) {
         throw new TypeError('The editor draft must be a JSON object.');
     }
-    return cloneJson(draft);
+    if (!isFixedInputEditor(__classPrivateFieldGet(this, _EditorSession_definition, "f")))
+        return cloneJson(draft);
+    try {
+        return snapshotJson(draft);
+    }
+    catch (error) {
+        try {
+            void Promise.prototype.then.call(draft, () => undefined, () => undefined);
+        }
+        catch ( /* Synchronous fixed drafts never inspect arbitrary thenables. */_a) { /* Synchronous fixed drafts never inspect arbitrary thenables. */ }
+        throw error;
+    }
 }, _EditorSession_assertOpen = function _EditorSession_assertOpen() {
     if (__classPrivateFieldGet(this, _EditorSession_status, "f") !== 'editing' && __classPrivateFieldGet(this, _EditorSession_status, "f") !== 'saving') {
         throw new Error('The session is closed.');
@@ -177,6 +359,22 @@ _EditorSession_draft = new WeakMap(), _EditorSession_status = new WeakMap(), _Ed
 }, _EditorSession_finish = function _EditorSession_finish(status) {
     __classPrivateFieldSet(this, _EditorSession_status, status, "f");
     __classPrivateFieldSet(this, _EditorSession_draft, {}, "f");
+    const unsubscribe = __classPrivateFieldGet(this, _EditorSession_unsubscribeFixedScope, "f");
+    __classPrivateFieldSet(this, _EditorSession_unsubscribeFixedScope, undefined, "f");
+    try {
+        unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_reportObserverError).call(this, error);
+    }
+    const unsubscribeRegistration = __classPrivateFieldGet(this, _EditorSession_unsubscribeFixedRegistration, "f");
+    __classPrivateFieldSet(this, _EditorSession_unsubscribeFixedRegistration, undefined, "f");
+    try {
+        unsubscribeRegistration === null || unsubscribeRegistration === void 0 ? void 0 : unsubscribeRegistration();
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_reportObserverError).call(this, error);
+    }
     __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
     try {
         __classPrivateFieldGet(this, _EditorSession_view, "f").unmount();

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,8 +92,12 @@ 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);
+                const rootAppearance = readBlockEditorAppearance(block, ScratchBlocks);
+                appearances[reference.blockId] = rootAppearance;
+                labels[reference.blockId] = rootAppearance.name || block.type;
                 if (typeof session.getNodes === 'function') {
                     for (const node of session.getNodes()) {
                         const source = workspace.getBlockById(node.reference.blockId);
@@ -88,6 +113,7 @@ const createBlockEditorBridge = ({ ScratchBlocks, workspace, vm, service, label,
             onError(error);
             activeSession = createBlockEditorErrorSession(reference, error);
             openingSnapshot = null;
+            openingFixedDeclaration = null;
             onOpen(activeSession);
         }
     };
@@ -137,7 +163,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;