@astrale-os/kernel-dsl 1.0.0-beta.12 → 1.0.0-beta.14

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

@@ -0,0 +1,51 @@
+import type { core as zodCore } from 'zod';
+type JsonSchema = zodCore.JSONSchema.JSONSchema;
+/**
+ * The checks on value schemas JSON Schema cannot state, which the published document names with
+ * the positions it constrains. The Kernel reports each as `DV_VALUE_SCHEMA`, with its value code.
+ */
+export declare const valueSchemaRules: {
+    readonly 'value-blob': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_VALUE_KIND';
+        readonly statement: 'A blob is declared only by the whole schema of a Property, exactly as values.blob writes it.';
+    };
+    readonly 'value-path': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_PATH_EXTENSION';
+        readonly statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.';
+    };
+    readonly 'value-recursion': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_RECURSION_PRODUCTIVE';
+        readonly statement: 'Every reference cycle of a value schema crosses a keyword that steps into the value: to a member, a member name or an item.';
+    };
+    readonly 'value-reference-form': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REFERENCE_FORM';
+        readonly statement: 'A $ref is a JSON Pointer fragment into its own value schema, or the id of the graph NodePath schema beside x-astrale-path.';
+    };
+    readonly 'value-reference-resolution': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REFERENCE_RESOLUTION';
+        readonly statement: 'A $ref resolves to a location of its own value schema, and x-astrale-path accepts Node Classes of the Domain or of a direct dependency.';
+    };
+    readonly 'value-regexp': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REGEX_PORTABLE';
+        readonly statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.';
+    };
+};
+export type ValueSchemaRule = keyof typeof valueSchemaRules;
+/**
+ * The value language in JSON Schema, for the document that embeds value schemas: `root` constrains
+ * the `value-schema` definition with the published dialect and what the profile adds to it,
+ * `definitions` holds the locations it reaches, and `nodeProperty` constrains a Node Property
+ * definition. A named check leaves `x-astrale-rule` at the positions it constrains.
+ */
+export declare function valueSchemaJsonSchema(): {
+    readonly root: readonly JsonSchema[];
+    readonly definitions: Readonly<Record<string, JsonSchema>>;
+    readonly nodeProperty: JsonSchema;
+};
+export {};

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

@@ -0,0 +1,126 @@
+import { VALUE_SCHEMA_DIALECT } from '../../language/value/model/schema.js';
+import { FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS, } from '../../language/value/profile/vocabulary.js';
+/**
+ * The checks on value schemas JSON Schema cannot state, which the published document names with
+ * the positions it constrains. The Kernel reports each as `DV_VALUE_SCHEMA`, with its value code.
+ */
+export const valueSchemaRules = {
+    'value-blob': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_VALUE_KIND',
+        statement: 'A blob is declared only by the whole schema of a Property, exactly as values.blob writes it.',
+    },
+    'value-path': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_PATH_EXTENSION',
+        statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.',
+    },
+    'value-recursion': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_RECURSION_PRODUCTIVE',
+        statement: 'Every reference cycle of a value schema crosses a keyword that steps into the value: to a member, a member name or an item.',
+    },
+    'value-reference-form': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_REFERENCE_FORM',
+        statement: 'A $ref is a JSON Pointer fragment into its own value schema, or the id of the graph NodePath schema beside x-astrale-path.',
+    },
+    'value-reference-resolution': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_REFERENCE_RESOLUTION',
+        statement: 'A $ref resolves to a location of its own value schema, and x-astrale-path accepts Node Classes of the Domain or of a direct dependency.',
+    },
+    'value-regexp': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_REGEX_PORTABLE',
+        statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.',
+    },
+};
+const KIND = 'x-astrale-value-kind';
+const LOCATION = '#/$defs/value-location';
+const SUBSCHEMA = '#/$defs/value-subschema';
+/**
+ * The value language in JSON Schema, for the document that embeds value schemas: `root` constrains
+ * the `value-schema` definition with the published dialect and what the profile adds to it,
+ * `definitions` holds the locations it reaches, and `nodeProperty` constrains a Node Property
+ * definition. A named check leaves `x-astrale-rule` at the positions it constrains.
+ */
+export function valueSchemaJsonSchema() {
+    return {
+        root: [
+            { $ref: VALUE_SCHEMA_DIALECT },
+            { $ref: LOCATION },
+            objectOrBoolean({
+                properties: {
+                    $schema: { const: VALUE_SCHEMA_DIALECT },
+                    [KIND]: {
+                        enum: ['instant', 'blob'],
+                        'x-astrale-rule': 'value-blob',
+                    },
+                },
+            }),
+        ],
+        definitions: {
+            // Every location, the root included: the closed vocabulary and the subschemas it holds.
+            'value-location': objectOrBoolean({
+                propertyNames: {
+                    enum: VALUE_KEYWORDS.filter((keyword) => !FORBIDDEN_KEYWORDS.includes(keyword)),
+                },
+                properties: {
+                    $id: false,
+                    $ref: {
+                        type: 'string',
+                        'x-astrale-rule': [
+                            'value-recursion',
+                            'value-reference-form',
+                            'value-reference-resolution',
+                        ],
+                    },
+                    enum: { type: 'array', uniqueItems: true },
+                    fullMatch: { type: 'string', 'x-astrale-rule': 'value-regexp' },
+                    pattern: { type: 'string', 'x-astrale-rule': 'value-regexp' },
+                    'x-astrale-path': { type: 'object', 'x-astrale-rule': 'value-path' },
+                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.single.map((keyword) => [keyword, { $ref: SUBSCHEMA }])),
+                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.array.map((keyword) => [
+                        keyword,
+                        { type: 'array', items: { $ref: SUBSCHEMA } },
+                    ])),
+                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.map.map((keyword) => [
+                        keyword,
+                        {
+                            type: 'object',
+                            additionalProperties: { $ref: SUBSCHEMA },
+                            ...(keyword === 'patternProperties' ? { 'x-astrale-rule': 'value-regexp' } : {}),
+                        },
+                    ])),
+                },
+                // An instant is a string.
+                if: { required: [KIND], properties: { [KIND]: { const: 'instant' } } },
+                // oxlint-disable-next-line unicorn/no-thenable -- the JSON Schema keyword
+                then: { required: ['type'], properties: { type: { const: 'string' } } },
+            }),
+            // A location below the root: no $schema, and no blob.
+            'value-subschema': {
+                allOf: [
+                    { $ref: LOCATION },
+                    objectOrBoolean({ properties: { $schema: false, [KIND]: { const: 'instant' } } }),
+                ],
+            },
+        },
+        // An automatic or State Property holds no blob.
+        nodeProperty: {
+            if: { anyOf: [{ required: ['auto'] }, { required: ['state'] }] },
+            // oxlint-disable-next-line unicorn/no-thenable -- the JSON Schema keyword
+            then: {
+                properties: {
+                    schema: {
+                        not: { type: 'object', required: [KIND], properties: { [KIND]: { const: 'blob' } } },
+                    },
+                },
+            },
+        },
+    };
+}
+function objectOrBoolean(object) {
+    return { anyOf: [{ type: 'boolean' }, { type: 'object', ...object }] };
+}

package/dist/v1/schema/validation/view.js

@@ -1,12 +1,14 @@
+import { equalDefinitionRefs } from '../../addressing/definition-ref.js';
 import { Key } from '../../addressing/key.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 const formatDefinitionRef = Key.of;
 export function validateViews(environment) {
     const diagnostics = [];
     for (const [name, view] of Object.entries(environment.candidate.views)) {
-        const pointer = `/views/${escapePointer(name)}`;
+        const pointer = `/views/${escapePointerToken(name)}`;
         const ref = { origin: environment.candidate.origin, kind: 'view', name };
-        if (!sameRef(view.ref, ref)) {
+        if (!equalDefinitionRefs(view.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `View ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(view.ref)));
         }
     }
@@ -26,9 +28,3 @@ function validateEntrypoint(environment, diagnostics) {
         diagnostics.push(diagnostic('DV_ENTRYPOINT', '/entrypoint', `Entrypoint ${formatDefinitionRef(entrypoint)} is not a Domain-targeted View of ${origin}.`, formatDefinitionRef(entrypoint)));
     }
 }
-function sameRef(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.12",
+  "version": "1.0.0-beta.14",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -79,6 +79,8 @@
       "types": "./dist/v1/schema/revision.d.ts",
       "import": "./dist/v1/schema/revision.js"
     },
+    "./v1/schema/domain-schema.schema.json": "./dist/v1/schema/.spec/schemas/domain-schema.schema.json",
+    "./v1/schema/value-schema.schema.json": "./dist/v1/language/.spec/schemas/value-schema.schema.json",
     "./v1/value/full-match": {
       "types": "./dist/v1/value/full-match.d.ts",
       "import": "./dist/v1/value/full-match.js"

package/dist/v1/compiled/admission/semantics/cardinality.d.ts

@@ -1,5 +0,0 @@
-import { type CompiledSchemaEntry } from '../../model/schema.js';
-import { type SemanticIndex } from './context.js';
-import { type CoreNode, type CoreEdgeValue } from './core.js';
-/** Check normalized Edge identity, keys, noSelf, cycles and complete Core degrees. */
-export declare function validateCoreEdgeSet(context: SemanticIndex, entry: CompiledSchemaEntry, entryIndex: number, nodes: ReadonlyMap<string, CoreNode>, edges: readonly CoreEdgeValue[]): void;

package/dist/v1/compiled/admission/semantics/cardinality.js

@@ -1,128 +0,0 @@
-import { Key } from '../../../addressing/index.js';
-import { compareUnicode } from '../../../addressing/ordering.js';
-import {} from '../../../language/class/model/edge.js';
-import { coveringEdgeUniqueTuples, edgeUniqueKeys } from '../../../language/class/unique.js';
-import {} from '../../model/schema.js';
-import { fail } from '../diagnostic.js';
-import { isCompiledEdge, classSatisfiesAny, } from './context.js';
-import {} from './core.js';
-import { sameIncidentEndpoint, countBounds } from './edge.js';
-/** Check normalized Edge identity, keys, noSelf, cycles and complete Core degrees. */
-export function validateCoreEdgeSet(context, entry, entryIndex, nodes, edges) {
-    const seen = new Set();
-    const slices = new Map();
-    for (const edge of edges) {
-        const classKey = Key.of(edge.value.class);
-        const [source, target] = edge.class.value.orientation === 'undirected' &&
-            compareUnicode(edge.source.key, edge.target.key) > 0
-            ? [edge.target.key, edge.source.key]
-            : [edge.source.key, edge.target.key];
-        const key = `${classKey}\u0000${source}\u0000${target}`;
-        if (seen.has(key))
-            fail(edge.pointer, 'Core Edge duplicates an exact normalized Edge identity.');
-        seen.add(key);
-        const values = slices.get(classKey) ?? [];
-        values.push(edge);
-        slices.set(classKey, values);
-        if (edge.class.value.constraints.noSelf === true && edge.source.key === edge.target.key)
-            fail(edge.pointer, 'Core Edge violates noSelf.');
-    }
-    // No two Core Edges hold one key under a tuple covering their Classes (DV-EDGE-UNIQUE).
-    const resolve = (ref) => context.classes.get(Key.of(ref))?.value;
-    const holders = new Set();
-    for (const edge of edges) {
-        const keys = edgeUniqueKeys(coveringEdgeUniqueTuples(edge.class.value, resolve), {
-            source: edge.source.key,
-            target: edge.target.key,
-            props: edge.value.properties,
-        });
-        if (keys.some((key) => holders.has(key)))
-            fail(edge.pointer, 'Core Edge holds a key another Core Edge holds.');
-        for (const key of keys)
-            holders.add(key);
-    }
-    for (const edgeClass of entry.definitions.classes) {
-        if (!isCompiledEdge(edgeClass))
-            continue;
-        const classEdges = slices.get(Key.of(edgeClass.ref)) ?? [];
-        if (edgeClass.constraints.acyclic === true && hasCycle(classEdges))
-            fail(`/closure/${entryIndex}/facts/core`, 'Core Edge set violates exact-Class acyclicity.');
-        validateCardinality(context, edgeClass, classEdges, nodes);
-    }
-}
-function validateCardinality(context, declaration, edges, nodes) {
-    for (const subject of cardinalitySubjects(edges, nodes)) {
-        if (declaration.orientation === 'directed') {
-            if (classSatisfiesAny(context, subject.class, declaration.endpoints.source.accepts))
-                checkCount(declaration.endpoints.source.outgoing, edges.filter(({ source }) => source.key === subject.key).length, subject.pointer, subject.minimum);
-            if (classSatisfiesAny(context, subject.class, declaration.endpoints.target.accepts))
-                checkCount(declaration.endpoints.target.incoming, edges.filter(({ target }) => target.key === subject.key).length, subject.pointer, subject.minimum);
-        }
-        else {
-            const degree = edges.filter(({ source, target }) => source.key === subject.key || target.key === subject.key).length;
-            const [first, second] = declaration.endpoints;
-            if (classSatisfiesAny(context, subject.class, first.accepts))
-                checkCount(first.incident, degree, subject.pointer, subject.minimum);
-            if (!sameIncidentEndpoint(first, second) &&
-                classSatisfiesAny(context, subject.class, second.accepts))
-                checkCount(second.incident, degree, subject.pointer, subject.minimum);
-        }
-    }
-}
-/**
- * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
- * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
- * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
- */
-function cardinalitySubjects(edges, nodes) {
-    const subjects = new Map();
-    for (const node of nodes.values()) {
-        subjects.set(node.key, {
-            key: node.key,
-            class: node.value.class,
-            pointer: node.pointer,
-            minimum: true,
-        });
-    }
-    for (const edge of edges) {
-        for (const endpoint of [edge.source, edge.target]) {
-            if ('value' in endpoint || !('class' in endpoint) || subjects.has(endpoint.key))
-                continue;
-            subjects.set(endpoint.key, {
-                key: endpoint.key,
-                class: endpoint.class,
-                pointer: endpoint.pointer,
-                minimum: false,
-            });
-        }
-    }
-    return Object.freeze([...subjects.values()]);
-}
-function checkCount(count, degree, path, enforceMinimum) {
-    const [minimum, maximum] = countBounds(count);
-    if (degree > maximum || (degree < minimum && enforceMinimum))
-        fail(path, `Core degree ${degree} violates Edge count ${count}.`);
-}
-function hasCycle(edges) {
-    const outgoing = new Map();
-    for (const edge of edges) {
-        const values = outgoing.get(edge.source.key) ?? [];
-        values.push(edge.target.key);
-        outgoing.set(edge.source.key, values);
-    }
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (key) => {
-        if (visiting.has(key))
-            return true;
-        if (visited.has(key))
-            return false;
-        visiting.add(key);
-        if ((outgoing.get(key) ?? []).some(visit))
-            return true;
-        visiting.delete(key);
-        visited.add(key);
-        return false;
-    };
-    return [...outgoing.keys()].some(visit);
-}

package/dist/v1/compiled/admission/semantics/policy/equality.d.ts

@@ -1,8 +0,0 @@
-/** Retain and merge term equalities while typing one Policy branch. */
-export declare class CompiledUnionFind {
-    #private;
-    constructor(values: Iterable<string>);
-    add(value: string): void;
-    find(value: string): string;
-    join(left: string, right: string): void;
-}

package/dist/v1/compiled/admission/semantics/policy/equality.js

@@ -1,27 +0,0 @@
-/** Retain and merge term equalities while typing one Policy branch. */
-export class CompiledUnionFind {
-    #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/compiled/admission/semantics/policy/measure.d.ts

@@ -1,9 +0,0 @@
-import { type PolicyExpression } from '../../../../language/policy/model/policy.js';
-interface CompiledPatternMeasure {
-    readonly depth: number;
-    readonly edgeCounts: readonly number[];
-    readonly domains: ReadonlySet<string>;
-}
-/** Measure expanded Policy branches, depth and referenced Domains. */
-export declare function measureCompiledPolicy(origin: string, name: string, normalized: ReadonlyMap<string, PolicyExpression>, visiting: Set<string>): CompiledPatternMeasure | undefined;
-export {};

package/dist/v1/compiled/admission/semantics/policy/measure.js

@@ -1,81 +0,0 @@
-import { policyObjectOrigin, policyVariableClass } from '../../../../language/index.js';
-import { BRANCH_OVERFLOW } from '../../../../language/policy/analysis/budgets.js';
-import {} from '../../../../language/policy/model/policy.js';
-/** Measure expanded Policy branches, depth and referenced Domains. */
-export function measureCompiledPolicy(origin, name, normalized, visiting) {
-    if (visiting.has(name))
-        return undefined;
-    const expression = normalized.get(name);
-    if (expression === undefined)
-        return undefined;
-    if ('match' in expression)
-        return measureCompiledPattern(expression.match, origin);
-    const nested = new Set(visiting);
-    nested.add(name);
-    const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    const children = refs.map((ref) => ref.origin === origin ? measureCompiledPolicy(origin, ref.name, normalized, nested) : undefined);
-    if (children.some((value) => value === undefined))
-        return undefined;
-    return combineCompiledMeasures('allOf' in expression ? 'allOf' : 'anyOf', children);
-}
-function measureCompiledPattern(pattern, origin) {
-    if ('sameNode' in pattern)
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                origin,
-                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    if ('source' in pattern)
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                origin,
-                pattern.class.origin,
-                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    if ('exists' in pattern) {
-        const child = measureCompiledPattern(pattern.exists.where, origin);
-        return {
-            depth: child.depth + 1,
-            edgeCounts: child.edgeCounts,
-            domains: new Set([
-                ...child.domains,
-                ...pattern.exists.nodes.flatMap((node) => {
-                    const ref = policyVariableClass(node);
-                    return ref === undefined ? [] : [ref.origin];
-                }),
-            ]),
-        };
-    }
-    return combineCompiledMeasures('allOf' in pattern ? 'allOf' : 'anyOf', ('allOf' in pattern ? pattern.allOf : pattern.anyOf).map((child) => measureCompiledPattern(child, origin)));
-}
-function combineCompiledMeasures(kind, children) {
-    const depth = 1 + Math.max(0, ...children.map((child) => child.depth));
-    const domains = new Set(children.flatMap((child) => [...child.domains]));
-    if (kind === 'anyOf')
-        return {
-            depth,
-            edgeCounts: children.flatMap((child) => child.edgeCounts).slice(0, BRANCH_OVERFLOW),
-            domains,
-        };
-    let edgeCounts = [0];
-    for (const child of children) {
-        const next = [];
-        for (const left of edgeCounts) {
-            for (const right of child.edgeCounts) {
-                next.push(left + right);
-                if (next.length >= BRANCH_OVERFLOW)
-                    break;
-            }
-            if (next.length >= BRANCH_OVERFLOW)
-                break;
-        }
-        edgeCounts = next;
-    }
-    return { depth, edgeCounts, domains };
-}

package/dist/v1/compiled/admission/semantics/policy/variants.d.ts

@@ -1,10 +0,0 @@
-import type { CompiledPolicyTyping } from './typing.js';
-import { type ClassRef } from '../../../../addressing/index.js';
-import { type PatternEdgeUse } from '../../../../language/policy/analysis/branches.js';
-/** One possible combination of endpoint constraints and term equalities. */
-export interface CompiledEdgeVariant {
-    readonly constraints: readonly (readonly [string, readonly ClassRef[]])[];
-    readonly equalities: readonly (readonly [string, string])[];
-}
-/** Enumerate satisfiable endpoint variants for a branch’s Edge uses. */
-export declare function compiledEdgeAlternatives(edges: readonly PatternEdgeUse[], typing: CompiledPolicyTyping): readonly (readonly CompiledEdgeVariant[])[];

package/dist/v1/compiled/admission/semantics/policy/variants.js

@@ -1,65 +0,0 @@
-import { Key } from '../../../../addressing/index.js';
-import { compareUnicode } from '../../../../addressing/ordering.js';
-import {} from '../../../../language/class/model/edge.js';
-import { termKey } from '../../../../language/policy/analysis/branches.js';
-import { isCompiledEdge } from '../context.js';
-/** Enumerate satisfiable endpoint variants for a branch’s Edge uses. */
-export function compiledEdgeAlternatives(edges, typing) {
-    let result = [[]];
-    for (const edge of edges) {
-        const variants = compiledVariantsForEdge(edge, typing);
-        if (variants.length === 0)
-            return [];
-        result = result.flatMap((prefix) => variants.map((variant) => [...prefix, variant]));
-    }
-    return result;
-}
-function compiledVariantsForEdge(use, typing) {
-    const declaration = typing.context.classes.get(Key.of(use.pattern.class))?.value;
-    if (declaration === undefined || !isCompiledEdge(declaration))
-        return [];
-    const endpoints = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source, declaration.endpoints.target]
-        : declaration.endpoints;
-    const repeat = use.pattern.repeat ?? { min: 1, max: 1 };
-    const sourceKey = termKey(use.pattern.source, use.namespace);
-    const targetKey = termKey(use.pattern.target, use.namespace);
-    const variants = [];
-    for (let length = repeat.min; length <= repeat.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 reversed = Array.from({ length }, (_, index) => declaration.orientation === 'undirected' && (mask & (1 << index)) !== 0);
-            let valid = true;
-            for (let index = 0; index + 1 < length; index++) {
-                const incoming = reversed[index] ? endpoints[0] : endpoints[1];
-                const outgoing = reversed[index + 1] ? endpoints[1] : endpoints[0];
-                if (!typing.endpointsOverlap(incoming.accepts, outgoing.accepts))
-                    valid = false;
-            }
-            if (!valid)
-                continue;
-            const first = reversed[0] ? endpoints[1] : endpoints[0];
-            const last = reversed[length - 1] ? endpoints[0] : endpoints[1];
-            variants.push({
-                constraints: [
-                    [sourceKey, first.accepts],
-                    [targetKey, last.accepts],
-                ],
-                equalities: [],
-            });
-        }
-    }
-    return uniqueCompiledEdgeVariants(variants);
-}
-function uniqueCompiledEdgeVariants(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = `${value.constraints.map(([term, accepts]) => `${term}:${accepts.map(Key.of).sort(compareUnicode).join(',')}`).join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
-}

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

@@ -1,8 +0,0 @@
-export type * from './model/class.js';
-export type * from './model/data.js';
-export type * from './model/edge.js';
-export type * from './model/property.js';
-export { PropertyValues } from './property-values.js';
-export type { PropertyValuesOperations } from './property-values.js';
-export type * from './facets.js';
-export type * from './resolved.js';

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

@@ -1 +0,0 @@
-export { PropertyValues } from './property-values.js';

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

@@ -1,2 +0,0 @@
-export type * from './model/core.js';
-export type * from './resolved.js';

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,11 +0,0 @@
-/** 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, classifyValueKind, 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

@@ -1,8 +0,0 @@
-/** 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, classifyValueKind } 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';