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

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

@@ -0,0 +1,170 @@
+import { loadValueProgram } from './compile/load.js';
+import { prepareValueSchema } from './evaluate/preparation.js';
+const ALL_JSON_KINDS = new Set([
+    'null',
+    'boolean',
+    'number',
+    'string',
+    'array',
+    'object',
+]);
+/**
+ * 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 function classifyOrdering(contract, registry) {
+    const prepared = prepareValueSchema(contract, registry, '');
+    if (!prepared.compiled)
+        return undefined;
+    return classifyPreparedOrdering(prepared.value);
+}
+/** Recompute the scalar ordering classification from one admitted portable value program. */
+export function classifyValueProgramOrdering(program) {
+    return classifyPreparedOrdering(loadValueProgram(program));
+}
+export function classifyPreparedOrdering(compiled) {
+    const candidates = new OrderingClassifier(compiled).classify(compiled.root);
+    if (candidates.size !== 1)
+        return undefined;
+    const [kind] = candidates;
+    return kind === 'boolean' || kind === 'number' || kind === 'string' || kind === 'instant'
+        ? kind
+        : undefined;
+}
+class OrderingClassifier {
+    compiled;
+    active = new Set();
+    cache = new Map();
+    constructor(compiled) {
+        this.compiled = compiled;
+    }
+    classify(location) {
+        const cached = this.cache.get(location.key);
+        if (cached !== undefined)
+            return cached;
+        if (this.active.has(location.key))
+            return ALL_JSON_KINDS;
+        this.active.add(location.key);
+        try {
+            const result = this.classifySchema(location);
+            this.cache.set(location.key, result);
+            return result;
+        }
+        finally {
+            this.active.delete(location.key);
+        }
+    }
+    classifySchema(location) {
+        if (location.schema === false)
+            return new Set();
+        if (location.schema === true)
+            return ALL_JSON_KINDS;
+        const schema = location.schema;
+        let candidates = ALL_JSON_KINDS;
+        if (Object.hasOwn(schema, 'x-astrale-value-kind')) {
+            if (schema['x-astrale-value-kind'] !== 'instant' || schema.type !== 'string') {
+                return new Set();
+            }
+            candidates = intersect(candidates, new Set(['instant']));
+        }
+        const declaredTypes = typesOf(schema.type);
+        if (declaredTypes !== undefined)
+            candidates = intersect(candidates, declaredTypes);
+        if (Object.hasOwn(schema, 'const')) {
+            candidates = intersect(candidates, new Set([kindOfValue(schema.const)]));
+        }
+        if (Array.isArray(schema.enum)) {
+            candidates = intersect(candidates, normalize(new Set(schema.enum.map(kindOfValue))));
+        }
+        if (Object.hasOwn(schema, '$ref')) {
+            const target = this.compiled.reference(location);
+            if (target === undefined)
+                return new Set();
+            candidates = intersect(candidates, this.classify(target));
+        }
+        const allOf = schemaList(schema.allOf);
+        if (allOf !== undefined) {
+            for (let index = 0; index < allOf.length; index += 1) {
+                candidates = intersect(candidates, this.classify(this.child(location, 'allOf', index)));
+            }
+        }
+        for (const keyword of ['anyOf', 'oneOf']) {
+            const branches = schemaList(schema[keyword]);
+            if (branches === undefined)
+                continue;
+            let admitted = new Set();
+            for (let index = 0; index < branches.length; index += 1) {
+                admitted = union(admitted, this.classify(this.child(location, keyword, index)));
+            }
+            candidates = intersect(candidates, admitted);
+        }
+        return candidates;
+    }
+    child(location, keyword, index) {
+        return this.compiled.child(location, keyword, index);
+    }
+}
+function typesOf(input) {
+    if (typeof input === 'string')
+        return typeSet([input]);
+    if (Array.isArray(input)) {
+        const types = input.filter((value) => typeof value === 'string');
+        return typeSet(types);
+    }
+    return undefined;
+}
+function typeSet(types) {
+    const result = new Set();
+    for (const type of types) {
+        if (type === 'integer' || type === 'number')
+            result.add('number');
+        else if (type === 'null' ||
+            type === 'boolean' ||
+            type === 'string' ||
+            type === 'array' ||
+            type === 'object') {
+            result.add(type);
+        }
+    }
+    return result;
+}
+function kindOfValue(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (typeof value === 'object')
+        return 'object';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (typeof value === 'number')
+        return 'number';
+    return 'string';
+}
+function intersect(left, right) {
+    const result = new Set();
+    for (const leftKind of left) {
+        for (const rightKind of right) {
+            if (leftKind === rightKind)
+                result.add(leftKind);
+            else if ((leftKind === 'string' && rightKind === 'instant') ||
+                (leftKind === 'instant' && rightKind === 'string')) {
+                result.add('instant');
+            }
+        }
+    }
+    return normalize(result);
+}
+function union(left, right) {
+    return normalize(new Set([...left, ...right]));
+}
+function normalize(input) {
+    if (input.has('string'))
+        input.delete('instant');
+    return input;
+}
+function schemaList(input) {
+    return Array.isArray(input) ? input : undefined;
+}

package/dist/v1/language/value/profile/canonicalize.d.ts

@@ -0,0 +1,4 @@
+import type { JsonSchema, ValueSchemaContext } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
+/** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
+export declare function canonicalizeValueSchema(schema: JsonSchema, context?: ValueSchemaContext, registry?: ValueSchemaRegistry): JsonSchema;

package/dist/v1/language/value/profile/canonicalize.js

@@ -0,0 +1,130 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { compareDefinitionRefs, compareUnicode } from '../../../addressing/ordering.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../syntax/keywords.js';
+const TYPE_ORDER = ['null', 'boolean', 'integer', 'number', 'string', 'array', 'object'];
+const TYPE_RANK = new Map(TYPE_ORDER.map((name, index) => [name, index]));
+const encoder = new TextEncoder();
+/** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
+export function canonicalizeValueSchema(schema, context, registry) {
+    void registry;
+    return canonicalizeSchema(schema, true, context);
+}
+function canonicalizeSchema(schema, root, context) {
+    if (typeof schema === 'boolean')
+        return schema;
+    const result = {};
+    for (const keyword of Object.keys(schema).sort()) {
+        if (root && keyword === '$schema')
+            continue;
+        const value = schema[keyword];
+        if (keyword === 'required' && Array.isArray(value)) {
+            assertUnique(value, String, 'required');
+            result[keyword] = [...value].sort((left, right) => compareUnicode(String(left), String(right)));
+        }
+        else if (keyword === 'type' && Array.isArray(value)) {
+            assertUnique(value, String, 'type');
+            result[keyword] = [...value].sort((left, right) => (TYPE_RANK.get(String(left)) ?? Number.MAX_SAFE_INTEGER) -
+                (TYPE_RANK.get(String(right)) ?? Number.MAX_SAFE_INTEGER));
+        }
+        else if (keyword === 'enum' && Array.isArray(value)) {
+            const entries = value.map(canonicalizeJson);
+            assertUnique(entries, json.serialize, 'enum');
+            result[keyword] = entries.sort(compareCanonicalBytes);
+        }
+        else if (keyword === 'dependentRequired' && isJsonObject(value)) {
+            result[keyword] = canonicalizeDependentRequired(value);
+        }
+        else if (keyword === 'x-astrale-path' && isJsonObject(value)) {
+            result[keyword] = canonicalizePathAnnotation(value);
+        }
+        else if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
+            result[keyword] = canonicalizeSchema(value, false, context);
+        }
+        else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false, context) : canonicalizeJson(entry));
+        }
+        else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
+            const schemas = {};
+            for (const name of Object.keys(value).sort()) {
+                const entry = value[name];
+                schemas[name] = isJsonSchema(entry)
+                    ? canonicalizeSchema(entry, false, context)
+                    : canonicalizeJson(entry);
+            }
+            result[keyword] = schemas;
+        }
+        else {
+            result[keyword] = canonicalizeJson(value);
+        }
+    }
+    return result;
+}
+function canonicalizeDependentRequired(value) {
+    const result = {};
+    for (const name of Object.keys(value).sort()) {
+        const dependencies = value[name];
+        if (!Array.isArray(dependencies)) {
+            result[name] = canonicalizeJson(dependencies);
+            continue;
+        }
+        assertUnique(dependencies, String, `dependentRequired.${name}`);
+        result[name] = [...dependencies].sort((left, right) => compareUnicode(String(left), String(right)));
+    }
+    return result;
+}
+function canonicalizePathAnnotation(value) {
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+        const entry = value[key];
+        if (key === 'accepts' && Array.isArray(entry)) {
+            const accepts = entry.map(canonicalizeJson);
+            assertUnique(accepts, json.serialize, 'x-astrale-path.accepts');
+            result[key] = accepts.sort((left, right) => compareDefinitionRefs(left, right));
+        }
+        else
+            result[key] = canonicalizeJson(entry);
+    }
+    return result;
+}
+function canonicalizeJson(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return value;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new TypeError('Cannot canonicalize a non-finite number.');
+        if (Object.is(value, -0))
+            throw new TypeError('Cannot canonicalize negative zero.');
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(canonicalizeJson);
+    if (!isJsonObject(value))
+        throw new TypeError('Cannot canonicalize a non-JSON value.');
+    const result = {};
+    for (const key of Object.keys(value).sort())
+        result[key] = canonicalizeJson(value[key]);
+    return result;
+}
+function compareCanonicalBytes(left, right) {
+    const a = encoder.encode(json.serialize(left));
+    const b = encoder.encode(json.serialize(right));
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) - (b[index] ?? 0);
+    }
+    return a.length - b.length;
+}
+function assertUnique(values, keyOf, name) {
+    const keys = new Set();
+    for (const value of values) {
+        const key = keyOf(value);
+        if (keys.has(key))
+            throw new TypeError(`${name} contains a duplicate value.`);
+        keys.add(key);
+    }
+}
+function isJsonSchema(value) {
+    return typeof value === 'boolean' || isJsonObject(value);
+}

package/dist/v1/language/value/profile/json.validate.d.ts

@@ -0,0 +1,2 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+export declare function validateCanonicalJsonDomain(value: unknown, pointer: string): readonly Diagnostic[];

package/dist/v1/language/value/profile/json.validate.js

@@ -0,0 +1,14 @@
+import { acceptForRead as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+import { diagnostic } from '../../validation/diagnostic.js';
+export function validateCanonicalJsonDomain(value, pointer) {
+    try {
+        acceptJsonValue(value);
+        return [];
+    }
+    catch (error) {
+        if (error instanceof JsonBoundaryError) {
+            return [diagnostic('VS_NUMBER_DOMAIN', `${pointer}${error.pointer}`, error.message)];
+        }
+        return [diagnostic('VS_META_SCHEMA', pointer, 'Value is outside the JSON data model.')];
+    }
+}

package/dist/v1/language/value/profile/meta-schema.compiled.d.ts

@@ -0,0 +1,78 @@
+export declare const validate: typeof validate20;
+export default validate20;
+declare function validate20(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+    dynamicAnchors?: {} | undefined;
+    instancePath?: string | undefined;
+    rootData?: any;
+}): boolean;
+declare namespace validate20 {
+    var evaluated: {
+        props: {
+            fullMatch: boolean;
+            "x-astrale-path": boolean;
+            definitions: boolean;
+            dependencies: boolean;
+            $recursiveAnchor: boolean;
+            $recursiveRef: boolean;
+            contentEncoding: boolean;
+            contentMediaType: boolean;
+            contentSchema: boolean;
+            format: boolean;
+            title: boolean;
+            description: boolean;
+            default: boolean;
+            deprecated: boolean;
+            readOnly: boolean;
+            writeOnly: boolean;
+            examples: boolean;
+            type: boolean;
+            const: boolean;
+            enum: boolean;
+            multipleOf: boolean;
+            maximum: boolean;
+            exclusiveMaximum: boolean;
+            minimum: boolean;
+            exclusiveMinimum: boolean;
+            maxLength: boolean;
+            minLength: boolean;
+            pattern: boolean;
+            maxItems: boolean;
+            minItems: boolean;
+            uniqueItems: boolean;
+            maxContains: boolean;
+            minContains: boolean;
+            maxProperties: boolean;
+            minProperties: boolean;
+            required: boolean;
+            dependentRequired: boolean;
+            unevaluatedItems: boolean;
+            unevaluatedProperties: boolean;
+            prefixItems: boolean;
+            items: boolean;
+            contains: boolean;
+            additionalProperties: boolean;
+            properties: boolean;
+            patternProperties: boolean;
+            dependentSchemas: boolean;
+            propertyNames: boolean;
+            if: boolean;
+            then: boolean;
+            else: boolean;
+            allOf: boolean;
+            anyOf: boolean;
+            oneOf: boolean;
+            not: boolean;
+            $id: boolean;
+            $schema: boolean;
+            $ref: boolean;
+            $anchor: boolean;
+            $dynamicRef: boolean;
+            $dynamicAnchor: boolean;
+            $vocabulary: boolean;
+            $comment: boolean;
+            $defs: boolean;
+        };
+        dynamicProps: boolean;
+        dynamicItems: boolean;
+    };
+}