@kubohiroya/turbowarp-structured-data 0.6.1 → 0.6.3

package/docs/editor-runtime-boundary.ja.md

@@ -0,0 +1,38 @@
+# 編集metadataとruntimeの境界
+
+追跡: [共通data-editor #72](https://github.com/kubohiroya/turbowarp-extension-data-editor/issues/72)。
+Camera Source #52と同じ責務分担を適用する。
+
+| 担当 | 責務 |
+| --- | --- |
+| Structured Data | JSON/YAMLの既存parser、名前付きデータ、path/反復、正本Schema、原文decoder、pure owner検証、編集binding |
+| 共通data-editor／GUI | 編集時のSchema compile、Schema制約の診断、フォーム描画、保存／Cancel、transaction |
+
+`sourceBinding.validateSource` は原文を保持して既存ownerのreader/checkerを実行し、Schemaをcompileしない。
+共通GUIは宣言されたSchemaBundleを検証してから保存する。独自consumerがSchema keyword別診断を必要とする場合は、
+consumer自身が共通data-editorのSchema検証を組み合わせる。owner callbackの診断はSchema診断の代わりにはしない。
+
+`@kubohiroya/turbowarp-structured-data/editor-metadata` はSource/Formの3定義と固定MAX入力の1定義を公開する。
+この入口はGUI/DOM/VMを参照せず、実行時importは既存production依存の`yaml`だけである。
+共通のJSON値SchemaBundleと新数値入力parserは開発依存の正本をビルド時に取り込み、手書きの複製を作らない。
+型宣言で共通型を利用するTypeScript consumerは、自身の開発依存にdata-editorを追加する。
+
+data-editorの直接依存をdevDependenciesへ移す。standalone JSとmetadataにはAjv、ajv-formats、Schema compiler、
+React/RJSFを含めない。Viteのmodule graph guardと隔離importテストで再流入を検出する。
+通常のYAML解析はruntime機能なので維持する。yaml本体の複数拡張間共有は[sb3-toolchain #65](https://github.com/kubohiroya/sb3-toolchain/issues/65)の後続課題である。
+
+既存のMVP・GUI編集フラグ、Extension ID、opcode、MAXの文法・範囲、既存raw値と無変更保存、Undo transactionを維持する。
+問題時はGUI編集フラグをOFFにして再読込し、必要なら検証済みのexact pin・lock・生成物へ一組で戻す。
+保存済みデータを自動移行しない。
+
+開発時は`pnpm run build`でstandaloneと公開metadataを生成してから対象テストを実行する。
+ローカルの対象テストは実GUIや実機の代替であり、ブラウザ上の表示確認を実施した意味にはしない。
+
+## ローカル検証記録（2026-10-24）
+
+- 基準: 公開main `4ae44bd6ee1d`。standalone JSは560,962 Bから256,729 Bへ変更。
+- gzip level 9（参考値）は119,711 Bから58,861 B。SB3削減量や実行時RAMの測定値ではない。
+- 対象テスト82件、型検査、変更したTypeScriptのESLint、standalone／metadata build、package export・repo policy確認が成功。
+- GUIなしVMで通常登録1回、Ajv生成0回、編集用SchemaBundle compile 0回。2拡張をsb3-toolchain 0.16.0で束ねても同じ結果。
+- 共通サービス経由のSchema制約拒否、owner受理条件、raw no-op／変更時commit、旧GUIでの非登録、隔離metadata importを確認。
+- 実ブラウザ・3D描画・実カメラの確認、push、PR、merge、npm公開はこのローカル検証に含めない。

package/lib-editor/src/codecs.d.ts

@@ -0,0 +1,10 @@
+import { type JsonValue } from './core.js';
+export declare const PARSE_LIMITS: {
+    readonly maxInputBytes: number;
+    readonly maxDepth: 64;
+    readonly maxNodes: 50000;
+};
+export declare function parseJsonDocument(source: string): JsonValue;
+export declare function parseYamlDocument(source: string): JsonValue;
+export declare function renderJsonDocument(value: JsonValue): string;
+export declare function renderYamlDocument(value: JsonValue): string;

package/lib-editor/src/config.d.ts

@@ -0,0 +1,25 @@
+export declare const STRUCTURED_DATA_MVP_DEFAULT = false;
+export declare const NAMED_DATA_REGISTRY_MVP_DEFAULT = false;
+export declare const NAMED_DATA_SCHEMA_REF_DEFAULT = false;
+export declare function isNamedDataSchemaRefEnabled(source?: {
+    __TW_NAMED_DATA_FEATURE_FLAGS__?: {
+        NAMED_DATA_SCHEMA_REF?: unknown;
+    };
+}): boolean;
+export declare function isStructuredDataMvpEnabled(source?: {
+    STRUCTURED_DATA_MVP?: unknown;
+}): boolean;
+export declare function isNamedDataRegistryMvpEnabled(source?: {
+    NAMED_DATA_REGISTRY_MVP?: unknown;
+}): boolean;
+export declare const extensionConfig: {
+    readonly id: "kubohiroyastructureddata";
+    readonly slug: "structured-data";
+    readonly name: "Structured Data";
+    readonly description: "Named structured data with JSON/YAML codecs for TurboWarp and server compilation.";
+    readonly author: "Hiroya Kubo";
+    readonly license: "MPL-2.0";
+    readonly unsandboxed: true;
+    readonly docsURI: "https://kubohiroya.github.io/turbowarp-structured-data/";
+    readonly blockIconURI: "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0OCA0OCI+PHJlY3QgeD0iNCIgeT0iOCIgd2lkdGg9IjE4IiBoZWlnaHQ9IjE0IiByeD0iMyIgZmlsbD0iIzRDOTdGRiIvPjxyZWN0IHg9IjI2IiB5PSI4IiB3aWR0aD0iMTgiIGhlaWdodD0iMTQiIHJ4PSIzIiBmaWxsPSIjNTlDMDU5Ii8+PHJlY3QgeD0iMTUiIHk9IjI2IiB3aWR0aD0iMTgiIGhlaWdodD0iMTQiIHJ4PSIzIiBmaWxsPSIjRkZBQjE5Ii8+PC9zdmc+";
+};

package/lib-editor/src/core.d.ts

@@ -0,0 +1,34 @@
+export declare const STRUCTURED_DATA_ERROR_CODES: readonly ["INVALID_JSON", "INVALID_YAML", "INVALID_NAME", "DATA_NOT_FOUND", "INVALID_PATH", "PATH_NOT_FOUND", "TYPE_MISMATCH", "INDEX_OUT_OF_RANGE", "ITERATION_LIMIT_EXCEEDED", "ITERATION_CONTEXT_REQUIRED", "PARSE_LIMIT_EXCEEDED"];
+export type StructuredDataErrorCode = (typeof STRUCTURED_DATA_ERROR_CODES)[number];
+export type JsonPrimitive = null | boolean | number | string;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type PathSegment = {
+    kind: 'key';
+    value: string;
+} | {
+    kind: 'index';
+    value: number;
+};
+export declare class StructuredDataError extends Error {
+    readonly code: StructuredDataErrorCode;
+    constructor(code: StructuredDataErrorCode, message: string);
+}
+export declare function parseJson(text: unknown): JsonValue;
+export declare function isValidJson(text: unknown): boolean;
+export declare function normalizeJson(text: unknown): string;
+export declare function stringifyJson(value: JsonValue): string;
+export declare function parsePath(input: unknown): PathSegment[];
+export declare function getAtPath(root: JsonValue, segments: readonly PathSegment[]): JsonValue;
+export declare function hasAtPath(root: JsonValue, segments: readonly PathSegment[]): boolean;
+export declare function setAtPath(root: JsonValue, segments: readonly PathSegment[], replacement: JsonValue): JsonValue;
+export declare function deleteAtPath(root: JsonValue, segments: readonly PathSegment[]): JsonValue;
+export declare function keysAtPath(root: JsonValue, segments: readonly PathSegment[]): string[];
+export declare function lengthAtPath(root: JsonValue, segments: readonly PathSegment[]): number;
+export interface IterationEntry {
+    key: string;
+    value: JsonValue;
+}
+export declare function iterationEntries(root: JsonValue, segments: readonly PathSegment[], maximum: number): IterationEntry[];
+export declare function compareUnicodeCodePoints(left: string, right: string): number;

package/lib-editor/src/editor-metadata.d.ts

@@ -0,0 +1,5 @@
+/** Lightweight declarations and owner callbacks; the optional GUI owns Schema compilation. */
+export { sourceEditorDefinitions } from './editor-schema.js';
+export { canonicalBundle, registerSourceEditors, sourceBinding } from './source-editor.js';
+export { fixedInputEditorDefinitions, registerFixedInputEditors } from './fixed-input-editors.js';
+export { fixedInputSchemaBundle } from './fixed-input-schema.js';

package/lib-editor/src/editor-metadata.js

@@ -0,0 +1,443 @@
+import { LineCounter, isAlias, isMap, isScalar, isSeq, parseDocument } from "yaml";
+var extensionConfig = {
+	id: "kubohiroyastructureddata",
+	slug: "structured-data",
+	name: "Structured Data",
+	description: "Named structured data with JSON/YAML codecs for TurboWarp and server compilation.",
+	author: "Hiroya Kubo",
+	license: "MPL-2.0",
+	unsandboxed: true,
+	docsURI: "https://kubohiroya.github.io/turbowarp-structured-data/",
+	blockIconURI: "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0OCA0OCI+PHJlY3QgeD0iNCIgeT0iOCIgd2lkdGg9IjE4IiBoZWlnaHQ9IjE0IiByeD0iMyIgZmlsbD0iIzRDOTdGRiIvPjxyZWN0IHg9IjI2IiB5PSI4IiB3aWR0aD0iMTgiIGhlaWdodD0iMTQiIHJ4PSIzIiBmaWxsPSIjNTlDMDU5Ii8+PHJlY3QgeD0iMTUiIHk9IjI2IiB3aWR0aD0iMTgiIGhlaWdodD0iMTQiIHJ4PSIzIiBmaWxsPSIjRkZBQjE5Ii8+PC9zdmc+"
+};
+function canonicalBundle(ownerId, contractId, document, ownerSource) {
+	const source = {
+		repository: ownerId,
+		path: `schemas/${contractId}.schema.json`
+	};
+	return {
+		identity: {
+			ownerId,
+			contractId,
+			revision: "source-forms-v1",
+			variantId: "default"
+		},
+		dialect: "2020-12",
+		root: {
+			retrievalUri: `https://kubohiroya.github.io/${ownerId}/schemas/${contractId}.schema.json`,
+			document,
+			artifact: {
+				role: "canonical-schema",
+				source
+			}
+		},
+		resources: [],
+		provenance: {
+			canonicalSources: [source, {
+				repository: ownerId,
+				...ownerSource
+			}],
+			generatedFiles: [],
+			referenceSchemas: [],
+			generationSources: []
+		}
+	};
+}
+function sourceBinding(argument, bundle, read, check = read, format = "json", uiSchema) {
+	return {
+		argument,
+		variants: [{
+			variantId: "default",
+			format,
+			schemaBundle: bundle,
+			...uiSchema ? { uiSchema } : {}
+		}],
+		decode(source) {
+			return {
+				source,
+				format,
+				variantId: "default",
+				data: read(source)
+			};
+		},
+		validateSource(source, context) {
+			try {
+				read(source);
+			} catch {
+				return {
+					source,
+					result: {
+						kind: "invalid",
+						diagnostics: [{ code: "source-decode-invalid" }]
+					}
+				};
+			}
+			try {
+				const descriptors = Object.getOwnPropertyDescriptors(context);
+				if (typeof descriptors.consumerId?.value !== "string" || typeof descriptors.nowMs?.value !== "number" || !Number.isFinite(descriptors.nowMs.value) || !descriptors.settings || !("value" in descriptors.settings)) return {
+					source,
+					result: {
+						kind: "execution-error",
+						diagnostics: [{ code: "owner-context-invalid" }]
+					}
+				};
+			} catch {
+				return {
+					source,
+					result: {
+						kind: "execution-error",
+						diagnostics: [{ code: "owner-context-invalid" }]
+					}
+				};
+			}
+			try {
+				check(source);
+			} catch {
+				return {
+					source,
+					result: {
+						kind: "invalid",
+						diagnostics: [{ code: "source-owner-invalid" }]
+					}
+				};
+			}
+			return {
+				source,
+				result: {
+					kind: "valid",
+					diagnostics: []
+				}
+			};
+		}
+	};
+}
+/** The optional capability keeps legacy hosts and the startup flag safely inactive. */
+function registerSourceEditors(scratch, definitions) {
+	const host = scratch;
+	const api = host.gui?.blockEditors;
+	if (api?.apiVersion !== 1 || typeof api.registerSourceEditor !== "function") return () => {};
+	const removers = [];
+	let active = true;
+	const dispose = () => {
+		if (!active) return;
+		active = false;
+		host.vm?.runtime?.off?.("RUNTIME_DISPOSED", dispose);
+		for (const remove of removers.splice(0).reverse()) remove();
+	};
+	try {
+		for (const definition of definitions) removers.push(api.registerSourceEditor.call(api, definition));
+		host.vm?.runtime?.on?.("RUNTIME_DISPOSED", dispose);
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+	return dispose;
+}
+var source$1 = {
+	repository: "https://github.com/kubohiroya/turbowarp-extension-data-editor",
+	path: "src/json-value.ts",
+	symbol: "jsonValueSchema"
+};
+var 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: true,
+		artifact: {
+			role: "canonical-schema",
+			source: source$1
+		}
+	},
+	resources: [],
+	provenance: {
+		canonicalSources: [source$1],
+		generatedFiles: [],
+		referenceSchemas: [],
+		generationSources: []
+	}
+});
+var numberToken = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
+var invalidNumber = Object.freeze({
+	kind: "invalid",
+	code: "fixed-number-input-invalid"
+});
+/**
+* Parse a NEW numeric draft according to NP-finite-new-input-v1.
+* Never apply this to opening/no-op raw values or use it as an owner validator.
+* Keep the validated token so negative zero, precision and exponent spelling survive.
+*/
+function parseFixedNumberInput(input) {
+	if (typeof input === "number") {
+		if (!Number.isFinite(input)) return invalidNumber;
+		return Object.freeze({
+			kind: "valid",
+			token: Object.is(input, -0) ? "-0" : String(input),
+			value: input
+		});
+	}
+	if (typeof input !== "string") return invalidNumber;
+	const token = input.trim();
+	if (!numberToken.test(token)) return invalidNumber;
+	const value = Number(token);
+	return Number.isFinite(value) ? Object.freeze({
+		kind: "valid",
+		token,
+		value
+	}) : invalidNumber;
+}
+var StructuredDataError = class extends Error {
+	constructor(code, message) {
+		super(`${code}: ${message}`);
+		this.name = "StructuredDataError";
+		this.code = code;
+	}
+};
+function parseJson(text) {
+	try {
+		const value = JSON.parse(String(text));
+		assertJsonValue(value);
+		return value;
+	} catch (error) {
+		if (error instanceof StructuredDataError) throw error;
+		throw new StructuredDataError("INVALID_JSON", "Input must be valid JSON.");
+	}
+}
+function assertJsonValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number" && Number.isFinite(value)) return;
+	if (Array.isArray(value)) {
+		for (const item of value) assertJsonValue(item);
+		return;
+	}
+	if (typeof value === "object") {
+		for (const item of Object.values(value)) assertJsonValue(item);
+		return;
+	}
+	throw new StructuredDataError("INVALID_JSON", "JSON contains an unsupported value.");
+}
+var PARSE_LIMITS = {
+	maxInputBytes: 262144,
+	maxDepth: 64,
+	maxNodes: 5e4
+};
+function parseJsonDocument(source) {
+	validateInputSize(source);
+	const value = parseJson(source);
+	validateValueBudget(value, { nodes: 0 }, 0);
+	return value;
+}
+function parseYamlDocument(source) {
+	validateInputSize(source);
+	const lineCounter = new LineCounter();
+	const document = parseDocument(source, {
+		lineCounter,
+		prettyErrors: false,
+		schema: "core",
+		uniqueKeys: true
+	});
+	const problem = document.errors[0] ?? document.warnings[0];
+	if (problem) {
+		const { line, column } = yamlPosition(lineCounter, problem.pos[0]);
+		throw new StructuredDataError("INVALID_YAML", `${problem.code} at line ${line}, column ${column}: ${problem.message}`);
+	}
+	try {
+		return valueFromYamlNode(document.contents, { nodes: 0 }, 0, lineCounter);
+	} catch (error) {
+		if (error instanceof StructuredDataError) throw error;
+		throw new StructuredDataError("INVALID_YAML", error instanceof Error ? error.message : String(error));
+	}
+}
+function valueFromYamlNode(node, budget, depth, lineCounter) {
+	consumeBudget(budget, depth);
+	if (node === null) return null;
+	if (isAlias(node)) throw new StructuredDataError("INVALID_YAML", "YAML aliases are not allowed.");
+	if (isScalar(node)) {
+		const value = node.value;
+		if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return value;
+		throw new StructuredDataError("INVALID_YAML", "YAML contains an unsupported scalar value.");
+	}
+	if (isSeq(node)) return node.items.map((item) => valueFromYamlNode(item, budget, depth + 1, lineCounter));
+	if (isMap(node)) return Object.fromEntries(node.items.map((item) => yamlPairToEntry(item, budget, depth, lineCounter)));
+	throw new StructuredDataError("INVALID_YAML", "YAML contains an unsupported node type.");
+}
+function yamlPairToEntry(pair, budget, depth, lineCounter) {
+	if (!isScalar(pair.key) || typeof pair.key.value !== "string") throw new StructuredDataError("INVALID_YAML", "YAML map keys must be strings.");
+	return [pair.key.value, valueFromYamlNode(pair.value, budget, depth + 1, lineCounter)];
+}
+function validateValueBudget(value, budget, depth) {
+	consumeBudget(budget, depth);
+	if (Array.isArray(value)) for (const item of value) validateValueBudget(item, budget, depth + 1);
+	else if (typeof value === "object" && value !== null) for (const item of Object.values(value)) validateValueBudget(item, budget, depth + 1);
+}
+function consumeBudget(budget, depth) {
+	if (depth > PARSE_LIMITS.maxDepth) throw new StructuredDataError("PARSE_LIMIT_EXCEEDED", `Data exceeds maximum nesting depth ${PARSE_LIMITS.maxDepth}.`);
+	budget.nodes += 1;
+	if (budget.nodes > PARSE_LIMITS.maxNodes) throw new StructuredDataError("PARSE_LIMIT_EXCEEDED", `Data exceeds maximum node count ${PARSE_LIMITS.maxNodes}.`);
+}
+function validateInputSize(source) {
+	const bytes = new TextEncoder().encode(source).byteLength;
+	if (bytes > PARSE_LIMITS.maxInputBytes) throw new StructuredDataError("PARSE_LIMIT_EXCEEDED", `Input is ${bytes} bytes; maximum is ${PARSE_LIMITS.maxInputBytes}.`);
+}
+function yamlPosition(counter, offset) {
+	const position = counter.linePos(offset);
+	return {
+		line: position.line,
+		column: position.col
+	};
+}
+var sourceEditorDefinitions = [
+	{
+		editorId: "json-document-source",
+		opcodes: ["parseJson"],
+		bindings: [sourceBinding("TEXT", jsonValueSchemaBundle, parseJsonDocument)]
+	},
+	{
+		editorId: "yaml-document-source",
+		opcodes: ["parseYaml"],
+		bindings: [sourceBinding("TEXT", jsonValueSchemaBundle, parseYamlDocument, parseYamlDocument, "yaml")]
+	},
+	{
+		editorId: "json-path-value-source",
+		opcodes: ["setJsonAtPath"],
+		bindings: [sourceBinding("VALUE", jsonValueSchemaBundle, parseJson)]
+	}
+].map(({ editorId, opcodes, bindings }) => ({
+	apiVersion: 1,
+	extensionId: extensionConfig.id,
+	editorId,
+	opcodes: opcodes.map((opcode) => `${extensionConfig.id}_${opcode}`),
+	bindings,
+	validationContext: () => ({
+		consumerId: extensionConfig.id,
+		nowMs: Date.now(),
+		settings: null
+	})
+}));
+var block_editor_fixed_inputs_schema_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://kubohiroya.github.io/turbowarp-structured-data/schemas/block-editor-fixed-inputs.schema.json",
+	$defs: { "forEachAtPath": {
+		"type": "object",
+		"properties": { "MAX": {
+			"type": "integer",
+			"minimum": 1,
+			"maximum": 1e3
+		} },
+		"required": ["MAX"],
+		"additionalProperties": true
+	} }
+};
+var source = {
+	repository: "turbowarp-structured-data",
+	path: "schemas/block-editor-fixed-inputs.schema.json",
+	symbol: "#/$defs/forEachAtPath/properties/MAX"
+};
+/** The on-disk owner Schema is canonical; this is its single-field projection. */
+var fixedInputSchemaBundle = {
+	identity: {
+		ownerId: "turbowarp-structured-data",
+		contractId: "forEachAtPath.MAX",
+		revision: "fixed-inputs-v1",
+		variantId: "default"
+	},
+	dialect: "2020-12",
+	root: {
+		retrievalUri: "https://kubohiroya.github.io/turbowarp-structured-data/schemas/forEachAtPath-MAX.schema.json",
+		document: block_editor_fixed_inputs_schema_default.$defs.forEachAtPath.properties.MAX,
+		artifact: {
+			role: "canonical-schema",
+			source
+		}
+	},
+	resources: [],
+	provenance: {
+		canonicalSources: [source, {
+			repository: "turbowarp-structured-data",
+			path: "src/core.ts",
+			symbol: "iterationEntries"
+		}],
+		generatedFiles: [{
+			repository: "turbowarp-structured-data",
+			path: "docs/schemas/block-editor-fixed-inputs.schema.json"
+		}],
+		referenceSchemas: [],
+		generationSources: [{
+			repository: "turbowarp-structured-data",
+			path: "scripts/generate-fixed-input-docs.mjs"
+		}]
+	}
+};
+var fixedInputEditorDefinitions = [{
+	apiVersion: 1,
+	extensionId: extensionConfig.id,
+	editorId: "forEachAtPath-fixed-inputs",
+	opcodes: [`${extensionConfig.id}_forEachAtPath`],
+	contractId: "turbowarp-structured-data:forEachAtPath.MAX",
+	contractRevision: "fixed-inputs-v1",
+	bindings: [{
+		argument: "MAX",
+		schemaBundle: fixedInputSchemaBundle,
+		control: {
+			kind: "number",
+			label: "MAX"
+		},
+		read(value) {
+			if (typeof value !== "string" && typeof value !== "number") throw new TypeError("Expected a literal maximum.");
+			if (typeof value === "string" && value.trim() === "") throw new TypeError("Blank maximum stays readonly.");
+			const number = Number(value);
+			if (!Number.isFinite(number)) throw new TypeError("Maximum must be finite.");
+			return number;
+		},
+		encode(value) {
+			const parsed = parseFixedNumberInput(value);
+			if (parsed.kind !== "valid") throw new TypeError("Expected a finite numeric token.");
+			return parsed.token;
+		},
+		validateCandidate(value) {
+			const parsed = parseFixedNumberInput(value);
+			return parsed.kind === "valid" && Number.isInteger(parsed.value) && parsed.value >= 1 && parsed.value <= 1e3 ? [] : [{
+				path: "/inputs/MAX",
+				message: "Maximum must be an integer from 1 to 1000."
+			}];
+		}
+	}],
+	validationContext: () => ({
+		consumerId: extensionConfig.id,
+		nowMs: Date.now(),
+		settings: null
+	})
+}];
+/** Register metadata only; the GUI startup capability owns editor activation. */
+function registerFixedInputEditors(scratch, definitions, runtimeOverride) {
+	const host = scratch;
+	const api = host.gui?.blockEditors;
+	if (!definitions.length || api?.apiVersion !== 1 || typeof api.registerFixedInputEditor !== "function") return () => {};
+	const runtime = runtimeOverride ?? host.vm?.runtime;
+	const removers = [];
+	let active = true;
+	const dispose = () => {
+		if (!active) return;
+		active = false;
+		runtime?.off?.("RUNTIME_DISPOSED", dispose);
+		for (const remove of removers.splice(0).reverse()) remove();
+	};
+	try {
+		for (const definition of definitions) {
+			const remove = api.registerFixedInputEditor.call(api, definition);
+			if (typeof remove !== "function") throw new TypeError("Invalid fixed input registration disposer.");
+			removers.push(remove);
+		}
+		runtime?.on?.("RUNTIME_DISPOSED", dispose);
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+	return dispose;
+}
+export { canonicalBundle, fixedInputEditorDefinitions, fixedInputSchemaBundle, registerFixedInputEditors, registerSourceEditors, sourceBinding, sourceEditorDefinitions };

package/lib-editor/src/editor-schema.d.ts

@@ -0,0 +1,2 @@
+import type { SourceEditorOptions } from '@kubohiroya/turbowarp-extension-data-editor/schema';
+export declare const sourceEditorDefinitions: readonly SourceEditorOptions[];

package/lib-editor/src/fixed-input-editors.d.ts

@@ -0,0 +1,9 @@
+import type { FixedInputEditorOptions } from '@kubohiroya/turbowarp-extension-data-editor';
+export declare const fixedInputEditorDefinitions: readonly FixedInputEditorOptions[];
+interface RuntimeLifetime {
+    on?: (event: string, listener: () => void) => void;
+    off?: (event: string, listener: () => void) => void;
+}
+/** Register metadata only; the GUI startup capability owns editor activation. */
+export declare function registerFixedInputEditors(scratch: unknown, definitions: readonly FixedInputEditorOptions[], runtimeOverride?: RuntimeLifetime): () => void;
+export {};

package/lib-editor/src/fixed-input-schema.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaBundle } from '@kubohiroya/turbowarp-extension-data-editor/schema';
+/** The on-disk owner Schema is canonical; this is its single-field projection. */
+export declare const fixedInputSchemaBundle: SchemaBundle;

package/lib-editor/src/source-editor.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaBundle, SchemaDocument, SourceBinding, SourceEditorOptions } from '@kubohiroya/turbowarp-extension-data-editor/schema';
+export declare function canonicalBundle(ownerId: string, contractId: string, document: SchemaDocument, ownerSource: {
+    path: string;
+    symbol: string;
+}): SchemaBundle;
+export declare function sourceBinding(argument: string, bundle: SchemaBundle, read: (source: string) => unknown, check?: (source: string) => unknown, format?: 'json' | 'yaml', uiSchema?: SourceBinding['variants'][number]['uiSchema']): SourceBinding;
+/** The optional capability keeps legacy hosts and the startup flag safely inactive. */
+export declare function registerSourceEditors(scratch: unknown, definitions: readonly SourceEditorOptions[]): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubohiroya/turbowarp-structured-data",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Named structured data with JSON/YAML codecs and deterministic path operations for TurboWarp.",
   "author": "Hiroya Kubo <hiroya@cuc.ac.jp>",
   "license": "MPL-2.0",
@@ -32,7 +32,8 @@
     "README.md",
     "README.ja.md",
     "THIRD_PARTY_NOTICES.md",
-    "LICENSE"
+    "LICENSE",
+    "lib-editor/"
   ],
   "publishConfig": {
     "access": "public",
@@ -45,8 +46,8 @@
   "scripts": {
     "dev": "vite build --watch",
     "typecheck": "tsc --noEmit",
-    "build": "vite build",
-    "lint": "eslint src tests scripts vite.config.ts eslint.config.ts",
+    "build": "vite build && pnpm run build:editor",
+    "lint": "eslint src tests scripts vite.config.ts vite.editor.config.ts eslint.config.ts",
     "test": "vitest run",
     "docs": "node scripts/generate-readme.ts && node scripts/generate-fixed-input-docs.mjs",
     "docs:check": "node scripts/generate-readme.ts --check && node scripts/generate-fixed-input-docs.mjs --check",
@@ -54,12 +55,13 @@
     "repo:check": "node scripts/check-repo.ts",
     "pack:check": "npm pack --dry-run --ignore-scripts",
     "check": "pnpm run typecheck && pnpm run lint && pnpm run test && pnpm run docs:check && pnpm run check:dist && pnpm run repo:check && pnpm run pack:check",
-    "check:dist": "pnpm run build && node scripts/check-dist.ts"
+    "check:dist": "pnpm run build && node scripts/check-dist.ts",
+    "build:editor": "tsc -p tsconfig.editor.json && vite build --config vite.editor.config.ts"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.5",
     "@kubohiroya/turbowarp-extension-manifest": "0.3.2",
-    "@kubohiroya/turbowarp-named-data": "0.3.1",
+    "@kubohiroya/turbowarp-named-data": "0.4.0",
     "@kubohiroya/vite-plugin-turbowarp-extension": "0.6.1",
     "@types/node": "^24.13.3",
     "eslint": "^9.39.5",
@@ -68,19 +70,27 @@
     "typescript-eslint": "^8.66.0",
     "vite": "^8.2.2",
     "vitest": "^5.0.0",
-    "react-dom": "18.3.1"
+    "react-dom": "18.3.1",
+    "@kubohiroya/turbowarp-extension-data-editor": "0.2.1",
+    "@kubohiroya/turbowarp-named-functions": "0.1.1"
   },
   "dependencies": {
-    "yaml": "^2.9.1",
-    "@kubohiroya/turbowarp-extension-data-editor": "0.2.1"
+    "yaml": "^2.9.1"
   },
   "peerDependencies": {
-    "@kubohiroya/turbowarp-named-data": "0.3.1"
+    "@kubohiroya/turbowarp-named-data": ">=0.4.0 <1"
   },
-  "gitHead": "7429d0707e0c46099fa89d09f456a43a29919395",
+  "gitHead": "870ebcaa4071e0eacb4d36a6d9e98734e51f2361",
   "x-turbowarp-source": {
-    "revision": "7429d0707e0c46099fa89d09f456a43a29919395",
+    "revision": "870ebcaa4071e0eacb4d36a6d9e98734e51f2361",
     "revisionRole": "base-commit",
     "sourceState": "local-release-overlay"
+  },
+  "exports": {
+    "./*": "./*",
+    "./editor-metadata": {
+      "types": "./lib-editor/src/editor-metadata.d.ts",
+      "import": "./lib-editor/src/editor-metadata.js"
+    }
   }
 }