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

package/dist/react.css

@@ -181,3 +181,45 @@
     outline: 2px solid currentColor;
     outline-offset: 2px;
 }
+
+.body :global(.block-editor-fixed-inputs) > fieldset {
+    margin: 0 0 1rem;
+    padding: 0.75rem;
+    border: 1px solid var(--block-editor-border, #ccc);
+    border-radius: var(--block-editor-radius, 0.5rem);
+}
+
+.body :global(.block-editor-fixed-inputs) output {
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+}
+
+.body :global(.block-editor-fixed-color) {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.body :global(.block-editor-fixed-color) input[type="text"] {
+    flex: 1;
+    min-width: 0;
+}
+
+.body :global(.block-editor-fixed-color) input[type="color"] {
+    width: 3rem;
+    min-width: 3rem;
+    height: 2.75rem;
+    padding: 0.25rem;
+    box-sizing: border-box;
+}
+
+.body :global(.block-editor-fixed-readonly),
+.body :global(.block-editor-fixed-unverified) {
+    margin-bottom: 0;
+    font-size: 0.875em;
+}
+
+.body :global(.block-editor-fixed-error) {
+    color: var(--block-editor-error-text, #a61b1b);
+    margin-bottom: 0;
+}

package/dist/react.d.ts

@@ -11,6 +11,7 @@ export interface DialogSessionState {
 }
 export interface DialogSession {
     getState(): DialogSessionState;
+    getFixedInputView?(): unknown;
     subscribe(listener: () => void): () => void;
     mount?(container: HTMLElement): () => void;
     getNodes?(): readonly DescendantNodeDescriptor[];
@@ -29,6 +30,8 @@ export interface EditorDialogMessages {
     readonly conflict: string;
     readonly failed: string;
     readonly structuralNode: string;
+    /** Fixed forms retain technical diagnostics in the API while showing a localized summary. */
+    readonly invalidInput?: string;
 }
 export interface EditorNodeAppearance {
     readonly name?: string;

package/dist/react.js

@@ -206,6 +206,15 @@ export class BlockEditorDialog extends React.Component {
         const { styles, messages, ModalComponent, session } = this.props;
         const saving = this.state.status === 'saving';
         const hierarchy = typeof session.getNodes === 'function';
+        let fixed = false;
+        if (session.getFixedInputView && (this.state.status === 'editing' || saving)) {
+            try {
+                fixed = Boolean(session.getFixedInputView());
+            }
+            catch (_a) {
+                fixed = true;
+            }
+        }
         return React.createElement(ModalComponent, { className: `${styles.modalContent || ''} ${hierarchy ? styles.hierarchyModal : ''} ${this.props.className || ''}`, contentLabel: messages.title, id: "blockEditorModal", onRequestClose: this.handleClose },
             React.createElement("div", { "aria-busy": saving, className: styles.body, onCompositionStart: () => { this.composing = true; }, onCompositionEnd: () => { this.composing = false; }, onKeyDownCapture: event => {
                     if (this.composing || event.nativeEvent.isComposing || event.keyCode === 229)
@@ -215,7 +224,7 @@ export class BlockEditorDialog extends React.Component {
                     React.createElement("div", { ref: this.handleBody }, hierarchy ? React.createElement(DescendantTree, { session: session, styles: styles, messages: messages, disabled: saving, nodeAppearances: this.props.nodeAppearances, nodeLabels: this.props.nodeLabels, onError: this.handleMountError, ref: tree => { this.tree = tree; } }) : null),
                     React.createElement("div", { "aria-live": "polite", className: styles.errors, role: "status" },
                         saving ? messages.saving : null,
-                        this.state.issues.map((issue, index) => {
+                        fixed && this.state.issues.length ? React.createElement("p", null, messages.invalidInput || messages.failed) : this.state.issues.map((issue, index) => {
                             var _a;
                             return hierarchy && 'reference' in issue ?
                                 React.createElement("button", { className: styles.nodeError, "data-block-editor-issue": index, disabled: saving, key: index, type: "button", onClick: () => { var _a; return (_a = this.tree) === null || _a === void 0 ? void 0 : _a.reveal(issue); } },

package/dist/registry.d.ts

@@ -2,10 +2,16 @@ import { EditorSession } from './session.js';
 import { DescendantSession } from './descendants.js';
 import type { DescendantLimits } from './descendant-types.js';
 import type { BlockEditorHost, BlockReference, EditorDefinition, EditorDescriptor } from './types.js';
+import type { PreparedEditorDefinition } from './prepared-types.js';
+import type { FixedInputDeclaration, FixedInputEditorDefinition } from './fixed-input-types.js';
 export declare class EditorRegistry {
     #private;
     register(definition: EditorDefinition): () => void;
+    registerPrepared(definition: PreparedEditorDefinition): () => void;
+    registerFixed<C = null>(definition: FixedInputEditorDefinition<C>): () => void;
     resolve(opcode: string): EditorDescriptor | undefined;
+    /** Stable, callback-free authority for this exact registration, never caller metadata. */
+    resolveFixed(opcode: string): FixedInputDeclaration | undefined;
     open(reference: BlockReference, host: BlockEditorHost): EditorSession | undefined;
     openDescendants(reference: BlockReference, host: BlockEditorHost, limits?: DescendantLimits): DescendantSession | undefined;
 }

package/dist/registry.js

@@ -3,64 +3,40 @@ 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_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';
 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 (definition.apiVersion !== EDITOR_API_VERSION)
-            throw new TypeError('Unsupported editor API version.');
-        if (!/^[a-z0-9]+$/i.test(definition.extensionId) ||
-            !/^[a-z0-9][a-z0-9._-]*$/i.test(definition.editorId)) {
-            throw new TypeError('Invalid extension ID or editor ID.');
-        }
-        if (!Array.isArray(definition.opcodes) || definition.opcodes.length === 0 ||
-            new Set(definition.opcodes).size !== definition.opcodes.length ||
-            definition.opcodes.some(opcode => typeof opcode !== 'string' ||
-                !opcode.startsWith(`${definition.extensionId}_`) || opcode === `${definition.extensionId}_`)) {
-            throw new TypeError('Expected distinct full opcodes belonging to the extension.');
-        }
-        if (!Array.isArray(definition.editableArguments) ||
-            new Set(definition.editableArguments).size !== definition.editableArguments.length ||
-            definition.editableArguments.some(name => typeof name !== 'string' || !name)) {
-            throw new TypeError('Expected distinct editable argument names.');
-        }
-        if (typeof definition.read !== 'function' || typeof definition.validate !== 'function' ||
-            typeof definition.createPatch !== 'function' ||
-            (definition.mount !== undefined && typeof definition.mount !== 'function')) {
-            throw new TypeError('Invalid editor callbacks.');
-        }
-        const key = JSON.stringify([definition.extensionId, definition.editorId]);
-        if (__classPrivateFieldGet(this, _EditorRegistry_editors, "f").has(key) || definition.opcodes.some(opcode => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").has(opcode))) {
-            throw new Error('The editor ID or an opcode is already registered.');
+        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);
+    }
+    registerPrepared(definition) {
+        if (!isPreparedEditor(definition) || typeof definition.prepareSave !== 'function') {
+            throw new TypeError('Expected a prepared source editor.');
         }
-        const entry = Object.freeze({
-            ...definition,
-            opcodes: Object.freeze([...definition.opcodes]),
-            editableArguments: Object.freeze([...definition.editableArguments])
-        });
-        __classPrivateFieldGet(this, _EditorRegistry_editors, "f").set(key, entry);
-        for (const opcode of entry.opcodes)
-            __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").set(opcode, entry);
-        __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_notifyChanges).call(this);
-        return () => {
-            if (__classPrivateFieldGet(this, _EditorRegistry_editors, "f").get(key) !== entry)
-                return;
-            __classPrivateFieldGet(this, _EditorRegistry_editors, "f").delete(key);
-            for (const opcode of entry.opcodes)
-                __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").delete(opcode);
-            __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_notifyChanges).call(this);
-        };
+        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);
@@ -71,14 +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) : 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))
@@ -90,15 +89,66 @@ 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_notifyChanges = function _EditorRegistry_notifyChanges() {
+_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) ||
+        !/^[a-z0-9][a-z0-9._-]*$/i.test(definition.editorId)) {
+        throw new TypeError('Invalid extension ID or editor ID.');
+    }
+    if (!Array.isArray(definition.opcodes) || definition.opcodes.length === 0 ||
+        new Set(definition.opcodes).size !== definition.opcodes.length ||
+        definition.opcodes.some(opcode => typeof opcode !== 'string' ||
+            !opcode.startsWith(`${definition.extensionId}_`) || opcode === `${definition.extensionId}_`)) {
+        throw new TypeError('Expected distinct full opcodes belonging to the extension.');
+    }
+    if (!Array.isArray(definition.editableArguments) ||
+        new Set(definition.editableArguments).size !== definition.editableArguments.length ||
+        definition.editableArguments.some(name => typeof name !== 'string' || !name)) {
+        throw new TypeError('Expected distinct editable argument names.');
+    }
+    if (typeof definition.read !== 'function' || typeof definition.validate !== 'function' ||
+        typeof definition.createPatch !== 'function' ||
+        (definition.mount !== undefined && typeof definition.mount !== 'function')) {
+        throw new TypeError('Invalid editor callbacks.');
+    }
+    const key = JSON.stringify([definition.extensionId, definition.editorId]);
+    if (__classPrivateFieldGet(this, _EditorRegistry_editors, "f").has(key) || definition.opcodes.some(opcode => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").has(opcode))) {
+        throw new Error('The editor ID or an opcode is already registered.');
+    }
+    const entry = Object.freeze({
+        ...definition,
+        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);
+    __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_notifyChanges).call(this);
+    return () => {
+        if (__classPrivateFieldGet(this, _EditorRegistry_editors, "f").get(key) !== entry)
+            return;
+        __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() {
     for (const listener of [...__classPrivateFieldGet(this, _EditorRegistry_changes, "f")])
         listener();
 };

package/dist/rjsf.d.ts

@@ -1,4 +1,15 @@
+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';
+export type * from './prepared-types.js';
 import type { RJSFSchema } from '@rjsf/utils';
+import type { SchemaBundle, SchemaValidationContext, SyncOwnerValidator } from './schema-types.js';
 import type { SourceFormat } from './codec.js';
 import { EditorRegistry } from './registry.js';
 import { EDITOR_API_VERSION } from './types.js';
@@ -17,10 +28,31 @@ export interface SchemaEditorOptions {
     /** Optional business validation, always run after schema validation when saving. */
     validateData?(data: JsonValue, snapshot: BlockSnapshot): readonly ValidationIssue[] | Promise<readonly ValidationIssue[]>;
 }
+/** Explicit bundle opt-in; the provider supplies fresh immutable validation inputs per call. */
+export interface SchemaBundleEditorOptions<C = null> extends Omit<SchemaEditorOptions, 'schema'> {
+    readonly schemaBundle: SchemaBundle;
+    readonly validationContext: () => SchemaValidationContext<C>;
+    readonly ownerValidate?: SyncOwnerValidator<C>;
+}
+export declare function createSchemaBundleEditor<C>(options: SchemaBundleEditorOptions<C>): EditorDefinition;
 export interface BlockEditorRegistrationAPI {
     readonly apiVersion: typeof EDITOR_API_VERSION;
     register(definition: EditorDefinition | SchemaEditorOptions): () => void;
     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 {
+    registerSchemaBundle<C>(definition: SchemaBundleEditorOptions<C>): () => void;
+}
+/** New prepared-source capability; existing bundle-only host implementations remain compatible. */
+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;
@@ -28,6 +60,21 @@ export interface BlockEditorService {
     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,8 +1,17 @@
 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';
 import * as RjsfUtils from '@rjsf/utils';
 import * as RjsfAjv from '@rjsf/validator-ajv8';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { compileSchemaBundle, validateSchemaInput, toValidationIssues } from './schema.js';
+import { schemaView, fieldErrors } from './schema-view.js';
+import { snapshotJson } from './schema-json.js';
 import { cloneJson } from './data.js';
 import { decodeSource, encodeSource, sameData } from './codec.js';
 import { EditorRegistry } from './registry.js';
@@ -17,13 +26,72 @@ const Form = moduleExports(RjsfCore).default;
 const { getDefaultFormState } = moduleExports(RjsfUtils);
 const { customizeValidator } = moduleExports(RjsfAjv);
 let nextViewId = 0;
-/** A host owns the service's lifetime; this module never stores VM or workspace instances. */
-export function createBlockEditorService() {
+export function createSchemaBundleEditor(options) {
+    const { schemaBundle, validationContext: provider, ownerValidate, apiVersion, extensionId, editorId, opcodes, argument, format, uiSchema, validateData } = options;
+    let bundle;
+    try {
+        bundle = snapshotJson(schemaBundle);
+    }
+    catch (_a) {
+        throw new TypeError('Invalid schema bundle.');
+    }
+    const result = compileSchemaBundle(bundle);
+    if (result.kind !== 'compiled')
+        throw new TypeError(`Schema bundle compilation failed: ${result.diagnostics[0].code}`);
+    const schema = schemaView(bundle);
+    const issuesFor = (data) => {
+        let context;
+        try {
+            context = provider();
+            if (context && typeof context === 'object') {
+                const prototype = Object.getPrototypeOf(context);
+                if (prototype !== Object.prototype && prototype !== null) {
+                    // Drain rejected native/cross-realm promises from a malformed synchronous provider.
+                    try {
+                        void Promise.prototype.then.call(context, () => undefined, () => undefined);
+                    }
+                    catch ( /* The common context guard rejects other non-JSON instances below. */_a) { /* The common context guard rejects other non-JSON instances below. */ }
+                }
+            }
+        }
+        catch (_b) {
+            return [{ message: 'Validation could not complete: owner-context-invalid.' }];
+        }
+        const validation = validateSchemaInput(result.validator, data, { context, ...(ownerValidate !== undefined ? { ownerValidate } : {}) });
+        if (validation.kind === 'valid')
+            return [];
+        if (validation.kind === 'execution-error')
+            return validation.diagnostics.map(d => ({ message: `Validation could not complete: ${d.code}.` }));
+        return toValidationIssues(validation.diagnostics);
+    };
+    return createSchemaEditorImpl({ apiVersion, extensionId, editorId, opcodes, argument, schema,
+        ...(format === undefined ? {} : { format }), ...(uiSchema === undefined ? {} : { uiSchema }),
+        ...(validateData === undefined ? {} : { validateData }) }, { issuesFor, dialect: result.validator.dialect });
+}
+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;
@@ -42,7 +110,18 @@ export function createBlockEditorService() {
                 notify();
             };
         },
-        registerSchema: (definition) => api.register(createSchemaEditor(definition))
+        registerSchema: (definition) => api.register(createSchemaEditor(definition)),
+        registerSchemaBundle: (definition) => api.register(createSchemaBundleEditor(definition)),
+        registerSourceEditor: (definition) => {
+            const remove = registry.registerPrepared(createSourceEditor(definition));
+            notify();
+            let active = true;
+            return () => { if (active) {
+                active = false;
+                remove();
+                notify();
+            } };
+        }
     });
     return { registry, api, subscribe: listener => {
             listeners.add(listener);
@@ -51,7 +130,10 @@ export function createBlockEditorService() {
 }
 /** Build an editor with JSON/YAML serialization, schema validation and the standard RJSF body. */
 export function createSchemaEditor(options) {
-    var _a;
+    return createSchemaEditorImpl(options);
+}
+function createSchemaEditorImpl(options, bundle) {
+    var _a, _b;
     if (options.apiVersion !== EDITOR_API_VERSION || typeof options.argument !== 'string' || !options.argument) {
         throw new TypeError('A supported API version and JSON argument name are required.');
     }
@@ -63,19 +145,20 @@ export function createSchemaEditor(options) {
     const uiSchema = options.uiSchema ? cloneJson(options.uiSchema) : {};
     const validateData = options.validateData;
     const validator = customizeValidator({
+        ...((bundle === null || bundle === void 0 ? void 0 : bundle.dialect) === '2020-12' ? { AjvClass: Ajv2020 } : {}),
         ajvOptionsOverrides: { allErrors: true, coerceTypes: false, useDefaults: false, removeAdditional: false }
     });
     const compilation = validator.rawValidation(schema);
     if (compilation.validationError) {
         throw new TypeError(`Invalid or unsupported JSON Schema: ${compilation.validationError.message}`);
     }
-    const issuesFor = (data) => {
+    const issuesFor = (_b = bundle === null || bundle === void 0 ? void 0 : bundle.issuesFor) !== null && _b !== void 0 ? _b : ((data) => {
         const result = validator.validateFormData(data, schema, undefined, undefined, uiSchema);
         return result.errors.map(error => ({
             message: error.stack || error.message || 'Invalid value.',
             ...(error.property === undefined ? {} : { path: error.property })
         }));
-    };
+    });
     // RJSF uses undefined for cleared controls; persist these as omitted properties (or null at the root).
     const formValue = (value) => JSON.parse(JSON.stringify(value !== null && value !== void 0 ? value : null));
     const dataFor = (draft) => {
@@ -94,7 +177,7 @@ export function createSchemaEditor(options) {
             }
             const data = decodeSource(slot.value, format);
             // Initialize the session draft once; remounting must not reset edits or errors.
-            return { data: formValue(getDefaultFormState(validator, schema, data, schema)) };
+            return { data: bundle ? data : formValue(getDefaultFormState(validator, schema, data, schema)) };
         },
         validate: (draft, snapshot) => {
             const data = dataFor(draft);
@@ -134,7 +217,8 @@ export function createSchemaEditor(options) {
                         constAsDefaults: 'never'
                     },
                     tagName: 'div',
-                    liveValidate: true,
+                    liveValidate: !bundle,
+                    ...(bundle ? { noValidate: true, extraErrors: fieldErrors(state.issues) } : {}),
                     showErrorList: false,
                     disabled: state.status !== 'editing',
                     onChange: (event) => {

package/dist/schema-compose.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledSchema, SchemaInputValidationResult, SchemaJsonValue, SchemaValidationContext, SyncOwnerValidator } from './schema-types.js';
+/** Validate one protected candidate/context snapshot, then invoke a synchronous owner at most once. */
+export declare function validateSchemaInput<C>(compiled: CompiledSchema, data: SchemaJsonValue, options: {
+    readonly context: SchemaValidationContext<C>;
+    readonly ownerValidate?: SyncOwnerValidator<C>;
+}): SchemaInputValidationResult;

package/dist/schema-compose.js

@@ -0,0 +1,103 @@
+import { scopeFor } from './schema-engine.js';
+import { isJsonRecord, JsonSnapshotError, snapshotJson } from './schema-json.js';
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object') {
+        Object.values(value).forEach(deepFreeze);
+        Object.freeze(value);
+    }
+    return value;
+}
+function ownerFailure(scope, code) {
+    return Object.freeze({ kind: 'execution-error', diagnostics: Object.freeze([
+            Object.freeze({ scope, phase: 'execution', operation: 'semantic', code })
+        ]) });
+}
+function asyncResult(value) {
+    // Handle rejected native/cross-realm promises without running a user-defined `then` getter.
+    try {
+        void Promise.prototype.then.call(value, () => undefined, () => undefined);
+        return true;
+    }
+    catch ( /* Non-promises have no Promise internal slots. */_a) { /* Non-promises have no Promise internal slots. */ }
+    return 'then' in value;
+}
+/** Validate one protected candidate/context snapshot, then invoke a synchronous owner at most once. */
+export function validateSchemaInput(compiled, data, options) {
+    let scope = scopeFor(compiled);
+    let context;
+    let owner;
+    try {
+        if (!isJsonRecord(options))
+            return ownerFailure(scope, 'owner-context-invalid');
+        const descriptor = Object.getOwnPropertyDescriptor(options, 'context');
+        if (!descriptor || !('value' in descriptor))
+            return ownerFailure(scope, 'owner-context-invalid');
+        const candidate = snapshotJson(descriptor.value);
+        if (!isJsonRecord(candidate) || typeof candidate.consumerId !== 'string' ||
+            typeof candidate.nowMs !== 'number' || !Number.isFinite(candidate.nowMs) || !Object.hasOwn(candidate, 'settings')) {
+            return ownerFailure(scope, 'owner-context-invalid');
+        }
+        context = deepFreeze(candidate);
+        scope = Object.freeze({ ...scope, consumerId: context.consumerId });
+        const ownerDescriptor = Object.getOwnPropertyDescriptor(options, 'ownerValidate');
+        if (ownerDescriptor && !('value' in ownerDescriptor))
+            return ownerFailure(scope, 'owner-result-invalid');
+        owner = ownerDescriptor === null || ownerDescriptor === void 0 ? void 0 : ownerDescriptor.value;
+        if (owner !== undefined && typeof owner !== 'function')
+            return ownerFailure(scope, 'owner-result-invalid');
+    }
+    catch (_a) {
+        return ownerFailure(scope, 'owner-context-invalid');
+    }
+    let input;
+    try {
+        input = deepFreeze(snapshotJson(data));
+        const structural = compiled.validate(input, { consumerId: context.consumerId });
+        if (!isJsonRecord(structural) || !Array.isArray(structural.diagnostics) ||
+            (structural.kind === 'valid' ? structural.diagnostics.length !== 0 : structural.diagnostics.length === 0) ||
+            !['valid', 'invalid', 'execution-error'].includes(structural.kind))
+            throw new Error();
+        if (structural.kind !== 'valid')
+            return structural;
+    }
+    catch (error) {
+        if (error instanceof JsonSnapshotError && error.kind === 'invalid')
+            return Object.freeze({ kind: 'invalid', diagnostics: Object.freeze([
+                    Object.freeze({ scope, phase: 'structure', code: 'input-not-json', dataPath: error.dataPath })
+                ]) });
+        return Object.freeze({ kind: 'execution-error', diagnostics: Object.freeze([Object.freeze({ scope, phase: 'execution', operation: 'structure',
+                    code: error instanceof JsonSnapshotError && error.kind === 'limit' || error instanceof RangeError ? 'limit-exceeded' : 'engine-failed' })]) });
+    }
+    if (!owner)
+        return Object.freeze({ kind: 'valid', diagnostics: Object.freeze([]) });
+    let result;
+    try {
+        result = owner(input, context);
+    }
+    catch (_b) {
+        return ownerFailure(scope, 'owner-validation-failed');
+    }
+    try {
+        if (result !== null && (typeof result === 'object' || typeof result === 'function') && asyncResult(result))
+            return ownerFailure(scope, 'async-owner-unsupported');
+        const snapshot = snapshotJson(result);
+        if (!isJsonRecord(snapshot) || !Array.isArray(snapshot.issues))
+            return ownerFailure(scope, 'owner-result-invalid');
+        if (snapshot.kind === 'valid' && snapshot.issues.length === 0)
+            return Object.freeze({ kind: 'valid', diagnostics: Object.freeze([]) });
+        if (snapshot.kind !== 'invalid' || snapshot.issues.length === 0)
+            return ownerFailure(scope, 'owner-result-invalid');
+        const diagnostics = [];
+        for (const issue of snapshot.issues) {
+            if (!isJsonRecord(issue) || typeof issue.dataPath !== 'string' ||
+                (issue.dataPath !== '' && !issue.dataPath.startsWith('/')) || /~(?:[^01]|$)/u.test(issue.dataPath) || typeof issue.ruleId !== 'string') {
+                return ownerFailure(scope, 'owner-result-invalid');
+            }
+            diagnostics.push(Object.freeze({ scope, phase: 'semantic', code: 'owner-input-invalid', dataPath: issue.dataPath, ruleId: issue.ruleId }));
+        }
+        return Object.freeze({ kind: 'invalid', diagnostics: Object.freeze(diagnostics) });
+    }
+    catch (_c) {
+        return ownerFailure(scope, 'owner-result-invalid');
+    }
+}