@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.40

package/dist/v1/schema/validation/policy/typing.js

@@ -0,0 +1,347 @@
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { branchesOf, branchProduct, capBranches, targetMode, termKey, } from '../../../language/policy/analysis/branches.js';
+import { MAX_REPEAT } from './budgets.js';
+import { escapePointer } from './context.js';
+import { referenceContracts } from './objects.js';
+export class PolicyTyping {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    validatePolicies() {
+        for (const name of Object.keys(this.context.environment.candidate.policies)) {
+            const branches = this.#expandedBranches(name, new Set(), `$${name}`);
+            if (branches === undefined)
+                continue;
+            for (const [index, branch] of branches.entries()) {
+                const mode = targetMode(branch);
+                if (mode === undefined) {
+                    if (!('match' in this.context.environment.candidate.policies[name].expression)) {
+                        this.context.add('PL_TARGET', `/policies/${escapePointer(name)}`, `Expanded normalized branch ${index} must use object or at least one of source and target, without mixing target modes.`);
+                    }
+                    continue;
+                }
+                const use = mode === 'object'
+                    ? { kind: 'object', object: { kind: 'default' } }
+                    : {
+                        kind: 'edge',
+                        source: { kind: 'default' },
+                        target: { kind: 'default' },
+                    };
+                if (!this.#branchIsTyped(branch, use)) {
+                    this.context.add('PL_TYPING', `/policies/${escapePointer(name)}`, `Expanded normalized branch ${index} has contradictory endpoint or repeat contracts.`);
+                }
+            }
+        }
+    }
+    policyAccepts(name, object) {
+        const branches = this.#expandedBranches(name, new Set(), `$use:${name}`);
+        const use = { kind: 'object', object };
+        return branches !== undefined && branches.every((branch) => this.#branchIsTyped(branch, use));
+    }
+    policyAcceptsEdge(name, source, target) {
+        const branches = this.#expandedBranches(name, new Set(), `$edge-use:${name}`);
+        const use = { kind: 'edge', source, target };
+        return branches !== undefined && branches.every((branch) => this.#branchIsTyped(branch, use));
+    }
+    concreteEndpointClasses(accepts) {
+        return this.context.concreteNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, accepts));
+    }
+    endpointsOverlap(left, right) {
+        const seed = [{ kind: 'open', requirements: [] }];
+        const afterLeft = this.#applyEndpoint(seed, left);
+        return this.#applyEndpoint(afterLeft, right).length > 0;
+    }
+    #expandedBranches(name, visiting, namespace) {
+        if (visiting.has(name))
+            return undefined;
+        const declaration = this.context.normalized.get(name);
+        if (declaration === undefined)
+            return undefined;
+        if ('match' in declaration)
+            return branchesOf(declaration.match, namespace);
+        const nested = new Set(visiting);
+        nested.add(name);
+        const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+        const children = [];
+        for (const [index, ref] of refs.entries()) {
+            if (!this.context.isLocalPolicy(ref))
+                return undefined;
+            const expanded = this.#expandedBranches(ref.name, nested, `${namespace}/${index}:${ref.name}`);
+            if (expanded === undefined)
+                return undefined;
+            children.push(expanded);
+        }
+        return 'allOf' in declaration ? branchProduct(children) : capBranches(children.flat());
+    }
+    #branchIsTyped(branch, use) {
+        if (targetMode(branch) !== use.kind)
+            return false;
+        const alternatives = edgeAlternatives(branch.edges, this);
+        return alternatives.some((variants) => this.#constraintsAreSatisfiable(branch, variants, use));
+    }
+    #constraintsAreSatisfiable(branch, variants, use) {
+        const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+        for (const key of branch.variables.keys())
+            terms.add(key);
+        for (const key of branch.terms.keys())
+            terms.add(key);
+        for (const edge of branch.edges) {
+            terms.add(termKey(edge.pattern.source, edge.namespace));
+            terms.add(termKey(edge.pattern.target, edge.namespace));
+        }
+        const union = new UnionFind(terms);
+        for (const [left, right] of branch.equalities)
+            union.join(left, right);
+        for (const variant of variants) {
+            for (const [left, right] of variant.equalities)
+                union.join(left, right);
+        }
+        const constraints = new Map();
+        for (const variant of variants) {
+            for (const [term, accepts] of variant.constraints) {
+                const root = union.find(term);
+                const values = constraints.get(root) ?? [];
+                values.push(accepts);
+                constraints.set(root, values);
+            }
+        }
+        const groups = new Map();
+        for (const term of terms) {
+            const root = union.find(term);
+            const members = groups.get(root) ?? [];
+            members.push(term);
+            groups.set(root, members);
+        }
+        for (const [root, members] of groups) {
+            const endpointConstraints = constraints.get(root) ?? [];
+            let candidates = [{ kind: 'open', requirements: [] }];
+            for (const member of members) {
+                candidates = this.#applyInitial(candidates, member, branch, use);
+                if (candidates.length === 0)
+                    return false;
+            }
+            for (const endpoint of endpointConstraints) {
+                candidates = this.#applyEndpoint(candidates, endpoint);
+                if (candidates.length === 0)
+                    return false;
+            }
+        }
+        return true;
+    }
+    #applyInitial(candidates, term, branch, use) {
+        if (term === 'subject')
+            return this.#applyAnyNodeClass(candidates);
+        const contract = targetContract(term, use);
+        if (contract !== undefined) {
+            if (contract.kind === 'exact')
+                return this.#applyExact(candidates, contract.ref);
+            if (contract.kind === 'default') {
+                return uniqueCandidates(this.context.allNodeClasses.flatMap((ref) => this.#applyExact(candidates, ref)));
+            }
+            return candidates;
+        }
+        const referenced = branch.terms.get(term);
+        if (referenced?.kind === 'ref') {
+            const contract = referenceContracts(this.context, referenced.ref, '/policies')?.[0];
+            return contract?.kind === 'exact' ? this.#applyExact(candidates, contract.ref) : [];
+        }
+        const selector = branch.variables.get(term);
+        if (selector === undefined)
+            return [];
+        if (selector.kind === 'exact')
+            return this.#applyExact(candidates, selector.class);
+        if (selector.kind === 'any')
+            return candidates;
+        return this.#applyRequirement(candidates, selector.class);
+    }
+    #applyExact(candidates, exact) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
+                    result.push(candidate);
+            }
+            else if (candidate.requirements.every((required) => this.context.classExtends(exact, required))) {
+                result.push({ kind: 'exact', ref: exact });
+            }
+        }
+        return uniqueCandidates(result);
+    }
+    #applyAnyNodeClass(candidates) {
+        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
+            ? [candidate]
+            : this.context.allNodeClasses
+                .filter((ref) => candidate.requirements.every((required) => this.context.classExtends(ref, required)))
+                .map((ref) => ({ kind: 'exact', ref }))));
+    }
+    #applyRequirement(candidates, required) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (this.context.classExtends(candidate.ref, required))
+                    result.push(candidate);
+            }
+            else {
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueClasses([...candidate.requirements, required]),
+                });
+            }
+        }
+        return uniqueCandidates(result);
+    }
+    #applyEndpoint(candidates, accepts) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (this.#classSatisfiesEndpoint(candidate.ref, accepts))
+                    result.push(candidate);
+                continue;
+            }
+            for (const accept of accepts) {
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueClasses([...candidate.requirements, accept]),
+                });
+            }
+        }
+        return uniqueCandidates(result);
+    }
+    #classSatisfiesEndpoint(candidate, accepts) {
+        return accepts.some((accept) => this.context.classExtends(candidate, accept));
+    }
+}
+function targetContract(term, use) {
+    if (use.kind === 'object')
+        return term === 'object' ? use.object : undefined;
+    if (term === 'source')
+        return use.source;
+    if (term === 'target')
+        return use.target;
+    return undefined;
+}
+export function contractOfNodeDefinition(ref) {
+    return { kind: 'exact', ref };
+}
+function edgeAlternatives(edges, typing) {
+    let result = [[]];
+    for (const edge of edges) {
+        const variants = variantsForEdge(edge, typing);
+        if (variants.length === 0)
+            return [];
+        const next = [];
+        for (const prefix of result) {
+            for (const variant of variants)
+                next.push([...prefix, variant]);
+        }
+        result = next;
+    }
+    return result;
+}
+function variantsForEdge(use, typing) {
+    const edge = use.pattern;
+    const declaration = typing.context.edgeDeclaration(edge.class);
+    if (declaration === undefined)
+        return [];
+    const endpoints = declaration.orientation === 'directed'
+        ? [declaration.endpoints.source, declaration.endpoints.target]
+        : declaration.endpoints;
+    const bounds = edge.repeat ?? { min: 1, max: 1 };
+    if (!Number.isInteger(bounds.min) ||
+        !Number.isInteger(bounds.max) ||
+        bounds.min < 0 ||
+        bounds.max < bounds.min ||
+        bounds.max > MAX_REPEAT) {
+        return [];
+    }
+    const sourceKey = termKey(edge.source, use.namespace);
+    const targetKey = termKey(edge.target, use.namespace);
+    const variants = [];
+    for (let length = bounds.min; length <= bounds.max; length++) {
+        if (length === 0) {
+            variants.push({ constraints: [], equalities: [[sourceKey, targetKey]] });
+            continue;
+        }
+        const orientationCount = declaration.orientation === 'undirected' ? 2 ** length : 1;
+        for (let mask = 0; mask < orientationCount; mask++) {
+            const orientations = Array.from({ length }, (_, index) => declaration.orientation === 'undirected' && (mask & (1 << index)) !== 0);
+            let transitionsValid = true;
+            for (let index = 0; index + 1 < length; index++) {
+                const incoming = endEndpoint(endpoints, orientations[index] ?? false);
+                const outgoing = startEndpoint(endpoints, orientations[index + 1] ?? false);
+                if (!typing.endpointsOverlap(incoming.accepts, outgoing.accepts)) {
+                    transitionsValid = false;
+                    break;
+                }
+            }
+            if (!transitionsValid)
+                continue;
+            const first = startEndpoint(endpoints, orientations[0] ?? false);
+            const last = endEndpoint(endpoints, orientations[length - 1] ?? false);
+            variants.push({
+                constraints: [
+                    [sourceKey, first.accepts],
+                    [targetKey, last.accepts],
+                ],
+                equalities: [],
+            });
+        }
+    }
+    return uniqueEdgeVariants(variants);
+}
+function startEndpoint(endpoints, reversed) {
+    return reversed ? endpoints[1] : endpoints[0];
+}
+function endEndpoint(endpoints, reversed) {
+    return reversed ? endpoints[0] : endpoints[1];
+}
+function uniqueEdgeVariants(values) {
+    const result = new Map();
+    for (const value of values) {
+        const key = `${value.constraints
+            .map(([term, accepts]) => `${term}:${accepts.map(definitionRefIndex).sort().join(',')}`)
+            .join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
+        result.set(key, value);
+    }
+    return [...result.values()];
+}
+function uniqueCandidates(values) {
+    const result = new Map();
+    for (const value of values) {
+        const key = value.kind === 'exact'
+            ? `exact:${definitionRefIndex(value.ref)}`
+            : `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`;
+        result.set(key, value);
+    }
+    return [...result.values()];
+}
+function uniqueClasses(values) {
+    return [...new Map(values.map((value) => [definitionRefIndex(value), value])).values()];
+}
+class UnionFind {
+    #parents = new Map();
+    constructor(values) {
+        for (const value of values)
+            this.add(value);
+    }
+    add(value) {
+        if (!this.#parents.has(value))
+            this.#parents.set(value, value);
+    }
+    find(value) {
+        this.add(value);
+        const parent = this.#parents.get(value);
+        if (parent === value)
+            return value;
+        const root = this.find(parent);
+        this.#parents.set(value, root);
+        return root;
+    }
+    join(left, right) {
+        const a = this.find(left);
+        const b = this.find(right);
+        if (a !== b)
+            this.#parents.set(b, a);
+    }
+}

package/dist/v1/schema/validation/policy/uses.d.ts

@@ -0,0 +1,5 @@
+import type { PolicyValidationContext } from './context.js';
+import { type PolicyTyping } from './typing.js';
+export declare function validateReadUses(context: PolicyValidationContext, typing: PolicyTyping): void;
+export declare function validateTraverseUses(context: PolicyValidationContext, typing: PolicyTyping): void;
+export declare function validateCallableUses(context: PolicyValidationContext, typing: PolicyTyping): void;

package/dist/v1/schema/validation/policy/uses.js

@@ -0,0 +1,196 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { isBinaryInput } from '../../../language/callable/model/callable.js';
+import { normalizePolicyChecks } from '../../../language/policy/normalization/normalize.js';
+import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
+import { MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, measureChecks } from './budgets.js';
+import { escapePointer } from './context.js';
+import { referenceContracts } from './objects.js';
+import { contractOfNodeDefinition } from './typing.js';
+const formatDefinitionRef = Key.of;
+export function validateReadUses(context, typing) {
+    validateClassPolicyUses(context, typing, 'read');
+}
+export function validateTraverseUses(context, typing) {
+    validateClassPolicyUses(context, typing, 'traverse');
+}
+function validateClassPolicyUses(context, typing, operation) {
+    for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
+        const ref = declaration.policies[operation];
+        if (ref === undefined)
+            continue;
+        const pointer = `/classes/${escapePointer(name)}/policies/${operation}`;
+        if (!context.resolvePolicy(ref, pointer))
+            continue;
+        if (declaration.kind === 'node') {
+            const object = {
+                kind: 'exact',
+                ref: { origin: context.environment.candidate.origin, kind: 'class', name },
+            };
+            if (typing.policyAccepts(ref.name, object))
+                continue;
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of ${operation} Node Class ${name}.`, formatDefinitionRef(ref));
+            continue;
+        }
+        const endpoints = declaration.orientation === 'directed'
+            ? [declaration.endpoints.source, declaration.endpoints.target]
+            : declaration.endpoints;
+        const sources = typing.concreteEndpointClasses(endpoints[0].accepts);
+        const targets = typing.concreteEndpointClasses(endpoints[1].accepts);
+        const accepted = sources.every((source) => targets.every((target) => typing.policyAcceptsEdge(ref.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })));
+        if (!accepted) {
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every concrete source/target pair of ${operation} Edge Class ${name}.`, formatDefinitionRef(ref));
+        }
+    }
+}
+export function validateCallableUses(context, typing) {
+    for (const [name, declaration] of Object.entries(context.environment.candidate.functions)) {
+        if (declaration.policy === undefined)
+            continue;
+        validateChecks(context, typing, declaration.policy, {
+            pointer: `/functions/${escapePointer(name)}/policy`,
+            input: isBinaryInput(declaration.input) ? declaration.input.metadata : declaration.input,
+            instanceMethod: false,
+        });
+    }
+    for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
+        if (declaration.kind !== 'node')
+            continue;
+        validateDeclaredMethods(context, typing, 'classes', name, declaration.methods, {
+            origin: context.environment.candidate.origin,
+            kind: 'class',
+            name,
+        });
+    }
+}
+function validateDeclaredMethods(context, typing, namespace, name, methods, receiver) {
+    const ownerAnalysis = context.analysis.definitions.get(definitionRefIndex(receiver));
+    for (const [methodName, method] of Object.entries(methods)) {
+        if (method.policy === undefined)
+            continue;
+        // Definition analysis is the authority for the effective callable. A
+        // missing entry is already a definition diagnostic, so avoid inventing a
+        // second Policy interpretation for it.
+        if (ownerAnalysis !== undefined && !ownerAnalysis.methods.has(methodName))
+            continue;
+        validateChecks(context, typing, method.policy, {
+            pointer: `/${namespace}/${escapePointer(name)}/methods/${escapePointer(methodName)}/policy`,
+            input: method.input,
+            receiver,
+            instanceMethod: !method.static,
+        });
+    }
+}
+function validateChecks(validation, typing, expression, context) {
+    const normalized = normalizePolicyChecks(expression);
+    const measure = measureChecks(normalized);
+    if (measure.depth > MAX_CHECK_DEPTH ||
+        measure.branches > MAX_BRANCHES ||
+        measure.leaves > MAX_CHECK_LEAVES) {
+        validation.add('PL_BUDGET', context.pointer, `Callable checks require depth <= ${MAX_CHECK_DEPTH}, branches <= ${MAX_BRANCHES}, and leaves <= ${MAX_CHECK_LEAVES}; got ${measure.depth}, ${measure.branches}, ${measure.leaves}.`);
+    }
+    visitChecks(validation, typing, normalized, context, context.pointer);
+}
+function visitChecks(validation, typing, expression, context, pointer) {
+    if ('sameNode' in expression) {
+        for (const [side, object] of Object.entries(expression.sameNode)) {
+            const objectPointer = `${pointer}/sameNode/${side}`;
+            if (object.kind === 'self')
+                selfContracts(validation, context, objectPointer);
+            else if (object.kind === 'input')
+                inputContracts(validation, context, object.field, objectPointer);
+            else
+                referenceContracts(validation, object.ref, objectPointer);
+        }
+        return;
+    }
+    if ('check' in expression) {
+        if (!validation.resolvePolicy(expression.check, `${pointer}/check`))
+            return;
+        const objectPointer = `${pointer}/object`;
+        const contracts = expression.object.kind === 'self'
+            ? selfContracts(validation, context, objectPointer)
+            : expression.object.kind === 'input'
+                ? inputContracts(validation, context, expression.object.field, objectPointer)
+                : referenceContracts(validation, expression.object.ref, objectPointer);
+        if (contracts === undefined)
+            return;
+        for (const contract of contracts) {
+            if (!typing.policyAccepts(expression.check.name, contract)) {
+                validation.add('PL_USE', pointer, `${formatDefinitionRef(expression.check)} is incompatible with the callable object contract.`, formatDefinitionRef(expression.check));
+                break;
+            }
+        }
+        return;
+    }
+    const { key, values } = checkOperands(expression);
+    if (values.length === 0) {
+        validation.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
+    }
+    values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`));
+}
+function selfContracts(validation, context, pointer) {
+    if (!context.instanceMethod || context.receiver === undefined) {
+        validation.add('PL_USE', pointer, 'self is valid only for a Node instance Method.');
+        return undefined;
+    }
+    return [contractOfNodeDefinition(context.receiver)];
+}
+function inputContracts(validation, context, field, pointer) {
+    const input = asRecord(context.input);
+    const properties = asRecord(input?.properties);
+    const fieldSchema = asRecord(properties?.[field]);
+    const required = input?.required;
+    const rootValid = input?.type === 'object' &&
+        properties !== undefined &&
+        Array.isArray(required) &&
+        required.includes(field) &&
+        input.additionalProperties === false &&
+        !hasCombinator(input);
+    const annotation = asRecord(fieldSchema?.['x-astrale-path']);
+    const fieldValid = rootValid &&
+        fieldSchema?.$ref === GRAPH_NODE_PATH_SCHEMA_ID &&
+        !hasCombinator(fieldSchema) &&
+        annotation?.target === 'node' &&
+        annotation.cardinality === 'one' &&
+        Array.isArray(annotation.accepts) &&
+        annotation.accepts.length > 0;
+    if (!fieldValid) {
+        validation.add('PL_USE', pointer, `input.${field} must be one direct required single-Node x-astrale-path field of a closed object input.`);
+        return undefined;
+    }
+    const contracts = [];
+    for (const ref of annotation.accepts) {
+        if (!isDefinitionRef(ref)) {
+            validation.add('PL_USE', pointer, `input.${field} has a non-Node acceptance ref.`);
+            return undefined;
+        }
+        const resolved = validation.environment.resolve(ref);
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
+            validation.add('PL_USE', pointer, `input.${field} ref ${formatDefinitionRef(ref)} does not resolve as an allowed Node Definition.`, formatDefinitionRef(ref));
+            return undefined;
+        }
+        contracts.push(contractOfNodeDefinition(ref));
+    }
+    return contracts;
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function hasCombinator(value) {
+    return ['allOf', 'anyOf', 'oneOf', 'not', 'if', 'then', 'else'].some((key) => Object.hasOwn(value, key));
+}
+function isDefinitionRef(value) {
+    const record = asRecord(value);
+    return (record !== undefined &&
+        typeof record.origin === 'string' &&
+        record.kind === 'class' &&
+        typeof record.name === 'string');
+}
+function checkOperands(value) {
+    return 'allOf' in value
+        ? { key: 'allOf', values: value.allOf }
+        : { key: 'anyOf', values: value.anyOf };
+}

package/dist/v1/schema/validation/policy/validate.d.ts

@@ -0,0 +1,11 @@
+import type { DefinitionAnalysisResult } from '../../analysis/class.js';
+import type { SchemaDiagnostic } from '../../diagnostic.js';
+import type { DomainResolutionContext } from '../../resolution/context.js';
+/**
+ * Validates the closed V1 Policy language after structural parsing.
+ *
+ * This pass is deliberately backend-independent and never throws for semantic
+ * failure. Environment and definition diagnostics are owned by their respective
+ * validators and are therefore not repeated here.
+ */
+export declare function validatePolicies(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];

package/dist/v1/schema/validation/policy/validate.js

@@ -0,0 +1,23 @@
+import { validatePolicyBudgets } from './budgets.js';
+import { PolicyValidationContext } from './context.js';
+import { validatePolicyReferences } from './references.js';
+import { PolicyTyping } from './typing.js';
+import { validateCallableUses, validateReadUses, validateTraverseUses } from './uses.js';
+/**
+ * Validates the closed V1 Policy language after structural parsing.
+ *
+ * This pass is deliberately backend-independent and never throws for semantic
+ * failure. Environment and definition diagnostics are owned by their respective
+ * validators and are therefore not repeated here.
+ */
+export function validatePolicies(environment, analysis) {
+    const context = new PolicyValidationContext(environment, analysis);
+    validatePolicyReferences(context);
+    validatePolicyBudgets(context);
+    const typing = new PolicyTyping(context);
+    typing.validatePolicies();
+    validateReadUses(context, typing);
+    validateTraverseUses(context, typing);
+    validateCallableUses(context, typing);
+    return Object.freeze(context.diagnostics);
+}

package/dist/v1/schema/validation/value-api.d.ts

@@ -0,0 +1,15 @@
+/** The exact V1 value-schema grammar embedded in DomainSchema declarations. */
+import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+import type { DomainSchema } from '../model/schema.js';
+export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export { blob, isBlobValueSchema as isBlob } from '../../language/value/model/blob.js';
+export type { BlobOptions, BlobReceipt, BlobRef, BlobSchema, } from '../../language/value/model/blob.js';
+export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from '../../language/value/model/schema.js';
+export { instant } from '../../language/value/model/instant.js';
+export type { OrderingKind } from '../../language/value/ordering.js';
+/** Validate one complete JSON value under the exact accepted schema that owns the contract. */
+export declare function validate(owner: DomainSchema, contract: JsonSchema, input: unknown, pointer?: string): readonly Diagnostic[];
+/** Return the one portable scalar ordering domain admitted by a property schema, if any. */
+export declare function classifyOrdering(owner: DomainSchema, contract: JsonSchema): OrderingKind | undefined;

package/dist/v1/schema/validation/value-api.js

@@ -0,0 +1,24 @@
+/** The exact V1 value-schema grammar embedded in DomainSchema declarations. */
+import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
+import { classifyOrdering as classifyOrderingWithRegistry } from '../../language/value/ordering.js';
+import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
+const registries = new WeakMap();
+export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export { blob, isBlobValueSchema as isBlob } from '../../language/value/model/blob.js';
+export { instant } from '../../language/value/model/instant.js';
+/** Validate one complete JSON value under the exact accepted schema that owns the contract. */
+export function validate(owner, contract, input, pointer = '') {
+    return validateJsonInstance(contract, input, registryFor(owner), pointer);
+}
+/** Return the one portable scalar ordering domain admitted by a property schema, if any. */
+export function classifyOrdering(owner, contract) {
+    return classifyOrderingWithRegistry(contract, registryFor(owner));
+}
+function registryFor(owner) {
+    let registry = registries.get(owner);
+    if (registry === undefined) {
+        registry = createDomainValueSchemaRegistry(owner);
+        registries.set(owner, registry);
+    }
+    return registry;
+}

package/dist/v1/schema/validation/value.d.ts

@@ -1,5 +1,4 @@
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { DomainSchemaIR } from '../domain.ir.js';
-import type { ValueSchemaRegistry } from '../value/registry.js';
-export declare function validateEmbeddedValueSchemas(schema: DomainSchemaIR, registry: ValueSchemaRegistry): readonly DomainDiagnostic[];
-//# sourceMappingURL=value.d.ts.map
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+export declare function validateEmbeddedValueSchemas(schema: DomainSchemaIR, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];