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

package/dist/v1/language/value/evaluate/preparation.js

@@ -0,0 +1,126 @@
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { collectResourceClosure, locationKey, } from '../reference/closure.js';
+import { indexRegistry } from '../reference/registry.index.js';
+import { compilePattern } from '../regexp/compile.js';
+import { loadPattern } from '../regexp/matcher.js';
+import { appendPointer } from '../syntax/pointer.js';
+import { walkSchema } from '../syntax/walk.js';
+/** Prepare reference and linear-regexp state without generating executable source. */
+export function prepareValueSchema(schema, registry, pointer, pool = new Map()) {
+    const indexed = indexRegistry(registry, pointer);
+    if (indexed.diagnostics.length > 0)
+        return failed(indexed.diagnostics);
+    const closure = collectResourceClosure(schema, 'callable-input', indexed.index, pointer);
+    if (closure.diagnostics.length > 0)
+        return failed(closure.diagnostics);
+    const locations = new Map();
+    const matchers = new Map();
+    for (const resource of closure.resources.values()) {
+        walkSchema(resource.schema, (location) => {
+            const key = locationKey(resource.key, location.pointer);
+            locations.set(key, {
+                key,
+                pointer: location.pointer,
+                resource,
+                schema: location.schema,
+            });
+            if (!isJsonObject(location.schema))
+                return;
+            rememberMatcher(matchers, pool, location.schema.pattern);
+            rememberMatcher(matchers, pool, location.schema.fullMatch);
+            if (isJsonObject(location.schema.patternProperties)) {
+                for (const pattern of Object.keys(location.schema.patternProperties)) {
+                    rememberMatcher(matchers, pool, pattern);
+                }
+            }
+        });
+    }
+    const initial = closure.resources.values().next().value;
+    const root = initial === undefined ? undefined : locations.get(locationKey(initial.key, ''));
+    if (root === undefined) {
+        return { compiled: false, message: 'The root value schema is absent from its closure.' };
+    }
+    let program;
+    return {
+        compiled: true,
+        value: {
+            root,
+            locations,
+            resolutions: closure.resolutions,
+            program: () => (program ??= portableProgram(root, locations, closure.resolutions, matchers)),
+            child(location, keyword, member) {
+                const keywordPointer = appendPointer(location.pointer, keyword);
+                const pointer = member === undefined ? keywordPointer : appendPointer(keywordPointer, member);
+                const child = locations.get(locationKey(location.resource.key, pointer));
+                if (child === undefined) {
+                    throw new TypeError(`Admitted value schema child ${pointer} is absent from its closure.`);
+                }
+                return child;
+            },
+            reference(location) {
+                const resolved = closure.resolutions.get(location.key);
+                return resolved === undefined
+                    ? undefined
+                    : locations.get(locationKey(resolved.resource.key, resolved.pointer));
+            },
+            matcher(source) {
+                const matcher = matchers.get(source);
+                if (matcher === undefined) {
+                    throw new TypeError('Value schema uses an unprepared I-Regexp source.');
+                }
+                return matcher.matcher;
+            },
+        },
+    };
+}
+function portableProgram(root, locations, resolutions, patterns) {
+    const ordered = [...locations.values()];
+    const indices = new Map(ordered.map((location, index) => [location.key, index]));
+    const nodes = ordered.map((location) => {
+        const children = {};
+        walkSchema(location.schema, (child) => {
+            if (child.depth !== 1)
+                return;
+            const target = indices.get(locationKey(location.resource.key, `${location.pointer}${child.pointer}`));
+            if (target !== undefined)
+                children[childKey(child.pointer)] = target;
+        });
+        const resolved = resolutions.get(location.key);
+        const reference = resolved === undefined
+            ? undefined
+            : indices.get(locationKey(resolved.resource.key, resolved.pointer));
+        if (resolved !== undefined && reference === undefined) {
+            throw new TypeError('Prepared value schema reference target is absent.');
+        }
+        return Object.freeze({
+            schema: location.schema,
+            children: Object.freeze(children),
+            ...(reference === undefined ? {} : { reference }),
+        });
+    });
+    return Object.freeze({
+        root: indices.get(root.key),
+        nodes: Object.freeze(nodes),
+        patterns: Object.freeze([...patterns.values()].map(({ pattern }) => pattern)),
+    });
+}
+export function childKey(pointer) {
+    return pointer.slice(1);
+}
+function rememberMatcher(matchers, pool, input) {
+    if (typeof input === 'string' && !matchers.has(input)) {
+        let prepared = pool.get(input);
+        if (prepared === undefined) {
+            const pattern = compilePattern(input);
+            prepared = { pattern, matcher: loadPattern(pattern) };
+            pool.set(input, prepared);
+        }
+        matchers.set(input, prepared);
+    }
+}
+function failed(diagnostics) {
+    return {
+        compiled: false,
+        message: diagnostics.map(({ code, message }) => `${code}: ${message}`).join('; '),
+    };
+}

package/dist/v1/language/value/evaluate/program.d.ts

@@ -0,0 +1,3 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { ValueProgram } from '../compile/model.js';
+export declare function validateValueProgram(program: ValueProgram, input: unknown, roots?: readonly number[]): readonly Diagnostic[];

package/dist/v1/language/value/evaluate/program.js

@@ -0,0 +1,16 @@
+import { loadValueProgram } from '../compile/load.js';
+import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
+import { evaluateInstance } from './evaluator.js';
+export function validateValueProgram(program, input, roots = [program.root]) {
+    const canonical = validateCanonicalJsonDomain(input, '');
+    if (canonical.length > 0)
+        return canonical;
+    return roots.flatMap((root) => {
+        const result = evaluateInstance(loadValueProgram(program, root), input);
+        return result.failures.map((failure) => ({
+            code: 'VALUE_SCHEMA_INSTANCE_INVALID',
+            pointer: failure.instancePointer,
+            message: `Value does not satisfy its complete V1 schema at ${failure.keyword}: ${failure.message}`,
+        }));
+    });
+}

package/dist/v1/language/value/evaluate/types.d.ts

@@ -0,0 +1,36 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { ValueProgram } from '../compile/model.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { ResolvedAddressReference, SchemaResource } from '../reference/references.js';
+import type { IRegexpMatcher } from '../regexp/matcher.js';
+export interface InstanceFailure {
+    readonly instancePointer: string;
+    readonly keyword: string;
+    readonly message: string;
+}
+export interface SchemaLocation {
+    readonly key: string;
+    readonly pointer: string;
+    readonly resource: SchemaResource;
+    readonly schema: JsonSchema;
+}
+export interface CompiledInstanceSchema {
+    readonly root: SchemaLocation;
+    readonly locations: ReadonlyMap<string, SchemaLocation>;
+    readonly resolutions: ReadonlyMap<string, ResolvedAddressReference>;
+    program(): ValueProgram;
+    child(location: SchemaLocation, keyword: string, member?: string | number): SchemaLocation;
+    reference(location: SchemaLocation): SchemaLocation | undefined;
+    matcher(source: string): IRegexpMatcher;
+}
+export interface Evaluation {
+    readonly valid: boolean;
+    readonly failures: readonly InstanceFailure[];
+    /** Properties evaluated at this exact instance location. */
+    readonly properties: ReadonlySet<string>;
+    /** Items evaluated at this exact instance location. */
+    readonly items: ReadonlySet<number>;
+}
+export type Instance = JsonValue;
+export declare function evaluation(failures?: readonly InstanceFailure[], properties?: ReadonlySet<string>, items?: ReadonlySet<number>): Evaluation;
+export declare function mergeAnnotations(targetProperties: Set<string>, targetItems: Set<number>, source: Pick<Evaluation, 'properties' | 'items'>): void;

package/dist/v1/language/value/evaluate/types.js

@@ -0,0 +1,9 @@
+export function evaluation(failures = [], properties = new Set(), items = new Set()) {
+    return { valid: failures.length === 0, failures, properties, items };
+}
+export function mergeAnnotations(targetProperties, targetItems, source) {
+    for (const property of source.properties)
+        targetProperties.add(property);
+    for (const item of source.items)
+        targetItems.add(item);
+}

package/dist/v1/language/value/evaluate/validate.d.ts

@@ -0,0 +1,16 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
+import type { CompiledInstanceSchema } from './types.js';
+import { type PatternPool } from './preparation.js';
+/**
+ * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
+ *
+ * Evaluation is an interpreter over the exact local resource closure. It never performs network
+ * resolution or dynamic source generation; patterns use the portable executor.
+ * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
+ */
+export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string, patterns?: PatternPool): Diagnostic[];
+/** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
+export declare function validatePreparedInstance(compiled: CompiledInstanceSchema, value: unknown): Diagnostic[];

package/dist/v1/language/value/evaluate/validate.js

@@ -0,0 +1,50 @@
+import { diagnostic } from '../../validation/diagnostic.js';
+import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
+import { evaluateInstance } from './evaluator.js';
+import { prepareValueSchema, } from './preparation.js';
+const validatorCache = new WeakMap();
+/**
+ * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
+ *
+ * Evaluation is an interpreter over the exact local resource closure. It never performs network
+ * resolution or dynamic source generation; patterns use the portable executor.
+ * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
+ */
+export function validateJsonInstance(schema, value, registry, pointer = '', patterns) {
+    const diagnostics = [...validateCanonicalJsonDomain(value, pointer)];
+    if (diagnostics.length > 0)
+        return diagnostics;
+    const prepared = preparedInstanceValidator(schema, registry, pointer, patterns);
+    if (!prepared.compiled) {
+        return [
+            diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Value validation failed closed while preparing exact schema resources: ${prepared.message}.`),
+        ];
+    }
+    return instanceDiagnostics(prepared.value, value, pointer);
+}
+/** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
+export function validatePreparedInstance(compiled, value) {
+    const diagnostics = [...validateCanonicalJsonDomain(value, '')];
+    return diagnostics.length > 0
+        ? diagnostics
+        : instanceDiagnostics(compiled, value, '');
+}
+function instanceDiagnostics(compiled, value, pointer) {
+    const result = evaluateInstance(compiled, value);
+    if (result.valid)
+        return [];
+    return result.failures.map((failure) => diagnostic('VALUE_SCHEMA_INSTANCE_INVALID', `${pointer}${failure.instancePointer}`, `Value does not satisfy its complete V1 schema at ${failure.keyword}: ${failure.message}`));
+}
+function preparedInstanceValidator(schema, registry, pointer, patterns) {
+    let bySchema = validatorCache.get(registry);
+    if (bySchema === undefined) {
+        bySchema = new Map();
+        validatorCache.set(registry, bySchema);
+    }
+    const cached = bySchema.get(schema);
+    if (cached !== undefined)
+        return cached;
+    const prepared = prepareValueSchema(schema, registry, pointer, patterns);
+    bySchema.set(schema, prepared);
+    return prepared;
+}

package/dist/v1/language/value/index.d.ts

@@ -0,0 +1,11 @@
+/** Complete V1 inline value language. Named Type Definitions do not exist. */
+export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, PathAnnotation, PropertyObjectSchema, ValueSchemaContext, } from './model/schema.js';
+export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
+export { instant, isInstantValue } from './model/instant.js';
+export { classifyOrdering, type OrderingKind } from './ordering.js';
+export { canonicalizeValueSchema } from './profile/canonicalize.js';
+export { validateValueSchema } from './profile/validate.js';
+export { validateJsonInstance } from './evaluate/validate.js';
+export { prepareValueSchema, type InstanceSchemaCompilation } from './evaluate/preparation.js';
+export type { ValueProgram } from './compile/model.js';
+export type { ValueSchemaRegistry, ValueSchemaDomainRegistry } from './reference/registry.js';

package/dist/v1/language/value/index.js

@@ -0,0 +1,8 @@
+/** Complete V1 inline value language. Named Type Definitions do not exist. */
+export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
+export { instant, isInstantValue } from './model/instant.js';
+export { classifyOrdering } from './ordering.js';
+export { canonicalizeValueSchema } from './profile/canonicalize.js';
+export { validateValueSchema } from './profile/validate.js';
+export { validateJsonInstance } from './evaluate/validate.js';
+export { prepareValueSchema } from './evaluate/preparation.js';

package/dist/v1/language/value/model/blob.d.ts

@@ -0,0 +1,33 @@
+import type { JsonSchemaObject } from './schema.js';
+declare const BLOB_SCHEMA: unique symbol;
+/** The portable value read from a blob-kind Node property. */
+export interface BlobRef {
+    readonly digest: `sha256:${string}`;
+    readonly mediaType: string;
+    readonly size: number;
+}
+/** An uploader-bound receipt is the only ordinary write input for a blob property. */
+export type BlobReceipt = string & {
+    readonly __brand: 'BlobReceipt';
+};
+/** Type-only marker; the serialized schema remains ordinary JSON. */
+export interface BlobSchema extends JsonSchemaObject {
+    readonly [BLOB_SCHEMA]: true;
+}
+export interface BlobOptions {
+    /** Required property-level bound, in bytes. */
+    readonly maxBytes: number;
+    /** Omission admits any canonical artifact media type. */
+    readonly mediaTypes?: readonly string[];
+}
+export declare const BLOB_VALUE_KIND: 'blob';
+export declare const BLOB_DIGEST_PATTERN = "sha256:[0-9a-f]{64}";
+export declare const BLOB_MEDIA_TYPE_PATTERN = "[a-z0-9!#$%&'*+.^_`|~-]+/[a-z0-9!#$%&'*+.^_`|~-]+(;[a-z0-9!#$%&'*+.^_`|~-]+=[!#$%&'*+.^_`|~0-9A-Za-z-]+)*";
+/** Build the one canonical V1 schema shape for a blob-valued Node property. */
+export declare function blob(options: BlobOptions): BlobSchema;
+/** Marker recognition on an already admitted V1 value schema. */
+export declare function isBlobValueSchema(input: unknown): input is BlobSchema;
+/** Exact canonical artifact media type, including ordered token parameters. */
+export declare function canonicalMediaType(input: string): string;
+export declare function isCanonicalBlobRef(input: unknown): input is BlobRef;
+export {};

package/dist/v1/language/value/model/blob.js

@@ -0,0 +1,90 @@
+export const BLOB_VALUE_KIND = 'blob';
+export const BLOB_DIGEST_PATTERN = 'sha256:[0-9a-f]{64}';
+export const BLOB_MEDIA_TYPE_PATTERN = "[a-z0-9!#$%&'*+.^_`|~-]+/[a-z0-9!#$%&'*+.^_`|~-]+(;[a-z0-9!#$%&'*+.^_`|~-]+=[!#$%&'*+.^_`|~0-9A-Za-z-]+)*";
+const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+const DIGEST = /^sha256:[0-9a-f]{64}$/u;
+/** Build the one canonical V1 schema shape for a blob-valued Node property. */
+export function blob(options) {
+    if (!Number.isSafeInteger(options?.maxBytes) || options.maxBytes < 1) {
+        throw new TypeError('Blob maxBytes must be a positive safe integer.');
+    }
+    let mediaTypes;
+    if (options.mediaTypes !== undefined) {
+        if (!Array.isArray(options.mediaTypes) || options.mediaTypes.length === 0) {
+            throw new TypeError('Blob mediaTypes must be a non-empty list.');
+        }
+        mediaTypes = [...new Set(options.mediaTypes.map(canonicalMediaType))].sort();
+    }
+    return Object.freeze({
+        type: 'object',
+        'x-astrale-value-kind': BLOB_VALUE_KIND,
+        properties: {
+            digest: { type: 'string', fullMatch: BLOB_DIGEST_PATTERN },
+            mediaType: mediaTypes === undefined
+                ? { type: 'string', fullMatch: BLOB_MEDIA_TYPE_PATTERN }
+                : { enum: mediaTypes },
+            size: { type: 'integer', minimum: 0, maximum: options.maxBytes },
+        },
+        required: ['digest', 'mediaType', 'size'],
+        additionalProperties: false,
+    });
+}
+/** Marker recognition on an already admitted V1 value schema. */
+export function isBlobValueSchema(input) {
+    return (input !== null &&
+        typeof input === 'object' &&
+        !Array.isArray(input) &&
+        input['x-astrale-value-kind'] === BLOB_VALUE_KIND);
+}
+/** Exact canonical artifact media type, including ordered token parameters. */
+export function canonicalMediaType(input) {
+    if (typeof input !== 'string')
+        throw new TypeError('Blob media type is invalid.');
+    const [essence, ...parametersInput] = input.split(';');
+    const [rawType, rawSubtype, ...extra] = essence.trim().split('/');
+    if (rawType === undefined ||
+        rawSubtype === undefined ||
+        extra.length !== 0 ||
+        !TOKEN.test(rawType) ||
+        !TOKEN.test(rawSubtype)) {
+        throw new TypeError('Blob media type is invalid.');
+    }
+    const parameters = parametersInput.map((part) => {
+        const separator = part.indexOf('=');
+        if (separator <= 0)
+            throw new TypeError('Blob media type parameter is invalid.');
+        const name = part.slice(0, separator).trim().toLowerCase();
+        const value = part.slice(separator + 1).trim();
+        if (!TOKEN.test(name) || !TOKEN.test(value)) {
+            throw new TypeError('Blob media type parameter is invalid.');
+        }
+        return [name, value];
+    });
+    parameters.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    if (new Set(parameters.map(([name]) => name)).size !== parameters.length) {
+        throw new TypeError('Blob media type parameters are duplicated.');
+    }
+    return parameters.reduce((result, [name, value]) => `${result};${name}=${value}`, `${rawType.toLowerCase()}/${rawSubtype.toLowerCase()}`);
+}
+export function isCanonicalBlobRef(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return false;
+    const value = input;
+    if (Object.keys(value).length !== 3 ||
+        !Object.hasOwn(value, 'digest') ||
+        !Object.hasOwn(value, 'mediaType') ||
+        !Object.hasOwn(value, 'size') ||
+        typeof value.digest !== 'string' ||
+        !DIGEST.test(value.digest) ||
+        typeof value.mediaType !== 'string' ||
+        !Number.isSafeInteger(value.size) ||
+        value.size < 0) {
+        return false;
+    }
+    try {
+        return canonicalMediaType(value.mediaType) === value.mediaType;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/v1/language/value/model/instant.d.ts

@@ -0,0 +1,9 @@
+/** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
+/** Canonical value-language annotation for an Instant string. */
+export declare const INSTANT_VALUE_KIND: 'instant';
+export declare const instant: Readonly<{
+    readonly type: 'string';
+    readonly 'x-astrale-value-kind': 'instant';
+}>;
+/** Test the exact proleptic-Gregorian V1 Instant lexical and calendar domain. */
+export declare function isInstantValue(input: unknown): input is string;

package/dist/v1/language/value/model/instant.js

@@ -0,0 +1,37 @@
+/** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
+/** Canonical value-language annotation for an Instant string. */
+export const INSTANT_VALUE_KIND = 'instant';
+export const instant = Object.freeze({
+    type: 'string',
+    'x-astrale-value-kind': INSTANT_VALUE_KIND,
+});
+const INSTANT_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})Z$/u;
+/** Test the exact proleptic-Gregorian V1 Instant lexical and calendar domain. */
+export function isInstantValue(input) {
+    if (typeof input !== 'string')
+        return false;
+    const match = INSTANT_PATTERN.exec(input);
+    if (match === null)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    return (month >= 1 &&
+        month <= 12 &&
+        day >= 1 &&
+        day <= daysInMonth(year, month) &&
+        hour <= 23 &&
+        minute <= 59 &&
+        second <= 59);
+}
+function daysInMonth(year, month) {
+    if (month === 2)
+        return isLeapYear(year) ? 29 : 28;
+    return month === 4 || month === 6 || month === 9 || month === 11 ? 30 : 31;
+}
+function isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}

package/dist/v1/language/value/model/object.d.ts

@@ -0,0 +1,5 @@
+import type { Object as ValueObject, Value } from '@astrale-os/kernel-dsl/value';
+/** Internal shape refinement for values that have already crossed portable-value admission. */
+/** Return whether an unknown value is a portable JSON object. */
+export declare function isValueObject(value: unknown): value is ValueObject;
+export declare function isValueObject(value: Value): value is ValueObject;

package/dist/v1/language/value/model/object.js

@@ -0,0 +1,3 @@
+export function isValueObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/v1/language/value/model/schema.d.ts

@@ -0,0 +1,25 @@
+import type { Object as JsonObject, Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { ClassRef } from '../../../addressing/index.js';
+/** Standard dialect on which the Astrale value-schema dialect is based. */
+export declare const JSON_SCHEMA_DIALECT: 'https://json-schema.org/draft/2020-12/schema';
+/** Required V1 dialect for every embedded Astrale value schema. */
+export declare const VALUE_SCHEMA_DIALECT: 'https://schemas.astrale.ai/dsl/v1/value-schema';
+/** Required vocabulary carried by the V1 value-schema dialect. */
+export declare const VALUE_SCHEMA_VOCABULARY: 'https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary';
+export type JsonSchema = boolean | JsonSchemaObject;
+export type JsonSchemaObject = JsonObject & {
+    readonly [keyword: string]: JsonValue;
+};
+export interface PropertyObjectSchema extends JsonSchemaObject {
+    readonly type: 'object';
+    readonly properties: Readonly<Record<string, JsonSchema>>;
+    readonly required: readonly string[];
+    readonly additionalProperties: false;
+}
+export interface PathAnnotation {
+    readonly target: 'node';
+    readonly cardinality: 'one';
+    readonly accepts: readonly ClassRef[];
+}
+export declare const VALUE_SCHEMA_CONTEXTS: readonly ['property-facet', 'callable-input', 'callable-output'];
+export type ValueSchemaContext = (typeof VALUE_SCHEMA_CONTEXTS)[number];

package/dist/v1/language/value/model/schema.js

@@ -0,0 +1,11 @@
+/** Standard dialect on which the Astrale value-schema dialect is based. */
+export const JSON_SCHEMA_DIALECT = 'https://json-schema.org/draft/2020-12/schema';
+/** Required V1 dialect for every embedded Astrale value schema. */
+export const VALUE_SCHEMA_DIALECT = 'https://schemas.astrale.ai/dsl/v1/value-schema';
+/** Required vocabulary carried by the V1 value-schema dialect. */
+export const VALUE_SCHEMA_VOCABULARY = 'https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary';
+export const VALUE_SCHEMA_CONTEXTS = [
+    'property-facet',
+    'callable-input',
+    'callable-output',
+];

package/dist/v1/language/value/ordering.d.ts

@@ -0,0 +1,15 @@
+import type { ValueProgram } from './compile/model.js';
+import type { CompiledInstanceSchema } from './evaluate/types.js';
+import type { JsonSchema } from './model/schema.js';
+import type { ValueSchemaRegistry } from './reference/registry.js';
+export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
+/**
+ * Classify a schema only when every value it can admit belongs to one sortable scalar domain.
+ *
+ * The analysis is intentionally conservative: unsupported or ambiguous schemas return undefined
+ * instead of guessing from annotations, examples, formats, or current data.
+ */
+export declare function classifyOrdering(contract: JsonSchema, registry: ValueSchemaRegistry): OrderingKind | undefined;
+/** Recompute the scalar ordering classification from one admitted portable value program. */
+export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;
+export declare function classifyPreparedOrdering(compiled: CompiledInstanceSchema): OrderingKind | undefined;