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

package/dist/registry.js

@@ -3,7 +3,7 @@ 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 _EditorRegistry_instances, _EditorRegistry_editors, _EditorRegistry_opcodes, _EditorRegistry_changes, _EditorRegistry_register, _EditorRegistry_notifyChanges;
+var _EditorRegistry_instances, _EditorRegistry_editors, _EditorRegistry_opcodes, _EditorRegistry_fixedDeclarations, _EditorRegistry_changes, _EditorRegistry_register, _EditorRegistry_notifyChanges;
 import { captureReference, captureSnapshot } from './data.js';
 import { EditorSession } from './session.js';
 import { DescendantSession } from './descendants.js';
@@ -11,14 +11,20 @@ import { supportsDescendantEditing } from './descendant-types.js';
 import { captureSubtree, descendantLimits } from './subtree.js';
 import { EDITOR_API_VERSION } from './types.js';
 import { isPreparedEditor } from './prepared-save.js';
+import { isFixedInputEditor, captureFixedInputEditorDefinition } from './fixed-input-editor.js';
+import { captureFixedInputDeclaration, captureFixedSnapshot } from './fixed-input-snapshot.js';
+import { supportsFixedInputEditing } from './fixed-input-types.js';
 export class EditorRegistry {
     constructor() {
         _EditorRegistry_instances.add(this);
         _EditorRegistry_editors.set(this, new Map());
         _EditorRegistry_opcodes.set(this, new Map());
+        _EditorRegistry_fixedDeclarations.set(this, new Map());
         _EditorRegistry_changes.set(this, new Set());
     }
     register(definition) {
+        if (isFixedInputEditor(definition))
+            throw new TypeError('Fixed input editors require registerFixed().');
         if (isPreparedEditor(definition))
             throw new TypeError('Prepared editors require registerPrepared().');
         return __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, definition);
@@ -29,6 +35,9 @@ export class EditorRegistry {
         }
         return __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, definition);
     }
+    registerFixed(definition) {
+        return __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, captureFixedInputEditorDefinition(definition));
+    }
     resolve(opcode) {
         const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode);
         if (!entry)
@@ -38,15 +47,37 @@ export class EditorRegistry {
             opcodes: entry.opcodes, editableArguments: entry.editableArguments
         });
     }
+    /** Stable, callback-free authority for this exact registration, never caller metadata. */
+    resolveFixed(opcode) {
+        const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode);
+        return entry ? __classPrivateFieldGet(this, _EditorRegistry_fixedDeclarations, "f").get(entry) : undefined;
+    }
     open(reference, host) {
         const capturedReference = captureReference(reference);
         const live = host.readBlock(capturedReference);
         if (!live)
             return undefined;
+        const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(live.opcode);
+        if (!entry) {
+            // Preserve legacy snapshot validation even when no editor is registered.
+            captureSnapshot(live, capturedReference);
+            return undefined;
+        }
+        if (isFixedInputEditor(entry)) {
+            if (!supportsFixedInputEditing(host))
+                return undefined;
+            const fixed = host.fixedInputs.readBlock(capturedReference, entry);
+            if (!fixed || fixed.opcode !== live.opcode)
+                return undefined;
+            const snapshot = captureFixedSnapshot(fixed, capturedReference, entry);
+            return new EditorSession(entry, snapshot, host, () => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry, listener => {
+                __classPrivateFieldGet(this, _EditorRegistry_changes, "f").add(listener);
+                return () => { __classPrivateFieldGet(this, _EditorRegistry_changes, "f").delete(listener); };
+            });
+        }
         const snapshot = captureSnapshot(live, capturedReference);
-        const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode);
-        return entry ? new EditorSession(entry, snapshot, host, isPreparedEditor(entry)
-            ? () => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry : undefined) : undefined;
+        return new EditorSession(entry, snapshot, host, isPreparedEditor(entry)
+            ? () => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry : undefined);
     }
     openDescendants(reference, host, limits) {
         if (!supportsDescendantEditing(host))
@@ -58,15 +89,19 @@ export class EditorRegistry {
         if (!live)
             return undefined;
         const captured = captureSubtree(live, capturedReference, resolvedLimits);
-        if (!__classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").has(captured.snapshot.nodes[0].block.opcode))
+        const root = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(captured.snapshot.nodes[0].block.opcode);
+        if (!root || isFixedInputEditor(root))
             return undefined;
-        return new DescendantSession(captured, port, opcode => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode), listener => {
+        return new DescendantSession(captured, port, opcode => {
+            const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode);
+            return entry && !isFixedInputEditor(entry) ? entry : undefined;
+        }, listener => {
             __classPrivateFieldGet(this, _EditorRegistry_changes, "f").add(listener);
             return () => { __classPrivateFieldGet(this, _EditorRegistry_changes, "f").delete(listener); };
         }, resolvedLimits);
     }
 }
-_EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap(), _EditorRegistry_changes = new WeakMap(), _EditorRegistry_instances = new WeakSet(), _EditorRegistry_register = function _EditorRegistry_register(definition) {
+_EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap(), _EditorRegistry_fixedDeclarations = new WeakMap(), _EditorRegistry_changes = new WeakMap(), _EditorRegistry_instances = new WeakSet(), _EditorRegistry_register = function _EditorRegistry_register(definition) {
     if (definition.apiVersion !== EDITOR_API_VERSION)
         throw new TypeError('Unsupported editor API version.');
     if (!/^[a-z0-9]+$/i.test(definition.extensionId) ||
@@ -98,6 +133,8 @@ _EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap()
         opcodes: Object.freeze([...definition.opcodes]),
         editableArguments: Object.freeze([...definition.editableArguments])
     });
+    if (isFixedInputEditor(entry))
+        __classPrivateFieldGet(this, _EditorRegistry_fixedDeclarations, "f").set(entry, captureFixedInputDeclaration(entry));
     __classPrivateFieldGet(this, _EditorRegistry_editors, "f").set(key, entry);
     for (const opcode of entry.opcodes)
         __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").set(opcode, entry);
@@ -108,6 +145,7 @@ _EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap()
         __classPrivateFieldGet(this, _EditorRegistry_editors, "f").delete(key);
         for (const opcode of entry.opcodes)
             __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").delete(opcode);
+        __classPrivateFieldGet(this, _EditorRegistry_fixedDeclarations, "f").delete(entry);
         __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_notifyChanges).call(this);
     };
 }, _EditorRegistry_notifyChanges = function _EditorRegistry_notifyChanges() {

package/dist/rjsf.d.ts

@@ -1,3 +1,9 @@
+import type { FixedInputMessageSource } from './fixed-input-view.js';
+export type { FixedInputViewMessages, FixedInputMessageSource } from './fixed-input-view.js';
+import type { FixedInputEditorOptions } from './fixed-input-editor.js';
+export { createFixedInputEditor } from './fixed-input-editor.js';
+export type { FixedInputEditorOptions, FixedInputBinding, FixedInputBranchPolicy } from './fixed-input-editor.js';
+export type * from './fixed-input-types.js';
 import type { SourceEditorOptions } from './source-types.js';
 export { createSourceEditor } from './source-editor.js';
 export type * from './source-types.js';
@@ -35,6 +41,7 @@ export interface BlockEditorRegistrationAPI {
     registerSchema(definition: SchemaEditorOptions): () => void;
     registerSchemaBundle?<C>(definition: SchemaBundleEditorOptions<C>): () => void;
     registerSourceEditor?<C = null>(definition: SourceEditorOptions<C>): () => void;
+    registerFixedInputEditor?<C = null>(definition: FixedInputEditorOptions<C>): () => void;
 }
 /** Capability guaranteed by the service factory, optional on a legacy host-supplied API. */
 export interface SchemaBundleBlockEditorRegistrationAPI extends BlockEditorRegistrationAPI {
@@ -44,14 +51,30 @@ export interface SchemaBundleBlockEditorRegistrationAPI extends BlockEditorRegis
 export interface SourceBlockEditorRegistrationAPI extends SchemaBundleBlockEditorRegistrationAPI {
     registerSourceEditor<C = null>(definition: SourceEditorOptions<C>): () => void;
 }
+export interface FixedBlockEditorRegistrationAPI extends SourceBlockEditorRegistrationAPI {
+    registerFixedInputEditor<C = null>(definition: FixedInputEditorOptions<C>): () => void;
+}
 export interface BlockEditorService {
     readonly registry: EditorRegistry;
     readonly api: BlockEditorRegistrationAPI;
     subscribe(listener: () => void): () => void;
 }
 /** A host owns the service's lifetime; this module never stores VM or workspace instances. */
-export declare function createBlockEditorService(): BlockEditorService & {
+export declare function createBlockEditorService(options: {
+    readonly fixedInputs: true;
+    readonly fixedInputMessages?: FixedInputMessageSource;
+}): BlockEditorService & {
+    readonly api: FixedBlockEditorRegistrationAPI;
+};
+export declare function createBlockEditorService(options?: {
+    readonly fixedInputs?: false;
+    readonly fixedInputMessages?: FixedInputMessageSource;
+}): BlockEditorService & {
     readonly api: SourceBlockEditorRegistrationAPI;
 };
+export declare function createBlockEditorService(options: {
+    readonly fixedInputs?: boolean;
+    readonly fixedInputMessages?: FixedInputMessageSource;
+}): BlockEditorService;
 /** Build an editor with JSON/YAML serialization, schema validation and the standard RJSF body. */
 export declare function createSchemaEditor(options: SchemaEditorOptions): EditorDefinition;

package/dist/rjsf.js

@@ -1,5 +1,8 @@
 import * as React from 'react';
 import { createSourceEditor } from './source-editor.js';
+import { createFixedInputEditor } from './fixed-input-editor.js';
+import { captureFixedInputMessages, resolveFixedInputMessages, mountFixedInputView } from './fixed-input-view.js';
+export { createFixedInputEditor } from './fixed-input-editor.js';
 export { createSourceEditor } from './source-editor.js';
 import * as ReactDOM from 'react-dom';
 import * as RjsfCore from '@rjsf/core';
@@ -65,13 +68,30 @@ export function createSchemaBundleEditor(options) {
         ...(format === undefined ? {} : { format }), ...(uiSchema === undefined ? {} : { uiSchema }),
         ...(validateData === undefined ? {} : { validateData }) }, { issuesFor, dialect: result.validator.dialect });
 }
-/** A host owns the service's lifetime; this module never stores VM or workspace instances. */
-export function createBlockEditorService() {
+export function createBlockEditorService(options) {
+    if ((options === null || options === void 0 ? void 0 : options.fixedInputs) !== undefined && typeof options.fixedInputs !== 'boolean')
+        throw new TypeError('Invalid fixed input capability option.');
+    const messageSource = options === null || options === void 0 ? void 0 : options.fixedInputMessages;
+    const fixedMessages = typeof messageSource === 'function' ? messageSource : captureFixedInputMessages(messageSource);
     const registry = new EditorRegistry();
     const listeners = new Set();
     const notify = () => { for (const listener of [...listeners])
         listener(); };
+    const fixed = (options === null || options === void 0 ? void 0 : options.fixedInputs) === true ? {
+        registerFixedInputEditor: (definition) => {
+            const fixedDefinition = createFixedInputEditor(definition);
+            const remove = registry.registerFixed({ ...fixedDefinition, mount: (container, context) => mountFixedInputView(container, context, resolveFixedInputMessages(fixedMessages)) });
+            notify();
+            let active = true;
+            return () => { if (active) {
+                active = false;
+                remove();
+                notify();
+            } };
+        }
+    } : {};
     const api = Object.freeze({
+        ...fixed,
         apiVersion: EDITOR_API_VERSION,
         register: (definition) => {
             const custom = definition;

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,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();
         }