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

package/README.md

@@ -6,6 +6,9 @@ TurboWarp拡張が扱う構造化データを、フォームや独自UIで編集
 
 日本語の利用手順・API・GUI接続・公開・検証記録は[ドキュメント一覧](docs/README.md)へ集約しています。
 
+[公開エディター・日英案内](https://kubohiroya.github.io/turbowarp-extension-data-editor/) と
+[公開・検証の運用Issue #26](https://github.com/kubohiroya/turbowarp-extension-data-editor/issues/26) も本リポジトリが所有します。
+
 ## 標準の JSON Schema エディター
 
 JSON/YAML を格納する文字列引数と JSON Schema を宣言すると、react-jsonschema-form がフォームを生成します。
@@ -100,17 +103,17 @@ pnpm test
 `pnpm test` は型宣言を含むビルド後、コアと標準フォームのテストを実行します。
 パッケージは ESM です。ブラウザには ES2022 の組み込み API が必要です。
 標準フォームの React / ReactDOM peer は 16.14 / 17 / 18。GUI は既存の 16.14 を共有します。
-初回の実験版は `@kubohiroya/turbowarp-extension-data-editor@0.1.0` です。
+初回の実験版は `@kubohiroya/turbowarp-extension-data-editor@0.1.0` です。固定SchemaのSource/Form編集を追加する今回の配布版は `0.2.0` です。
 
 ```sh
-npm install --save-exact @kubohiroya/turbowarp-extension-data-editor@0.1.0
+npm install --save-exact @kubohiroya/turbowarp-extension-data-editor@0.2.0
 ```
 
 配布物・改名時の互換性・公開手順は[パッケージ配布](docs/package-distribution.md)を参照してください。
 
 ## GUI で試す
 
-`scratch-gui` はnpmに公開した本パッケージを固定versionで参照します。通常のGUIビルドに共通リポジトリの隣接配置は不要です。
+`scratch-gui` は本パッケージを検証済みのnpm完全version、またはGitの完全SHAで固定参照します。通常のGUIビルドに共通リポジトリの隣接配置は不要です。
 [GUIの起動・制約・検証手順](docs/block-editor.md) に従ってください。
 既存の拡張アイコンをクリックすると、標準モーダルで下書きを編集できます。
 
@@ -129,3 +132,21 @@ GUI の `src/lib/tw-feature-flags.js` で起動時固定の `blockEditorDialogs`
 ## webpack 4 / E2E
 
 [webpack 4配布物と設定API](docs/webpack4.md)、[GUI接続E2EとCIの実行手順](docs/block-editor-e2e.md)を参照。専用編集UIから互換ビルド・E2Eまで共通側で管理し、GUIには明示的なホスト接続とCI呼出しを残す。
+
+## Schemaの共通型と診断変換
+
+`@kubohiroya/turbowarp-extension-data-editor/schema`はDOM・React・RJSFをロードせずに利用できる入口です。Schema bundle、正本・生成物・参照用の役割、処理段階別の診断・結果、同期owner検証の型を公開します。
+
+`toValidationIssues()`は入力診断を既存の`ValidationIssue`へ変換し、JSON Pointerのpath・順序・件数を維持した凍結結果を返します。不正な診断やcompile/execution診断はTypeErrorで拒否します。既存RJSFのpathや保存時専用の非同期`validateData`の契約は変わりません。
+
+`compileSchemaBundle()`はdraft-07/2020-12と同梱resourceからオフラインの同期validatorを生成します。Schemaと入力を変更せず、構造化診断を返します。[pure検証API](docs/schema.md)を参照してください。同期owner合成と明示bundleのRJSF経路も追加済みです。既存公開入口・webpack4/build-info・CSS buildを維持しています。
+
+同期owner検証には`/schema`の`validateSchemaInput`を利用できます。明示bundleフォームは`/rjsf`の`createSchemaBundleEditor` / `registerSchemaBundle`で登録します。context providerは呼出しごとに時刻・設定を渡します。表示上の対応範囲と既存APIの扱いは[Schema基盤](docs/schema.md)を参照してください。
+
+現在のowner横断検証は**14契約・8 package**です。[Template分離後の再検証手順](docs/template-fixture-separation.ja.md#current-verification)で、Templateを含まないisolation indexと2つの検証commandを確認してください。段階2では、この14本番契約と新規予定の9固定契約を区別して計画します。旧16契約・9 packageの結果と当時の開始条件は[段階1の履歴](docs/schema-stage1.ja.md)として保持します。
+
+## Optional editing examples
+
+Repository examples are opt-in teaching code, not template blocks or additional package exports. See [the JSON/YAML document example](examples/document-properties.mjs) and [its guide](examples/README.ja.md). Each extension owns its actual data contract.
+
+Prepared source editing is an optional host capability. See [the source/form contract](docs/source-forms.ja.md) for fixed-schema bindings, atomic saves, compatibility, and rollback.

package/dist/build-info.json

@@ -1,6 +1,11 @@
 {
   "name": "@kubohiroya/turbowarp-extension-data-editor",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "repository": "https://github.com/kubohiroya/turbowarp-extension-data-editor",
-  "revision": "9e041e5278a1ea70146a76c10732d1401955a12a"
+  "revision": "76fa1d50a3c188082ceef723ea018a9d8769ea6e",
+  "sourceState": "commit",
+  "sourceSha256": "912efc0438710958698527aa5c26a33b0b1c2da280f91d36b048f6f2389a48f0",
+  "capabilities": {
+    "preparedSource": 1
+  }
 }

package/dist/descendants.js

@@ -143,9 +143,15 @@ export class DescendantSession {
         __classPrivateFieldGet(this, _DescendantSession_instances, "m", _DescendantSession_notify).call(this);
         try {
             __classPrivateFieldGet(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
+            const prepared = new Map();
             for (const record of __classPrivateFieldGet(this, _DescendantSession_records, "f").values()) {
                 try {
-                    const issues = await abortable(record.definition.validate(cloneJson(record.draft), record.snapshot), __classPrivateFieldGet(this, _DescendantSession_abort, "f").signal);
+                    const result = isPreparedEditor(record.definition)
+                        ? capturePreparedSave(record.definition, cloneJson(record.draft), record.snapshot) : undefined;
+                    if (result)
+                        prepared.set(record.snapshot.blockId, result);
+                    const issues = result ? (result.kind === 'invalid' ? result.issues : [])
+                        : await abortable(record.definition.validate(cloneJson(record.draft), record.snapshot), __classPrivateFieldGet(this, _DescendantSession_abort, "f").signal);
                     __classPrivateFieldGet(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
                     record.issues = copyIssues(issues);
                 }
@@ -161,7 +167,9 @@ export class DescendantSession {
             const destinations = new Set();
             for (const record of __classPrivateFieldGet(this, _DescendantSession_records, "f").values()) {
                 try {
-                    const patch = record.definition.createPatch(cloneJson(record.draft), record.snapshot);
+                    const result = prepared.get(record.snapshot.blockId);
+                    const patch = (result === null || result === void 0 ? void 0 : result.kind) === 'ready' ? result.changes
+                        : record.definition.createPatch(cloneJson(record.draft), record.snapshot);
                     __classPrivateFieldGet(this, _DescendantSession_instances, "m", _DescendantSession_assertSaving).call(this);
                     if (!Array.isArray(patch))
                         throw new TypeError('createPatch() must return an array.');
@@ -334,3 +342,4 @@ _DescendantSession_snapshot = new WeakMap(), _DescendantSession_host = new WeakM
     __classPrivateFieldGet(this, _DescendantSession_detach, "f").clear();
     __classPrivateFieldGet(this, _DescendantSession_listeners, "f").clear();
 };
+import { isPreparedEditor, capturePreparedSave } from './prepared-save.js';

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export { EditorRegistry } from './registry.js';
 export { EditorSession } from './session.js';
 export * from './descendant-types.js';
 export { DescendantSession } from './descendants.js';
+export type * from './prepared-types.js';

package/dist/json-value.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaBundle } from './schema-types.js';
+/** Every finite JSON value is accepted. The shared snapshot guard enforces JSON safety. */
+export declare const jsonValueSchema = true;
+export declare const jsonValueSchemaBundle: SchemaBundle;

package/dist/json-value.js

@@ -0,0 +1,12 @@
+/** Every finite JSON value is accepted. The shared snapshot guard enforces JSON safety. */
+export const jsonValueSchema = true;
+const source = { repository: 'https://github.com/kubohiroya/turbowarp-extension-data-editor',
+    path: 'src/json-value.ts', symbol: 'jsonValueSchema' };
+export const jsonValueSchemaBundle = Object.freeze({
+    identity: { ownerId: '@kubohiroya/turbowarp-extension-data-editor', contractId: 'json-value', revision: '1', variantId: 'json-value' },
+    dialect: '2020-12',
+    root: { retrievalUri: 'https://kubohiroya.github.io/turbowarp-extension-data-editor/schemas/json-value',
+        document: jsonValueSchema, artifact: { role: 'canonical-schema', source } },
+    resources: [],
+    provenance: { canonicalSources: [source], generatedFiles: [], referenceSchemas: [], generationSources: [] }
+});

package/dist/prepared-save.d.ts

@@ -0,0 +1,5 @@
+import type { PreparedEditorDefinition, PreparedSave } from './prepared-types.js';
+import type { BlockSnapshot, EditorDefinition, JsonObject } from './types.js';
+export declare function isPreparedEditor(definition: EditorDefinition): definition is PreparedEditorDefinition;
+/** Capture callback output before checking it; accessors and iterators never supply writes. */
+export declare function capturePreparedSave(definition: PreparedEditorDefinition, draft: JsonObject, snapshot: BlockSnapshot): PreparedSave;

package/dist/prepared-save.js

@@ -0,0 +1,47 @@
+import { snapshotJson } from './schema-json.js';
+export function isPreparedEditor(definition) {
+    return definition.saveContract === 'prepared-source-v1';
+}
+/** Capture callback output before checking it; accessors and iterators never supply writes. */
+export function capturePreparedSave(definition, draft, snapshot) {
+    const output = definition.prepareSave(draft, snapshot);
+    try {
+        const value = snapshotJson(output);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new TypeError('Invalid prepared save.');
+        const result = value;
+        if (result.kind === 'ready' && Array.isArray(result.changes)) {
+            const changes = [];
+            for (let i = 0; i < result.changes.length; i++) {
+                const change = result.changes[i];
+                if (!change || typeof change.argument !== 'string' ||
+                    !(typeof change.value === 'string' || typeof change.value === 'boolean' ||
+                        (typeof change.value === 'number' && Number.isFinite(change.value)))) {
+                    throw new TypeError('Invalid prepared change.');
+                }
+                changes.push(Object.freeze({ argument: change.argument, value: change.value }));
+            }
+            return Object.freeze({ kind: 'ready', changes: Object.freeze(changes) });
+        }
+        if (result.kind === 'invalid' && Array.isArray(result.issues) && result.issues.length > 0) {
+            const issues = [];
+            for (let i = 0; i < result.issues.length; i++) {
+                const issue = result.issues[i];
+                if (!issue || typeof issue.message !== 'string' || (issue.path !== undefined && typeof issue.path !== 'string')) {
+                    throw new TypeError('Invalid prepared issue.');
+                }
+                issues.push(Object.freeze({ message: issue.message, ...(issue.path === undefined ? {} : { path: issue.path }) }));
+            }
+            return Object.freeze({ kind: 'invalid', issues: Object.freeze(issues) });
+        }
+        throw new TypeError('Invalid prepared save.');
+    }
+    catch (error) {
+        // A synchronous contract never awaits foreign thenables. Drain native rejected promises.
+        try {
+            void Promise.prototype.then.call(output, () => undefined, () => undefined);
+        }
+        catch ( /* Non-promises are rejected without touching their then property. */_a) { /* Non-promises are rejected without touching their then property. */ }
+        throw error;
+    }
+}

package/dist/prepared-types.d.ts

@@ -0,0 +1,13 @@
+import type { BlockSnapshot, EditorDefinition, JsonObject, LiteralArgumentChange, ValidationIssue } from './types.js';
+export type PreparedSave = {
+    readonly kind: 'ready';
+    readonly changes: readonly LiteralArgumentChange[];
+} | {
+    readonly kind: 'invalid';
+    readonly issues: readonly ValidationIssue[];
+};
+export interface PreparedEditorDefinition extends EditorDefinition {
+    readonly saveContract: 'prepared-source-v1';
+    /** Construct, validate and capture each exact candidate once per save attempt. */
+    prepareSave(draft: JsonObject, snapshot: BlockSnapshot): PreparedSave;
+}

package/dist/prepared-types.js

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

package/dist/registry.d.ts

@@ -2,9 +2,11 @@ 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';
 export declare class EditorRegistry {
     #private;
     register(definition: EditorDefinition): () => void;
+    registerPrepared(definition: PreparedEditorDefinition): () => void;
     resolve(opcode: string): EditorDescriptor | undefined;
     open(reference: BlockReference, host: BlockEditorHost): EditorSession | undefined;
     openDescendants(reference: BlockReference, host: BlockEditorHost, limits?: DescendantLimits): DescendantSession | undefined;

package/dist/registry.js

@@ -3,13 +3,14 @@ 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_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';
 export class EditorRegistry {
     constructor() {
         _EditorRegistry_instances.add(this);
@@ -18,49 +19,15 @@ export class EditorRegistry {
         _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 (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);
     }
     resolve(opcode) {
         const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode);
@@ -78,7 +45,8 @@ export class EditorRegistry {
             return undefined;
         const snapshot = captureSnapshot(live, capturedReference);
         const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode);
-        return entry ? new EditorSession(entry, snapshot, host) : undefined;
+        return entry ? new EditorSession(entry, snapshot, host, isPreparedEditor(entry)
+            ? () => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry : undefined) : undefined;
     }
     openDescendants(reference, host, limits) {
         if (!supportsDescendantEditing(host))
@@ -98,7 +66,51 @@ export class EditorRegistry {
         }, 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_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])
+    });
+    __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);
+    };
+}, _EditorRegistry_notifyChanges = function _EditorRegistry_notifyChanges() {
     for (const listener of [...__classPrivateFieldGet(this, _EditorRegistry_changes, "f")])
         listener();
 };

package/dist/rjsf.d.ts

@@ -1,4 +1,9 @@
+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 +22,27 @@ 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;
+}
+/** 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 BlockEditorService {
     readonly registry: EditorRegistry;
@@ -28,6 +50,8 @@ 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(): BlockEditorService & {
+    readonly api: SourceBlockEditorRegistrationAPI;
+};
 /** 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,14 @@
 import * as React from 'react';
+import { createSourceEditor } from './source-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,6 +23,48 @@ const Form = moduleExports(RjsfCore).default;
 const { getDefaultFormState } = moduleExports(RjsfUtils);
 const { customizeValidator } = moduleExports(RjsfAjv);
 let nextViewId = 0;
+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 });
+}
 /** A host owns the service's lifetime; this module never stores VM or workspace instances. */
 export function createBlockEditorService() {
     const registry = new EditorRegistry();
@@ -42,7 +90,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 +110,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 +125,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 +157,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 +197,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;