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

package/dist/schema-view.js

@@ -0,0 +1,102 @@
+import { Ajv } from 'ajv';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import formats from 'ajv-formats';
+import uri from 'fast-uri';
+import { prepare } from './schema-engine.js';
+import { snapshotJson } from './schema-json.js';
+/** RJSF v5 only resolves fragment pointers; flatten a private, already checked resource graph. */
+export function schemaView(input) {
+    const bundle = snapshotJson(input);
+    const ajv = bundle.dialect === 'draft-07' ? new Ajv({ strict: false }) : new Ajv2020({ strict: false });
+    formats.default(ajv);
+    const prepared = prepare(bundle, ajv);
+    const pointerFor = (reference, base) => {
+        const absolute = uri.normalize(uri.resolve(base, reference)).replace(/#$/, '');
+        let location = prepared.registry.get(absolute);
+        if (location === undefined) {
+            const hash = absolute.indexOf('#');
+            const resource = prepared.registry.get(hash < 0 ? absolute : absolute.slice(0, hash));
+            const fragment = hash < 0 ? '' : decodeURIComponent(absolute.slice(hash + 1));
+            if (resource === undefined || (fragment !== '' && !fragment.startsWith('/')))
+                throw new TypeError('Unsupported form reference.');
+            location = resource + fragment;
+        }
+        const slash = location.indexOf('/');
+        const index = slash < 0 ? location : location.slice(0, slash);
+        return `#${encodeURIComponent(`/definitions/__resource${index}${slash < 0 ? '' : location.slice(slash)}`).replace(/%2F/g, '/')}`;
+    };
+    for (const { node, base } of prepared.nodes) {
+        // These constructs cannot be represented faithfully by this RJSF version.
+        if ('$dynamicRef' in node || '$recursiveRef' in node || 'prefixItems' in node)
+            throw new TypeError('Unsupported form schema keyword.');
+        if (typeof node.$ref === 'string')
+            node.$ref = pointerFor(node.$ref, base);
+        // Every reference is now absolute within the presentation wrapper; canonical documents are untouched.
+        delete node.$id;
+        delete node.$anchor;
+        delete node.$dynamicAnchor;
+    }
+    if (typeof bundle.root.document === 'boolean')
+        throw new TypeError('A form requires an object schema.');
+    const view = { $schema: bundle.dialect === 'draft-07' ? 'http://json-schema.org/draft-07/schema#' : 'https://json-schema.org/draft/2020-12/schema',
+        definitions: Object.fromEntries(prepared.resources.map((resource, index) => [`__resource${index}`, resource.document])),
+        $ref: '#/definitions/__resource0' };
+    assertFiniteObjectRendering(view, prepared.nodes.map(({ node }) => node));
+    return view;
+}
+// RJSF eagerly expands object defaults even for absent optional properties. Array items
+// are expanded only for actual elements, so recursion through arrays remains supported.
+function assertFiniteObjectRendering(root, seeds) {
+    const active = new Set(), done = new Set();
+    const visit = (value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return;
+        if (active.has(value))
+            throw new TypeError('Unsupported recursive object form schema.');
+        if (done.has(value))
+            return;
+        active.add(value);
+        const node = value;
+        if (typeof node.$ref === 'string') {
+            let target = root;
+            for (const segment of decodeURIComponent(node.$ref.slice(1)).slice(1).split('/')) {
+                target = target[segment.replace(/~1/g, '/').replace(/~0/g, '~')];
+            }
+            visit(target);
+        }
+        for (const key of ['properties', 'patternProperties', 'dependentSchemas', 'dependencies']) {
+            const map = node[key];
+            if (map && typeof map === 'object')
+                Object.values(map).forEach(visit);
+        }
+        for (const key of ['allOf', 'anyOf', 'oneOf'])
+            if (Array.isArray(node[key]))
+                node[key].forEach(visit);
+        for (const key of ['additionalProperties', 'if', 'then', 'else'])
+            visit(node[key]);
+        active.delete(value);
+        done.add(value);
+    };
+    visit(root);
+    seeds.forEach(visit);
+}
+/** Keep literal property names, including dots and pointer escapes, intact. */
+export function fieldErrors(issues) {
+    const root = Object.create(null);
+    for (const issue of issues) {
+        let node = root;
+        const path = issue.path;
+        const segments = (path === null || path === void 0 ? void 0 : path.startsWith('/')) ? path.slice(1).split('/').map(s => s.replace(/~1/g, '/').replace(/~0/g, '~')) : [];
+        // RJSF reserves __errors; retain this diagnostic at the root rather than losing it.
+        if (!segments.includes('__errors'))
+            for (const segment of segments) {
+                if (!Object.hasOwn(node, segment))
+                    Object.defineProperty(node, segment, { value: Object.create(null), enumerable: true });
+                node = node[segment];
+            }
+        if (!Object.hasOwn(node, '__errors'))
+            Object.defineProperty(node, '__errors', { value: [], enumerable: true });
+        node.__errors.push(issue.message);
+    }
+    return root;
+}

package/dist/schema.d.ts

@@ -0,0 +1,10 @@
+import type { InputDiagnostic, ValidationIssue } from './schema-types.js';
+export type * from './schema-types.js';
+export { compileSchemaBundle } from './schema-engine.js';
+export { validateSchemaInput } from './schema-compose.js';
+/** Convert input diagnostics without copying raw data or changing JSON Pointer paths. */
+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

@@ -0,0 +1,87 @@
+export { compileSchemaBundle } from './schema-engine.js';
+export { validateSchemaInput } from './schema-compose.js';
+const messages = {
+    'input-format-invalid': 'Input format is invalid.',
+    'variant-unrecognized': 'Input variant is not recognized.',
+    'input-not-json': 'Input must be a JSON-compatible value.',
+    'schema-data-invalid': 'Value does not satisfy the schema.',
+    'owner-input-invalid': 'Value does not satisfy the owner input rules.'
+};
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isPointer(value) {
+    return typeof value === 'string' && (value === '' || value.startsWith('/')) && !/~(?:[^01]|$)/u.test(value);
+}
+function readValidationIssue(value) {
+    if (!isRecord(value))
+        throw new TypeError();
+    const scope = value.scope;
+    if (!isRecord(scope))
+        throw new TypeError();
+    const identity = scope.identity;
+    if (!isRecord(identity))
+        throw new TypeError();
+    if (['ownerId', 'contractId', 'revision', 'variantId'].some(key => typeof identity[key] !== 'string')) {
+        throw new TypeError();
+    }
+    if ('consumerId' in scope && typeof scope.consumerId !== 'string')
+        throw new TypeError();
+    if ('resourceUri' in value && typeof value.resourceUri !== 'string')
+        throw new TypeError();
+    if ('schemaPath' in value && !isPointer(value.schemaPath))
+        throw new TypeError();
+    // Keep primitives locally so accessors cannot change them between validation and conversion.
+    const dataPath = value.dataPath;
+    const phase = value.phase;
+    const code = value.code;
+    if (!isPointer(dataPath))
+        throw new TypeError();
+    switch (phase) {
+        case 'decode':
+            if (code !== 'input-format-invalid' && code !== 'variant-unrecognized')
+                throw new TypeError();
+            break;
+        case 'structure':
+            if (code !== 'input-not-json' && code !== 'schema-data-invalid')
+                throw new TypeError();
+            if ('keyword' in value && typeof value.keyword !== 'string')
+                throw new TypeError();
+            break;
+        case 'semantic':
+            if (code !== 'owner-input-invalid' || typeof value.ruleId !== 'string')
+                throw new TypeError();
+            break;
+        default:
+            throw new TypeError();
+    }
+    return Object.freeze({ message: messages[code], path: dataPath });
+}
+/** Convert input diagnostics without copying raw data or changing JSON Pointer paths. */
+export function toValidationIssues(diagnostics) {
+    try {
+        if (!Array.isArray(diagnostics))
+            throw new TypeError();
+        const length = diagnostics.length;
+        if (!Number.isSafeInteger(length) || length < 0)
+            throw new TypeError();
+        // Snapshot indexed elements before invoking diagnostic getters. Ignore input iterators.
+        const snapshot = [];
+        for (let index = 0; index < length; index++) {
+            if (!Object.hasOwn(diagnostics, index))
+                throw new TypeError();
+            snapshot.push(diagnostics[index]);
+        }
+        const issues = [];
+        for (let index = 0; index < length; index++) {
+            issues.push(readValidationIssue(snapshot[index]));
+        }
+        return Object.freeze(issues);
+    }
+    catch (_a) {
+        // Never expose an external value or a getter's exception through this boundary.
+        throw new TypeError('Invalid input diagnostic.');
+    }
+}
+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);
+    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,13 +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_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) {
+    constructor(definition, snapshot, host, isRegistered, subscribeRegistrationChanges) {
         _EditorSession_instances.add(this);
         _EditorSession_draft.set(this, void 0);
         _EditorSession_status.set(this, 'editing');
@@ -26,10 +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() {
@@ -39,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.');
@@ -77,18 +171,30 @@ export class EditorSession {
         __classPrivateFieldSet(this, _EditorSession_error, undefined, "f");
         __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
         try {
-            const issues = await __classPrivateFieldGet(this, _EditorSession_definition, "f").validate(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f"));
+            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 : [])
+                : await __classPrivateFieldGet(this, _EditorSession_definition, "f").validate(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f"));
             if (!Array.isArray(issues))
                 throw new TypeError('validate() must return an issue array.');
             if (issues.length > 0) {
                 __classPrivateFieldSet(this, _EditorSession_issues, __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_copyIssues).call(this, issues), "f");
                 return { status: 'invalid', issues: __classPrivateFieldGet(this, _EditorSession_issues, "f") };
             }
-            const changes = __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_prepareChanges).call(this, __classPrivateFieldGet(this, _EditorSession_definition, "f").createPatch(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f")));
+            const changes = __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_prepareChanges).call(this, (prepared === null || prepared === void 0 ? void 0 : prepared.kind) === 'ready' ? prepared.changes
+                : __classPrivateFieldGet(this, _EditorSession_definition, "f").createPatch(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f")));
+            if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this))
+                throw new BlockEditorConflictError('The source editor registration expired.');
             const current = __classPrivateFieldGet(this, _EditorSession_host, "f").readBlock(__classPrivateFieldGet(this, _EditorSession_snapshot, "f"));
             if (!current || !sameSnapshot(__classPrivateFieldGet(this, _EditorSession_snapshot, "f"), captureSnapshot(current, __classPrivateFieldGet(this, _EditorSession_snapshot, "f")))) {
                 throw new BlockEditorConflictError();
             }
+            if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this))
+                throw new BlockEditorConflictError('The source editor registration expired.');
             if (changes.length > 0) {
                 await __classPrivateFieldGet(this, _EditorSession_host, "f").commit(Object.freeze({ expected: __classPrivateFieldGet(this, _EditorSession_snapshot, "f"), changes }));
             }
@@ -122,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_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();
@@ -138,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 => {
@@ -156,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.');
@@ -164,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/source-document.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from './types.js';
+/** Patch only edited source ranges; unsupported lossless operations fail closed. */
+export declare function patchSource(source: string, format: 'json' | 'yaml', original: JsonValue, edited: JsonValue): string;