@kubohiroya/turbowarp-structured-data 0.6.1 → 0.6.3

package/src/config.ts

@@ -1,5 +1,16 @@
 export const STRUCTURED_DATA_MVP_DEFAULT = false;
 export const NAMED_DATA_REGISTRY_MVP_DEFAULT = false;
+export const NAMED_DATA_SCHEMA_REF_DEFAULT = false;
+
+export function isNamedDataSchemaRefEnabled(
+  source: {__TW_NAMED_DATA_FEATURE_FLAGS__?: {NAMED_DATA_SCHEMA_REF?: unknown}} =
+    globalThis as {__TW_NAMED_DATA_FEATURE_FLAGS__?: {NAMED_DATA_SCHEMA_REF?: unknown}}
+): boolean {
+  const value = source.__TW_NAMED_DATA_FEATURE_FLAGS__?.NAMED_DATA_SCHEMA_REF;
+  return value === undefined
+    ? NAMED_DATA_SCHEMA_REF_DEFAULT
+    : value === true || value === 'true';
+}
 
 export function isStructuredDataMvpEnabled(
   source: {STRUCTURED_DATA_MVP?: unknown} = globalThis as {STRUCTURED_DATA_MVP?: unknown}

package/src/editor-metadata.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/src/fixed-input-schema.ts

@@ -1,5 +1,5 @@
 import type {SchemaBundle} from '@kubohiroya/turbowarp-extension-data-editor/schema';
-import document from '../schemas/block-editor-fixed-inputs.schema.json';
+import document from '../schemas/block-editor-fixed-inputs.schema.json' with {type: 'json'};
 
 const source = {repository: 'turbowarp-structured-data', path: 'schemas/block-editor-fixed-inputs.schema.json',
   symbol: '#/$defs/forEachAtPath/properties/MAX'};

package/src/source-editor.ts

@@ -1,4 +1,3 @@
-import {compileSchemaBundle, validateSchemaInput} from '@kubohiroya/turbowarp-extension-data-editor/schema';
 import type {SchemaBundle, SchemaDocument, SchemaJsonValue, SourceBinding, SourceEditorOptions} from '@kubohiroya/turbowarp-extension-data-editor/schema';
 
 export function canonicalBundle(ownerId: string, contractId: string, document: SchemaDocument, ownerSource: {path: string; symbol: string}): SchemaBundle {
@@ -16,21 +15,25 @@ export function canonicalBundle(ownerId: string, contractId: string, document: S
 export function sourceBinding(argument: string, bundle: SchemaBundle,
   read: (source: string) => unknown, check: (source: string) => unknown = read,
   format: 'json' | 'yaml' = 'json', uiSchema?: SourceBinding['variants'][number]['uiSchema']): SourceBinding {
-  const compiled = compileSchemaBundle(bundle);
   return {
     argument,
     variants: [{variantId: 'default', format, schemaBundle: bundle, ...(uiSchema ? {uiSchema} : {})}],
     decode(source) {return {source, format, variantId: 'default', data: read(source) as SchemaJsonValue};},
     validateSource(source, context) {
-      if (compiled.kind !== 'compiled') return {source, result: {kind: 'schema-error', diagnostics: [{code: 'source-schema-invalid'}]}};
+      try {read(source);}
+      catch {return {source, result: {kind: 'invalid', diagnostics: [{code: 'source-decode-invalid'}]}};}
       try {
-        const data = read(source) as SchemaJsonValue;
-        return {source, result: validateSchemaInput(compiled.validator, data, {context,
-          ownerValidate: () => {
-            try {check(source); return {kind: 'valid', issues: []};}
-            catch {return {kind: 'invalid', issues: [{dataPath: '', ruleId: 'source-owner-invalid'}]};}
-          }})};
-      } catch {return {source, result: {kind: 'invalid', diagnostics: [{code: 'source-decode-invalid'}]}};}
+        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'}]}};}
+      // The GUI checks Schema constraints; the owner checks the exact source without compiling.
+      try {check(source);}
+      catch {return {source, result: {kind: 'invalid', diagnostics: [{code: 'source-owner-invalid'}]}};}
+      return {source, result: {kind: 'valid', diagnostics: []}};
     }
   };
 }

package/src/structured-provider.ts

@@ -1,4 +1,5 @@
 import {renderJsonDocument, renderYamlDocument} from './codecs.js';
+import {isNamedDataSchemaRefEnabled} from './config.js';
 import type {JsonValue} from './core.js';
 import {
   NamedDataError,
@@ -6,6 +7,7 @@ import {
   type NamedDataMetadata,
   type NamedDataProvider,
   type NamedDataReference,
+  type NamedDataSchemaRef,
   type NamedDataRepresentation,
   type NamedDataResolveContext
 } from '@kubohiroya/turbowarp-named-data/composition';
@@ -17,6 +19,7 @@ export interface StructuredDataBinding {
   value: JsonValue;
   revision: number;
   nativeRepresentation: 'json' | 'yaml';
+  schemaRef?: NamedDataSchemaRef;
 }
 
 export interface StructuredDataBindingStore {
@@ -31,7 +34,8 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
 
   public constructor(
     private readonly store: StructuredDataBindingStore,
-    private readonly maxBodyBytes = STRUCTURED_BODY_MAX_BYTES
+    private readonly maxBodyBytes = STRUCTURED_BODY_MAX_BYTES,
+    private readonly schemaRefEnabled = isNamedDataSchemaRefEnabled()
   ) {}
 
   public canResolve(
@@ -57,7 +61,8 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
       resolved.nativeRepresentation,
       representation,
       resolved.bytes.byteLength,
-      resolved.revision
+      resolved.revision,
+      resolved.schemaRef
     );
   }
 
@@ -76,7 +81,8 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
         resolved.nativeRepresentation,
         representation,
         resolved.bytes.byteLength,
-        resolved.revision
+        resolved.revision,
+        resolved.schemaRef
       ),
       body: resolved.bytes,
       release: () => {
@@ -100,7 +106,12 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
     reference: NamedDataReference,
     representation: NamedDataRepresentation,
     context: NamedDataResolveContext
-  ): {bytes: Uint8Array; revision: number; nativeRepresentation: 'json' | 'yaml'} {
+  ): {
+    bytes: Uint8Array;
+    revision: number;
+    nativeRepresentation: 'json' | 'yaml';
+    schemaRef?: NamedDataSchemaRef;
+  } {
     if (this.released) {
       throw new NamedDataError('NAMED_DATA_PROVIDER_RELEASED', 'The structured provider was released.');
     }
@@ -113,6 +124,23 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
         `Structured data does not exist: ${reference.name}`
       );
     }
+    const requestedSchemaRef = reference.schemaRef;
+    if (requestedSchemaRef !== undefined && !this.schemaRefEnabled) {
+      throw new NamedDataError(
+        'NAMED_DATA_SCHEMA_UNRESOLVED',
+        'Schema reference resolution is disabled.'
+      );
+    }
+    if (
+      requestedSchemaRef !== undefined &&
+      (binding.schemaRef?.id !== requestedSchemaRef.id ||
+        binding.schemaRef?.version !== requestedSchemaRef.version)
+    ) {
+      throw new NamedDataError(
+        'NAMED_DATA_SCHEMA_VERSION_MISMATCH',
+        'Binding schemaRef does not match the requested reference.'
+      );
+    }
     const text = this.render(binding.value, representation);
     const bytes = new TextEncoder().encode(text);
     if (bytes.byteLength > this.maxBodyBytes) {
@@ -125,7 +153,8 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
     return {
       bytes,
       revision: binding.revision,
-      nativeRepresentation: binding.nativeRepresentation
+      nativeRepresentation: binding.nativeRepresentation,
+      ...(requestedSchemaRef === undefined ? {} : {schemaRef: binding.schemaRef})
     };
   }
 
@@ -164,7 +193,8 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
     nativeRepresentation: 'json' | 'yaml',
     representation: NamedDataRepresentation,
     byteLength: number,
-    revision: number
+    revision: number,
+    schemaRef?: NamedDataSchemaRef
   ): NamedDataMetadata {
     return {
       reference: {...reference},
@@ -176,7 +206,8 @@ export class StructuredDataNamedDataProvider implements NamedDataProvider {
           : 'application/yaml; charset=utf-8',
       byteLength,
       revision: String(revision),
-      replayable: true
+      replayable: true,
+      ...(schemaRef === undefined ? {} : {schemaRef})
     };
   }