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

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');
+    }
+}

package/dist/schema-engine.d.ts

@@ -0,0 +1,18 @@
+import { Ajv } from 'ajv';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import type { SchemaBundle, SchemaCompileResult, SchemaDiagnosticScope, SchemaDocument } from './schema-types.js';
+export declare function scopeFor(value: unknown): SchemaDiagnosticScope;
+export declare function prepare(bundle: SchemaBundle, ajv: Ajv | Ajv2020): {
+    root: string;
+    resources: {
+        uri: string;
+        document: SchemaDocument;
+    }[];
+    registry: Map<string, string>;
+    nodes: {
+        node: Record<string, unknown>;
+        base: string;
+    }[];
+};
+/** Compile an isolated synchronous validator from an immutable private snapshot. */
+export declare function compileSchemaBundle(input: SchemaBundle): SchemaCompileResult;

package/dist/schema-engine.js

@@ -0,0 +1,298 @@
+import { Ajv, MissingRefError } from 'ajv';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import formats from 'ajv-formats';
+import uri from 'fast-uri';
+import { appendPointer, isJsonRecord, JsonSnapshotError, snapshotJson } from './schema-json.js';
+const DIALECT_07 = 'http://json-schema.org/draft-07/schema#';
+const DIALECT_2020 = 'https://json-schema.org/draft/2020-12/schema';
+const { parse, resolve, normalize } = uri;
+const maps = ['$defs', 'definitions', 'properties', 'patternProperties', 'dependentSchemas', 'dependencies'];
+const singles = ['additionalProperties', 'additionalItems', 'contains', 'propertyNames', 'not', 'if', 'then', 'else',
+    'unevaluatedProperties', 'unevaluatedItems', 'contentSchema'];
+const arrays = ['allOf', 'anyOf', 'oneOf', 'prefixItems'];
+class BundleError extends Error {
+    constructor(code) {
+        super('Invalid schema bundle.');
+        this.code = code;
+    }
+}
+function fail(code) { throw new BundleError(code); }
+const ownString = (value, name) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, name);
+    return descriptor && 'value' in descriptor && typeof descriptor.value === 'string' ? descriptor.value : undefined;
+};
+const freezeIdentity = (identity) => Object.freeze({ ...identity });
+export function scopeFor(value) {
+    const fallback = freezeIdentity({ ownerId: 'unknown', contractId: 'unknown', revision: 'unknown', variantId: 'default' });
+    try {
+        if (!isJsonRecord(value))
+            return Object.freeze({ identity: fallback });
+        const descriptor = Object.getOwnPropertyDescriptor(value, 'identity');
+        const id = descriptor && 'value' in descriptor ? descriptor.value : null;
+        if (!isJsonRecord(id))
+            return Object.freeze({ identity: fallback });
+        const ownerId = ownString(id, 'ownerId'), contractId = ownString(id, 'contractId');
+        const revision = ownString(id, 'revision'), variantId = ownString(id, 'variantId');
+        if (ownerId === undefined || contractId === undefined || revision === undefined || variantId === undefined)
+            return Object.freeze({ identity: fallback });
+        return Object.freeze({ identity: freezeIdentity({ ownerId, contractId, revision, variantId }) });
+    }
+    catch (_a) {
+        return Object.freeze({ identity: fallback });
+    }
+}
+function dialectFor(uri) {
+    if (typeof uri !== 'string')
+        return undefined;
+    const canonical = uri.replace(/#$/, '').replace(/^https:/, 'http:');
+    if (canonical === 'http://json-schema.org/draft-07/schema')
+        return 'draft-07';
+    if (canonical === 'http://json-schema.org/draft/2020-12/schema')
+        return '2020-12';
+    return undefined;
+}
+const normalizeUri = (uri) => normalize(uri).replace(/#$/, '');
+function absoluteUri(uri, fragments) {
+    if (typeof uri !== 'string' || !uri)
+        return fail('resource-invalid');
+    const parsed = parse(uri);
+    if (parsed.error || !parsed.scheme || (!fragments && parsed.fragment !== undefined))
+        return fail('resource-invalid');
+    return normalizeUri(uri);
+}
+function referenceKey(value) {
+    var _a;
+    if (!isJsonRecord(value) || typeof value.repository !== 'string' || typeof value.path !== 'string')
+        return fail('artifact-role-invalid');
+    for (const key of ['symbol', 'version', 'sha256'])
+        if (key in value && typeof value[key] !== 'string')
+            return fail('artifact-role-invalid');
+    return JSON.stringify([value.repository, value.path, (_a = value.symbol) !== null && _a !== void 0 ? _a : null]);
+}
+/** Check declared provenance only; paths and retrieval URIs are never fetched. */
+function validateArtifacts(bundle) {
+    const provenance = bundle.provenance;
+    if (!isJsonRecord(provenance))
+        fail('artifact-role-invalid');
+    const roles = new Map();
+    for (const role of ['canonicalSources', 'generatedFiles', 'referenceSchemas', 'generationSources']) {
+        const refs = provenance[role];
+        if (!Array.isArray(refs) || (role === 'canonicalSources' && refs.length === 0))
+            fail('artifact-role-invalid');
+        for (const ref of refs) {
+            const key = referenceKey(ref);
+            if (roles.has(key))
+                fail('artifact-role-invalid');
+            roles.set(key, role);
+        }
+    }
+    for (const resource of [bundle.root, ...bundle.resources]) {
+        if (!isJsonRecord(resource) || !isJsonRecord(resource.artifact))
+            fail('artifact-role-invalid');
+        const artifact = resource.artifact;
+        const key = referenceKey(artifact.source);
+        if (artifact.role === 'canonical-schema') {
+            if (roles.get(key) !== 'canonicalSources')
+                fail('artifact-role-invalid');
+        }
+        else if (artifact.role === 'generated-schema') {
+            if (roles.get(key) !== 'generatedFiles' || !Array.isArray(artifact.generatedFrom) || !artifact.generatedFrom.length)
+                fail('artifact-role-invalid');
+            for (const ref of artifact.generatedFrom)
+                if (roles.get(referenceKey(ref)) !== 'canonicalSources')
+                    fail('artifact-role-invalid');
+        }
+        else
+            fail('artifact-role-invalid');
+    }
+}
+export function prepare(bundle, ajv) {
+    const registry = new Map();
+    const nodes = [];
+    const register = (id, location) => {
+        const key = normalizeUri(id), previous = registry.get(key);
+        if (previous !== undefined && previous !== location)
+            fail('resource-id-conflict');
+        registry.set(key, location);
+    };
+    const resources = [];
+    const walk = (node, base, location) => {
+        if (typeof node === 'boolean')
+            return;
+        if (!isJsonRecord(node))
+            return;
+        if ('$schema' in node) {
+            const dialect = dialectFor(node.$schema);
+            if (!dialect)
+                fail('dialect-unsupported');
+            if (dialect !== bundle.dialect)
+                fail('dialect-conflict');
+            // Canonicalize identifiers in the private snapshot, never in the owner's document.
+            node.$schema = dialect === 'draft-07' ? DIALECT_07 : DIALECT_2020;
+        }
+        if ('$id' in node) {
+            if (typeof node.$id !== 'string')
+                fail('schema-invalid');
+            base = absoluteUri(resolve(base, node.$id), true);
+            register(base, location);
+            node.$id = base;
+        }
+        for (const key of ['$anchor', '$dynamicAnchor'])
+            if (typeof node[key] === 'string')
+                register(`${base.replace(/#.*$/, '')}#${node[key]}`, location);
+        nodes.push({ node, base });
+        if (node.$async === true)
+            fail('schema-invalid');
+        if (typeof node.format === 'string' && !ajv.formats[node.format])
+            fail('schema-invalid');
+        for (const key of maps)
+            if (isJsonRecord(node[key])) {
+                for (const [name, child] of Object.entries(node[key]))
+                    if (typeof child === 'boolean' || isJsonRecord(child))
+                        walk(child, base, appendPointer(appendPointer(location, key), name));
+            }
+        for (const key of singles)
+            if (typeof node[key] === 'boolean' || isJsonRecord(node[key]))
+                walk(node[key], base, `${location}/${key}`);
+        for (const key of [...arrays, 'items']) {
+            const children = node[key];
+            if (Array.isArray(children))
+                children.forEach((child, index) => walk(child, base, `${location}/${key}/${index}`));
+            else if (key === 'items' && (typeof children === 'boolean' || isJsonRecord(children)))
+                walk(children, base, `${location}/${key}`);
+        }
+    };
+    const supplied = [bundle.root, ...bundle.resources];
+    for (let index = 0; index < supplied.length; index++) {
+        const resource = supplied[index];
+        if (!isJsonRecord(resource) || (typeof resource.document !== 'boolean' && !isJsonRecord(resource.document)))
+            fail('resource-invalid');
+        const uri = absoluteUri(resource.retrievalUri, false);
+        register(uri, `${index}`);
+        walk(resource.document, uri, `${index}`);
+        resources.push({ uri, document: resource.document });
+    }
+    // Use retrieval-URI pointers in private refs so Ajv emits unambiguous pointer diagnostics,
+    // including refs originally written as relative resource names or anchors.
+    for (const { node, base } of nodes)
+        if (typeof node.$ref === 'string') {
+            const absolute = normalizeUri(resolve(base, node.$ref));
+            let location = registry.get(absolute);
+            if (location === undefined) {
+                const hash = absolute.indexOf('#');
+                const resource = registry.get(hash < 0 ? absolute : absolute.slice(0, hash));
+                const fragment = hash < 0 ? '' : decodeURIComponent(absolute.slice(hash + 1));
+                if (resource !== undefined && (fragment === '' || fragment.startsWith('/')))
+                    location = resource + fragment;
+            }
+            if (location !== undefined) {
+                const slash = location.indexOf('/'), index = Number(slash < 0 ? location : location.slice(0, slash));
+                node.$ref = resources[index].uri + '#' + encodeURIComponent(slash < 0 ? '' : location.slice(slash)).replace(/%2F/g, '/');
+            }
+            else
+                node.$ref = absolute.includes('#') ? absolute : absolute + '#';
+        }
+    return { root: resources[0].uri, resources, registry, nodes };
+}
+function structuralDiagnostics(errors, scope, rootUri) {
+    return Object.freeze(errors.map(error => {
+        let dataPath = error.instancePath;
+        if (error.keyword === 'required' && typeof error.params.missingProperty === 'string')
+            dataPath = appendPointer(dataPath, error.params.missingProperty);
+        if (error.keyword === 'additionalProperties' && typeof error.params.additionalProperty === 'string')
+            dataPath = appendPointer(dataPath, error.params.additionalProperty);
+        const hash = error.schemaPath.indexOf('#');
+        const resourceUri = hash > 0 ? error.schemaPath.slice(0, hash) : rootUri;
+        const schemaPath = decodeURIComponent(hash >= 0 ? error.schemaPath.slice(hash + 1) : error.schemaPath);
+        return Object.freeze({ scope, phase: 'structure', code: 'schema-data-invalid', dataPath, schemaPath, resourceUri, keyword: error.keyword });
+    }));
+}
+function makeValidator(validate, scope, dialect, rootUri) {
+    return Object.freeze({ identity: scope.identity, dialect, validate(data, context) {
+            var _a;
+            let currentScope = scope;
+            try {
+                if (context !== undefined) {
+                    if (!isJsonRecord(context))
+                        throw new Error();
+                    const consumerId = ownString(context, 'consumerId');
+                    if (consumerId === undefined)
+                        throw new Error();
+                    currentScope = Object.freeze({ ...scope, consumerId });
+                }
+                const input = snapshotJson(data);
+                if (validate(input))
+                    return Object.freeze({ kind: 'valid', diagnostics: Object.freeze([]) });
+                const diagnostics = structuralDiagnostics((_a = validate.errors) !== null && _a !== void 0 ? _a : [], currentScope, rootUri);
+                if (!diagnostics.length)
+                    throw new Error();
+                return Object.freeze({ kind: 'invalid', diagnostics: diagnostics });
+            }
+            catch (error) {
+                if (error instanceof JsonSnapshotError && error.kind === 'invalid')
+                    return Object.freeze({ kind: 'invalid', diagnostics: Object.freeze([
+                            Object.freeze({ scope: currentScope, phase: 'structure', code: 'input-not-json', dataPath: error.dataPath })
+                        ]) });
+                return Object.freeze({ kind: 'execution-error', diagnostics: Object.freeze([Object.freeze({ scope: currentScope, phase: 'execution', operation: 'structure',
+                            code: error instanceof JsonSnapshotError && error.kind === 'limit' || error instanceof RangeError ? 'limit-exceeded' : 'engine-failed' })]) });
+            }
+        } });
+}
+/** Compile an isolated synchronous validator from an immutable private snapshot. */
+export function compileSchemaBundle(input) {
+    const scope = scopeFor(input);
+    try {
+        if (!isJsonRecord(input))
+            fail('resource-invalid');
+        const declaredDialect = Object.getOwnPropertyDescriptor(input, 'dialect');
+        if (!declaredDialect || 'value' in declaredDialect && declaredDialect.value === undefined)
+            fail('dialect-required');
+        if (!('value' in declaredDialect))
+            fail('resource-invalid');
+        if (declaredDialect.value !== 'draft-07' && declaredDialect.value !== '2020-12')
+            fail('dialect-unsupported');
+        const candidate = snapshotJson(input);
+        if (!isJsonRecord(candidate) || !isJsonRecord(candidate.identity))
+            fail('resource-invalid');
+        for (const key of ['ownerId', 'contractId', 'revision', 'variantId'])
+            if (typeof candidate.identity[key] !== 'string')
+                fail('resource-invalid');
+        if (!candidate.dialect)
+            fail('dialect-required');
+        if (candidate.dialect !== 'draft-07' && candidate.dialect !== '2020-12')
+            fail('dialect-unsupported');
+        if (!Array.isArray(candidate.resources) || !isJsonRecord(candidate.root))
+            fail('resource-invalid');
+        const bundle = candidate;
+        validateArtifacts(bundle);
+        const options = { allErrors: true, coerceTypes: false, useDefaults: false, removeAdditional: false,
+            strict: false, logger: false, ownProperties: true };
+        const ajv = bundle.dialect === 'draft-07' ? new Ajv(options) : new Ajv2020(options);
+        formats.default(ajv);
+        const prepared = prepare(bundle, ajv);
+        for (const resource of prepared.resources) {
+            if (!ajv.validateSchema(resource.document))
+                fail('schema-invalid');
+            ajv.addSchema(resource.document, resource.uri);
+        }
+        const validate = ajv.getSchema(prepared.root);
+        if (!validate || ('$async' in validate && validate.$async))
+            fail('schema-invalid');
+        return Object.freeze({ kind: 'compiled', validator: makeValidator(validate, scope, bundle.dialect, prepared.root), diagnostics: Object.freeze([]) });
+    }
+    catch (error) {
+        let code;
+        if (error instanceof BundleError)
+            code = error.code;
+        else if (error instanceof MissingRefError)
+            code = 'ref-unresolved';
+        else if (error instanceof JsonSnapshotError && error.kind === 'invalid')
+            code = 'resource-invalid';
+        else if (error instanceof SyntaxError)
+            code = 'schema-invalid';
+        if (code)
+            return Object.freeze({ kind: 'schema-error', diagnostics: Object.freeze([Object.freeze({ scope, phase: 'compile', code })]) });
+        return Object.freeze({ kind: 'execution-error', diagnostics: Object.freeze([Object.freeze({ scope, phase: 'execution', operation: 'compile',
+                    code: error instanceof JsonSnapshotError && error.kind === 'limit' || error instanceof RangeError ? 'limit-exceeded' : 'engine-failed' })]) });
+    }
+}

package/dist/schema-json.d.ts

@@ -0,0 +1,10 @@
+import type { JsonPointer, SchemaJsonValue } from './schema-types.js';
+export declare class JsonSnapshotError extends Error {
+    readonly kind: 'invalid' | 'limit';
+    readonly dataPath: JsonPointer;
+    constructor(kind: 'invalid' | 'limit', dataPath: JsonPointer);
+}
+export declare function appendPointer(path: string, key: string): JsonPointer;
+/** Copy JSON values without invoking accessors, toJSON, or input iterators. */
+export declare function snapshotJson(value: unknown): SchemaJsonValue;
+export declare function isJsonRecord(value: unknown): value is Record<string, unknown>;

package/dist/schema-json.js

@@ -0,0 +1,68 @@
+export class JsonSnapshotError extends Error {
+    constructor(kind, dataPath) {
+        super('JSON snapshot failed.');
+        this.kind = kind;
+        this.dataPath = dataPath;
+    }
+}
+export function appendPointer(path, key) {
+    return `${path}/${key.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+}
+/** Copy JSON values without invoking accessors, toJSON, or input iterators. */
+export function snapshotJson(value) {
+    const active = new WeakSet();
+    let remaining = 100000;
+    const visit = (input, path, depth) => {
+        if (--remaining < 0 || depth > 128)
+            throw new JsonSnapshotError('limit', path);
+        if (input === null || typeof input === 'string' || typeof input === 'boolean')
+            return input;
+        if (typeof input === 'number' && Number.isFinite(input))
+            return input;
+        if (typeof input !== 'object' || input === null || active.has(input))
+            throw new JsonSnapshotError('invalid', path);
+        const array = Array.isArray(input);
+        const prototype = Object.getPrototypeOf(input);
+        if (!array && prototype !== null && prototype !== Object.prototype)
+            throw new JsonSnapshotError('invalid', path);
+        if (Object.getOwnPropertySymbols(input).length)
+            throw new JsonSnapshotError('invalid', path);
+        active.add(input);
+        try {
+            if (array) {
+                const length = input.length;
+                if (!Number.isSafeInteger(length) || length > remaining)
+                    throw new JsonSnapshotError('limit', path);
+                const result = [];
+                for (let i = 0; i < length; i++) {
+                    const child = appendPointer(path, String(i));
+                    const descriptor = Object.getOwnPropertyDescriptor(input, i);
+                    if (!descriptor || !('value' in descriptor))
+                        throw new JsonSnapshotError('invalid', child);
+                    result.push(visit(descriptor.value, child, depth + 1));
+                }
+                for (const key of Object.keys(input)) {
+                    if (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= length)
+                        throw new JsonSnapshotError('invalid', appendPointer(path, key));
+                }
+                return result;
+            }
+            const result = {};
+            for (const key of Object.keys(input)) {
+                const child = appendPointer(path, key);
+                const descriptor = Object.getOwnPropertyDescriptor(input, key);
+                if (!descriptor || !('value' in descriptor))
+                    throw new JsonSnapshotError('invalid', child);
+                Object.defineProperty(result, key, { value: visit(descriptor.value, child, depth + 1), enumerable: true, writable: true, configurable: true });
+            }
+            return result;
+        }
+        finally {
+            active.delete(input);
+        }
+    };
+    return visit(value, '', 0);
+}
+export function isJsonRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/schema-types.d.ts

@@ -0,0 +1,161 @@
+export interface ValidationIssue {
+    readonly message: string;
+    readonly path?: string;
+}
+export type NonEmpty<T> = readonly [T, ...T[]];
+export type JsonPointer = '' | `/${string}`;
+export type SchemaDialect = 'draft-07' | '2020-12';
+export type SchemaJsonValue = null | string | number | boolean | readonly SchemaJsonValue[] | {
+    readonly [key: string]: SchemaJsonValue;
+};
+export type SchemaJsonObject = {
+    readonly [key: string]: SchemaJsonValue;
+};
+export type SchemaDocument = boolean | SchemaJsonObject;
+export type JsonSettings<T> = T extends null | string | number | boolean ? T : T extends (...args: never[]) => unknown ? never : T extends abstract new (...args: never[]) => unknown ? never : T extends readonly unknown[] ? {
+    readonly [K in keyof T]: JsonSettings<T[K]>;
+} : T extends object ? {
+    readonly [K in keyof T]: JsonSettings<T[K]>;
+} : never;
+export interface SchemaIdentity {
+    readonly ownerId: string;
+    readonly contractId: string;
+    readonly revision: string;
+    readonly variantId: string;
+}
+export interface SchemaSourceReference {
+    readonly repository: string;
+    readonly path: string;
+    readonly symbol?: string;
+    readonly version?: string;
+    readonly sha256?: string;
+}
+export interface SchemaProvenance {
+    readonly canonicalSources: NonEmpty<SchemaSourceReference>;
+    readonly generatedFiles: readonly SchemaSourceReference[];
+    readonly referenceSchemas: readonly SchemaSourceReference[];
+    readonly generationSources: readonly SchemaSourceReference[];
+}
+export type SchemaArtifact = {
+    readonly role: 'canonical-schema';
+    readonly source: SchemaSourceReference;
+} | {
+    readonly role: 'generated-schema';
+    readonly source: SchemaSourceReference;
+    readonly generatedFrom: NonEmpty<SchemaSourceReference>;
+};
+export interface SchemaResource {
+    readonly retrievalUri: string;
+    readonly document: SchemaDocument;
+    readonly artifact: SchemaArtifact;
+}
+export interface SchemaBundle {
+    readonly identity: SchemaIdentity;
+    readonly dialect: SchemaDialect;
+    readonly root: SchemaResource;
+    readonly resources: readonly SchemaResource[];
+    readonly provenance: SchemaProvenance;
+}
+export interface SchemaDiagnosticScope {
+    readonly identity: SchemaIdentity;
+    readonly consumerId?: string;
+}
+export interface SchemaDiagnosticBase {
+    readonly scope: SchemaDiagnosticScope;
+    readonly resourceUri?: string;
+    readonly schemaPath?: JsonPointer;
+}
+export type CompileDiagnosticCode = 'dialect-required' | 'dialect-unsupported' | 'dialect-conflict' | 'resource-invalid' | 'resource-id-conflict' | 'ref-unresolved' | 'schema-invalid' | 'artifact-role-invalid';
+export type CompileDiagnostic = SchemaDiagnosticBase & {
+    readonly phase: 'compile';
+    readonly code: CompileDiagnosticCode;
+};
+export type InputDiagnostic = SchemaDiagnosticBase & ({
+    readonly phase: 'decode';
+    readonly code: 'input-format-invalid' | 'variant-unrecognized';
+    readonly dataPath: JsonPointer;
+} | {
+    readonly phase: 'structure';
+    readonly code: 'input-not-json' | 'schema-data-invalid';
+    readonly dataPath: JsonPointer;
+    readonly keyword?: string;
+} | {
+    readonly phase: 'semantic';
+    readonly code: 'owner-input-invalid';
+    readonly dataPath: JsonPointer;
+    readonly ruleId: string;
+});
+export type CompileExecutionDiagnostic = SchemaDiagnosticBase & {
+    readonly phase: 'execution';
+    readonly operation: 'compile';
+    readonly code: 'engine-failed' | 'limit-exceeded';
+};
+export type DecodeExecutionDiagnostic = SchemaDiagnosticBase & {
+    readonly phase: 'execution';
+    readonly operation: 'decode';
+    readonly code: 'engine-failed' | 'limit-exceeded';
+};
+export type StructuralExecutionDiagnostic = SchemaDiagnosticBase & {
+    readonly phase: 'execution';
+    readonly operation: 'structure';
+    readonly code: 'engine-failed' | 'limit-exceeded';
+};
+export type OwnerExecutionDiagnostic = SchemaDiagnosticBase & {
+    readonly phase: 'execution';
+    readonly operation: 'semantic';
+    readonly code: 'owner-validation-failed' | 'owner-context-invalid' | 'async-owner-unsupported' | 'owner-result-invalid' | 'engine-failed' | 'limit-exceeded';
+};
+export type ExecutionDiagnostic = CompileExecutionDiagnostic | DecodeExecutionDiagnostic | StructuralExecutionDiagnostic | OwnerExecutionDiagnostic;
+export type ValidationExecutionDiagnostic = DecodeExecutionDiagnostic | StructuralExecutionDiagnostic | OwnerExecutionDiagnostic;
+export type SchemaDiagnostic = CompileDiagnostic | InputDiagnostic | ExecutionDiagnostic;
+export type SchemaValidationResult<D extends InputDiagnostic = InputDiagnostic, E extends ValidationExecutionDiagnostic = ValidationExecutionDiagnostic> = {
+    readonly kind: 'valid';
+    readonly diagnostics: readonly [];
+} | {
+    readonly kind: 'invalid';
+    readonly diagnostics: NonEmpty<D>;
+} | {
+    readonly kind: 'execution-error';
+    readonly diagnostics: NonEmpty<E>;
+};
+export type StructuralValidationResult = SchemaValidationResult<Extract<InputDiagnostic, {
+    phase: 'structure';
+}>, StructuralExecutionDiagnostic>;
+export type SchemaInputValidationResult = SchemaValidationResult<Extract<InputDiagnostic, {
+    phase: 'structure' | 'semantic';
+}>, StructuralExecutionDiagnostic | OwnerExecutionDiagnostic>;
+export interface CompiledSchema {
+    readonly identity: SchemaIdentity;
+    readonly dialect: SchemaDialect;
+    readonly validate: (data: SchemaJsonValue, context?: {
+        readonly consumerId: string;
+    }) => StructuralValidationResult;
+}
+export type SchemaCompileResult = {
+    readonly kind: 'compiled';
+    readonly validator: CompiledSchema;
+    readonly diagnostics: readonly [];
+} | {
+    readonly kind: 'schema-error';
+    readonly diagnostics: NonEmpty<CompileDiagnostic>;
+} | {
+    readonly kind: 'execution-error';
+    readonly diagnostics: NonEmpty<CompileExecutionDiagnostic>;
+};
+export interface SchemaValidationContext<C = null> {
+    readonly consumerId: string;
+    readonly nowMs: number;
+    readonly settings: JsonSettings<C>;
+}
+export interface OwnerInputIssue {
+    readonly dataPath: JsonPointer;
+    readonly ruleId: string;
+}
+export type OwnerValidationResult = {
+    readonly kind: 'valid';
+    readonly issues: readonly [];
+} | {
+    readonly kind: 'invalid';
+    readonly issues: NonEmpty<OwnerInputIssue>;
+};
+export type SyncOwnerValidator<C = null> = (data: SchemaJsonValue, context: SchemaValidationContext<C>) => OwnerValidationResult;

package/dist/schema-types.js

@@ -0,0 +1,2 @@
+// Shared schema contracts. Engine and owner composition implementations are provided separately.
+export {};