@astrale-os/kernel-dsl 0.1.5 → 0.2.0-beta.10

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

@@ -0,0 +1,20 @@
+import type { ClassRef, CoreRef, DefinitionBase } from '../../../addressing/index.js';
+import type { PropertyValues } from '../../class/property-values.js';
+export interface DomainEndpointRef {
+    readonly kind: 'domain';
+}
+export type CoreEndpointRef = CoreRef | DomainEndpointRef;
+export interface CoreDefinition extends DefinitionBase<CoreRef> {
+    readonly class: ClassRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreEdge {
+    readonly class: ClassRef;
+    readonly source: CoreEndpointRef;
+    readonly target: CoreEndpointRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreContent {
+    readonly nodes: Readonly<Record<string, CoreDefinition>>;
+    readonly edges: readonly CoreEdge[];
+}

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

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

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

@@ -0,0 +1,21 @@
+import type { DefinitionKey } from '../../addressing/index.js';
+import type { PropertyValues } from '../class/property-values.js';
+import type { ResolvedClass } from '../class/resolved.js';
+import type { CoreDefinition } from './model/core.js';
+export interface ResolvedCoreDefinition {
+    readonly ref: CoreDefinition['ref'];
+    readonly key: DefinitionKey<string, 'core'>;
+    readonly class: ResolvedClass<'node'>;
+    readonly properties: PropertyValues;
+    readonly definition: CoreDefinition;
+}
+export interface ResolvedDomainEndpoint {
+    readonly kind: 'domain';
+    readonly origin: string;
+}
+export interface ResolvedCoreEdge {
+    readonly class: ResolvedClass<'edge'>;
+    readonly source: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly target: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly properties: PropertyValues;
+}

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

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

package/dist/v1/language/definition/metadata.d.ts

@@ -0,0 +1,12 @@
+/** Exact V1 bound for optional human-facing declaration descriptions. */
+export declare const description: Readonly<{
+    readonly type: 'string';
+    readonly minLength: 1;
+    readonly maxLength: 1000;
+}>;
+/** Exact V1 bound for optional Node Class presentation icons. */
+export declare const icon: Readonly<{
+    readonly type: 'string';
+    readonly minLength: 1;
+    readonly maxLength: 8000;
+}>;

package/dist/v1/language/definition/metadata.js

@@ -0,0 +1,12 @@
+/** Exact V1 bound for optional human-facing declaration descriptions. */
+export const description = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    maxLength: 1000,
+});
+/** Exact V1 bound for optional Node Class presentation icons. */
+export const icon = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    maxLength: 8000,
+});

package/dist/v1/language/definition.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionDefinition } from './callable/model/callable.js';
+import type { ClassDefinition } from './class/model/class.js';
+import type { CoreDefinition } from './core/model/core.js';
+import type { PolicyDefinition } from './policy/model/policy.js';
+import type { ViewDefinition } from './view/model/view.js';
+/** Every named V1 product Definition. Property and Method remain Class-owned members. */
+export type Definition = ClassDefinition | FunctionDefinition | PolicyDefinition | ViewDefinition | CoreDefinition;

package/dist/v1/language/definition.js

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

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

@@ -0,0 +1,23 @@
+export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
+export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
+export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';
+export type { OrderingKind } from './value/ordering.js';
+export type * from './callable/model/callable.js';
+export type * from './callable/resolved.js';
+export type * from './class/model/class.js';
+export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
+export type * from './class/model/edge.js';
+export type * from './class/model/property.js';
+export type * from './class/resolved.js';
+export type * from './class/facets.js';
+export { PropertyValues } from './class/property-values.js';
+export type { PropertyValuesOperations } from './class/property-values.js';
+export type * from './core/model/core.js';
+export type * from './core/resolved.js';
+export type { Definition } from './definition.js';
+export type { ResolvedDefinition, ResolvedDefinitionOf } from './resolved.js';
+export type { Diagnostic, DiagnosticCode } from './validation/diagnostic.js';
+export type * from './policy/model/policy.js';
+export type * from './policy/resolved.js';
+export type * from './view/model/view.js';
+export type * from './view/resolved.js';

package/dist/v1/language/index.js

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

package/dist/v1/language/policy/analysis/branches.d.ts

@@ -0,0 +1,19 @@
+import type { ClassRef } from '../../../addressing/index.js';
+import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm } from '../model/policy.js';
+export interface PatternBranch {
+    readonly edges: readonly PatternEdgeUse[];
+    readonly variables: ReadonlyMap<string, ClassRef>;
+    readonly requiredVariables: ReadonlySet<string>;
+    readonly namespace: string;
+}
+export interface PatternEdgeUse {
+    readonly pattern: PolicyEdgePattern;
+    readonly namespace: string;
+}
+export type PolicyTargetMode = 'object' | 'edge';
+export declare function branchesOf(pattern: PolicyPatternExpression, namespace: string): readonly PatternBranch[];
+export declare function branchProduct(children: readonly (readonly PatternBranch[])[]): readonly PatternBranch[];
+export declare function capBranches(values: readonly PatternBranch[]): readonly PatternBranch[];
+export declare function isConnected(branch: PatternBranch): boolean;
+export declare function targetMode(branch: PatternBranch): PolicyTargetMode | undefined;
+export declare function termKey(term: PolicyPatternTerm, namespace: string): string;

package/dist/v1/language/policy/analysis/branches.js

@@ -0,0 +1,132 @@
+import { BRANCH_OVERFLOW } from './budgets.js';
+export function branchesOf(pattern, namespace) {
+    const variables = collectVariableClasses(pattern, namespace);
+    return branchesForNode(pattern, namespace, variables);
+}
+export function branchProduct(children) {
+    let result = [emptyBranch()];
+    for (const child of children) {
+        const next = [];
+        for (const left of result) {
+            for (const right of child) {
+                next.push(mergeBranches(left, right));
+                if (next.length >= BRANCH_OVERFLOW)
+                    return next;
+            }
+        }
+        result = next;
+    }
+    return result;
+}
+export function capBranches(values) {
+    return values.length <= BRANCH_OVERFLOW ? values : values.slice(0, BRANCH_OVERFLOW);
+}
+export function isConnected(branch) {
+    const mode = targetMode(branch);
+    if (mode === undefined)
+        return false;
+    const vertices = new Set(mode === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+    for (const variable of branch.requiredVariables)
+        vertices.add(variable);
+    const union = new UnionFind(vertices);
+    for (const edge of branch.edges) {
+        const source = termKey(edge.pattern.source, edge.namespace);
+        const target = termKey(edge.pattern.target, edge.namespace);
+        union.add(source);
+        union.add(target);
+        union.join(source, target);
+    }
+    const root = union.find('subject');
+    return [...vertices].every((vertex) => union.find(vertex) === root);
+}
+export function targetMode(branch) {
+    let object = false;
+    let source = false;
+    let target = false;
+    for (const edge of branch.edges) {
+        for (const term of [edge.pattern.source, edge.pattern.target]) {
+            object ||= term.kind === 'object';
+            source ||= term.kind === 'source';
+            target ||= term.kind === 'target';
+        }
+    }
+    if (object && !source && !target)
+        return 'object';
+    if (!object && source && target)
+        return 'edge';
+    return undefined;
+}
+export function termKey(term, namespace) {
+    return term.kind === 'variable' ? variableKey(namespace, term.id) : term.kind;
+}
+function branchesForNode(pattern, namespace, variables) {
+    if ('source' in pattern) {
+        return [{ edges: [{ pattern, namespace }], variables, requiredVariables: new Set(), namespace }];
+    }
+    if ('exists' in pattern) {
+        const direct = new Set(pattern.exists.nodes.map((node) => variableKey(namespace, node.variable.id)));
+        return branchesForNode(pattern.exists.where, namespace, variables).map((branch) => ({
+            ...branch,
+            requiredVariables: new Set([...branch.requiredVariables, ...direct]),
+        }));
+    }
+    const children = ('allOf' in pattern ? pattern.allOf : pattern.anyOf).map((child) => branchesForNode(child, namespace, variables));
+    return 'allOf' in pattern ? branchProduct(children) : capBranches(children.flat());
+}
+function emptyBranch() {
+    return { edges: [], variables: new Map(), requiredVariables: new Set(), namespace: '$' };
+}
+function mergeBranches(left, right) {
+    return {
+        edges: [...left.edges, ...right.edges],
+        variables: new Map([...left.variables, ...right.variables]),
+        requiredVariables: new Set([...left.requiredVariables, ...right.requiredVariables]),
+        namespace: `${left.namespace}&${right.namespace}`,
+    };
+}
+function collectVariableClasses(pattern, namespace) {
+    const result = new Map();
+    const visit = (node) => {
+        if ('exists' in node) {
+            for (const variable of node.exists.nodes) {
+                result.set(variableKey(namespace, variable.variable.id), variable.class);
+            }
+            visit(node.exists.where);
+        }
+        else if ('allOf' in node)
+            node.allOf.forEach(visit);
+        else if ('anyOf' in node)
+            node.anyOf.forEach(visit);
+    };
+    visit(pattern);
+    return result;
+}
+function variableKey(namespace, id) {
+    return `variable:${namespace}:${id}`;
+}
+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/language/policy/analysis/budgets.d.ts

@@ -0,0 +1,16 @@
+import type { PolicyCheckExpression } from '../model/policy.js';
+export declare const MAX_PATTERN_DEPTH = 4;
+export declare const MAX_BRANCHES = 8;
+export declare const MAX_VARIABLES = 4;
+export declare const MAX_EDGES = 6;
+export declare const MAX_REPEAT = 3;
+export declare const MAX_DOMAINS = 4;
+export declare const MAX_CHECK_DEPTH = 4;
+export declare const MAX_CHECK_LEAVES = 8;
+export declare const BRANCH_OVERFLOW: number;
+export interface CheckMeasure {
+    readonly depth: number;
+    readonly branches: number;
+    readonly leaves: number;
+}
+export declare function measureChecks(expression: PolicyCheckExpression): CheckMeasure;

package/dist/v1/language/policy/analysis/budgets.js

@@ -0,0 +1,25 @@
+export const MAX_PATTERN_DEPTH = 4;
+export const MAX_BRANCHES = 8;
+export const MAX_VARIABLES = 4;
+export const MAX_EDGES = 6;
+export const MAX_REPEAT = 3;
+export const MAX_DOMAINS = 4;
+export const MAX_CHECK_DEPTH = 4;
+export const MAX_CHECK_LEAVES = 8;
+export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
+export function measureChecks(expression) {
+    if ('check' in expression)
+        return { depth: 1, branches: 1, leaves: 1 };
+    const children = ('allOf' in expression ? expression.allOf : expression.anyOf).map(measureChecks);
+    const branches = 'allOf' in expression
+        ? children.reduce((value, child) => saturatingProduct(value, child.branches), 1)
+        : children.reduce((value, child) => Math.min(BRANCH_OVERFLOW, value + child.branches), 0);
+    return {
+        depth: 1 + Math.max(0, ...children.map((child) => child.depth)),
+        branches,
+        leaves: children.reduce((value, child) => value + child.leaves, 0),
+    };
+}
+function saturatingProduct(left, right) {
+    return Math.min(BRANCH_OVERFLOW, left * right);
+}

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

@@ -0,0 +1,3 @@
+export type * from './model/policy.js';
+export type * from './resolved.js';
+export * from './normalization/normalize.js';

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

@@ -0,0 +1 @@
+export * from './normalization/normalize.js';

package/dist/v1/language/policy/model/policy.d.ts

@@ -0,0 +1,77 @@
+import type { CoreRef, ClassRef, FunctionRef, PolicyRef, ViewRef, DefinitionBase } from '../../../addressing/index.js';
+export type PolicyPatternTerm = {
+    readonly kind: 'subject';
+} | {
+    readonly kind: 'object';
+} | {
+    readonly kind: 'source';
+} | {
+    readonly kind: 'target';
+} | {
+    readonly kind: 'variable';
+    readonly id: number;
+};
+export interface PolicyVariable {
+    readonly variable: {
+        readonly kind: 'variable';
+        readonly id: number;
+    };
+    readonly class: ClassRef;
+}
+export interface PolicyRepeat {
+    readonly min: number;
+    readonly max: number;
+}
+export interface PolicyEdgePattern {
+    readonly source: PolicyPatternTerm;
+    readonly class: ClassRef;
+    readonly target: PolicyPatternTerm;
+    readonly repeat?: PolicyRepeat;
+}
+export type PolicyPatternExpression = PolicyEdgePattern | {
+    readonly exists: {
+        readonly nodes: readonly PolicyVariable[];
+        readonly where: PolicyPatternExpression;
+    };
+} | {
+    readonly allOf: readonly PolicyPatternExpression[];
+} | {
+    readonly anyOf: readonly PolicyPatternExpression[];
+};
+export type PolicyExpression = {
+    readonly match: PolicyPatternExpression;
+} | {
+    readonly allOf: readonly PolicyRef[];
+} | {
+    readonly anyOf: readonly PolicyRef[];
+};
+export interface PolicyDefinition extends DefinitionBase<PolicyRef> {
+    readonly expression: PolicyExpression;
+    readonly description?: string;
+}
+/** Local Domain members whose installed projection resolves through one exact member Path. */
+export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | CoreRef;
+export type PolicyCheckObject = {
+    readonly kind: 'self';
+} | {
+    readonly kind: 'input';
+    readonly field: string;
+} | {
+    readonly kind: 'ref';
+    readonly ref: PolicyObjectRef;
+};
+/** Versioned Policy-check grammar specialized by each lifecycle boundary. */
+export type PolicyCheckExpression<Policy = PolicyRef, Object = PolicyCheckObject> = {
+    readonly check: Policy;
+    readonly object: Object;
+} | {
+    readonly allOf: readonly [
+        PolicyCheckExpression<Policy, Object>,
+        ...PolicyCheckExpression<Policy, Object>[]
+    ];
+} | {
+    readonly anyOf: readonly [
+        PolicyCheckExpression<Policy, Object>,
+        ...PolicyCheckExpression<Policy, Object>[]
+    ];
+};

package/dist/v1/language/policy/model/policy.js

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

package/dist/v1/language/policy/normalization/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
+export declare function normalizePolicyExpression(value: PolicyExpression): PolicyExpression;
+export declare function normalizePolicyPattern(value: PolicyPatternExpression): PolicyPatternExpression;
+export declare function normalizePolicyChecks(value: PolicyCheckExpression): PolicyCheckExpression;

package/dist/v1/language/policy/normalization/normalize.js

@@ -0,0 +1,226 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { definitionRefIndex, compareDefinitionRefs } from '../../../addressing/ordering.js';
+const textEncoder = new TextEncoder();
+export function normalizePolicyExpression(value) {
+    if ('match' in value) {
+        return { match: normalizePolicyPattern(value.match) };
+    }
+    if ('allOf' in value) {
+        return { allOf: uniqueRefs(value.allOf) };
+    }
+    return { anyOf: uniqueRefs(value.anyOf) };
+}
+export function normalizePolicyPattern(value) {
+    const rewritten = rewriteVariables(value, canonicalVariableIds(value));
+    return normalizePatternNode(rewritten);
+}
+export function normalizePolicyChecks(value) {
+    if ('check' in value)
+        return value;
+    if ('allOf' in value) {
+        const children = value.allOf.flatMap((child) => {
+            const normalized = normalizePolicyChecks(child);
+            return 'allOf' in normalized ? normalized.allOf : [normalized];
+        });
+        return { allOf: policyCheckComposition(uniqueJson(children)) };
+    }
+    const children = value.anyOf.flatMap((child) => {
+        const normalized = normalizePolicyChecks(child);
+        return 'anyOf' in normalized ? normalized.anyOf : [normalized];
+    });
+    return { anyOf: policyCheckComposition(uniqueJson(children)) };
+}
+function policyCheckComposition(values) {
+    // Structural routing may carry an invalid empty array into semantic validation;
+    // validateChecks reports it before the DomainSchema can be accepted.
+    return values;
+}
+function normalizePatternNode(value) {
+    if (isEdge(value)) {
+        const repeat = value.repeat;
+        if (repeat?.min === 1 && repeat.max === 1) {
+            const { repeat: _omitted, ...edge } = value;
+            return edge;
+        }
+        return value;
+    }
+    if ('exists' in value) {
+        return {
+            exists: {
+                nodes: [...value.exists.nodes].sort((left, right) => left.variable.id - right.variable.id),
+                where: normalizePatternNode(value.exists.where),
+            },
+        };
+    }
+    if ('allOf' in value) {
+        const children = value.allOf.flatMap((child) => {
+            const normalized = normalizePatternNode(child);
+            return 'allOf' in normalized ? normalized.allOf : [normalized];
+        });
+        return { allOf: uniqueJson(children) };
+    }
+    const children = value.anyOf.flatMap((child) => {
+        const normalized = normalizePatternNode(child);
+        return 'anyOf' in normalized ? normalized.anyOf : [normalized];
+    });
+    return { anyOf: uniqueJson(children) };
+}
+function canonicalVariableIds(value) {
+    const declarations = new Map();
+    collectDeclarations(value, declarations);
+    const colors = new Map(declarations);
+    for (let iteration = 0; iteration < declarations.size + 1; iteration++) {
+        const next = new Map();
+        for (const id of declarations.keys()) {
+            const uses = [];
+            collectUses(value, id, colors, uses);
+            uses.sort(compareUtf8Bytes);
+            next.set(id, `${declarations.get(id) ?? ''}|${uses.join('|')}`);
+        }
+        if ([...next].every(([id, color]) => colors.get(id) === color))
+            break;
+        colors.clear();
+        for (const [id, color] of next)
+            colors.set(id, color);
+    }
+    const firstUse = new Map();
+    collectFirstUseKeys(value, colors, firstUse);
+    const ordered = [...declarations.keys()].sort((left, right) => {
+        const byColor = compareUtf8Bytes(colors.get(left) ?? '', colors.get(right) ?? '');
+        if (byColor !== 0)
+            return byColor;
+        const byUse = compareUtf8Bytes(firstUse.get(left) ?? '', firstUse.get(right) ?? '');
+        if (byUse !== 0)
+            return byUse;
+        // A remaining tie is an automorphic binder class: assigning either first
+        // yields the same recursively sorted canonical Pattern.
+        return left - right;
+    });
+    return new Map(ordered.map((id, index) => [id, index]));
+}
+function collectDeclarations(value, result) {
+    if ('exists' in value) {
+        for (const node of value.exists.nodes) {
+            result.set(node.variable.id, definitionRefIndex(node.class));
+        }
+        collectDeclarations(value.exists.where, result);
+        return;
+    }
+    if ('allOf' in value)
+        for (const child of value.allOf)
+            collectDeclarations(child, result);
+    if ('anyOf' in value)
+        for (const child of value.anyOf)
+            collectDeclarations(child, result);
+}
+function collectUses(value, target, colors, result) {
+    if (isEdge(value)) {
+        if (value.source.kind === 'variable' && value.source.id === target) {
+            result.push(`s:${definitionRefIndex(value.class)}:${termColor(value.target, colors)}`);
+        }
+        if (value.target.kind === 'variable' && value.target.id === target) {
+            result.push(`t:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}`);
+        }
+        return;
+    }
+    if ('exists' in value)
+        return collectUses(value.exists.where, target, colors, result);
+    const children = 'allOf' in value ? value.allOf : value.anyOf;
+    for (const child of children)
+        collectUses(child, target, colors, result);
+}
+function termColor(term, colors) {
+    if (term.kind === 'variable')
+        return `variable:${colors.get(term.id) ?? '?'}`;
+    return term.kind;
+}
+function collectFirstUseKeys(value, colors, result, prefix = '$') {
+    if (isEdge(value)) {
+        for (const [position, term] of [
+            ['source', value.source],
+            ['target', value.target],
+        ]) {
+            if (term.kind === 'variable') {
+                const key = `${prefix}:${definitionRefIndex(value.class)}:${position}`;
+                const current = result.get(term.id);
+                if (current === undefined || key < current)
+                    result.set(term.id, key);
+            }
+        }
+        return;
+    }
+    if ('exists' in value) {
+        collectFirstUseKeys(value.exists.where, colors, result, `${prefix}:exists`);
+        return;
+    }
+    const key = 'allOf' in value ? 'allOf' : 'anyOf';
+    const operands = 'allOf' in value ? value.allOf : value.anyOf;
+    const children = [...operands].sort((left, right) => compareUtf8Bytes(patternSignature(left, colors), patternSignature(right, colors)));
+    children.forEach((child, index) => collectFirstUseKeys(child, colors, result, `${prefix}:${key}:${index}`));
+}
+function patternSignature(value, colors) {
+    if (isEdge(value)) {
+        return `edge:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}:${termColor(value.target, colors)}:${value.repeat?.min ?? 1}:${value.repeat?.max ?? 1}`;
+    }
+    if ('exists' in value) {
+        return `exists:${value.exists.nodes
+            .map((node) => colors.get(node.variable.id) ?? '')
+            .sort(compareUtf8Bytes)
+            .join(',')}:${patternSignature(value.exists.where, colors)}`;
+    }
+    const key = 'allOf' in value ? 'allOf' : 'anyOf';
+    const operands = 'allOf' in value ? value.allOf : value.anyOf;
+    return `${key}:${operands
+        .map((child) => patternSignature(child, colors))
+        .sort(compareUtf8Bytes)
+        .join('|')}`;
+}
+function rewriteVariables(value, ids) {
+    if (isEdge(value)) {
+        return {
+            ...value,
+            source: rewriteTerm(value.source, ids),
+            target: rewriteTerm(value.target, ids),
+        };
+    }
+    if ('exists' in value) {
+        return {
+            exists: {
+                nodes: value.exists.nodes.map((node) => ({
+                    variable: { kind: 'variable', id: ids.get(node.variable.id) ?? node.variable.id },
+                    class: node.class,
+                })),
+                where: rewriteVariables(value.exists.where, ids),
+            },
+        };
+    }
+    if ('allOf' in value)
+        return { allOf: value.allOf.map((child) => rewriteVariables(child, ids)) };
+    return { anyOf: value.anyOf.map((child) => rewriteVariables(child, ids)) };
+}
+function rewriteTerm(value, ids) {
+    return value.kind === 'variable' ? { kind: 'variable', id: ids.get(value.id) ?? value.id } : value;
+}
+function uniqueRefs(values) {
+    const byKey = new Map(values.map((value) => [definitionRefIndex(value), value]));
+    return [...byKey.values()].sort(compareDefinitionRefs);
+}
+function uniqueJson(values) {
+    const byEncoding = new Map(values.map((value) => [json.serialize(value), value]));
+    return [...byEncoding.entries()]
+        .sort(([left], [right]) => compareUtf8Bytes(left, right))
+        .map(([, value]) => value);
+}
+function compareUtf8Bytes(left, right) {
+    const a = textEncoder.encode(left);
+    const b = textEncoder.encode(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 isEdge(value) {
+    return 'source' in value;
+}

package/dist/v1/language/policy/resolved.d.ts

@@ -0,0 +1,9 @@
+import type { DefinitionKey, PolicyRef } from '../../addressing/index.js';
+import type { PolicyDefinition } from './model/policy.js';
+export interface ResolvedPolicy {
+    readonly ref: PolicyRef;
+    readonly key: DefinitionKey<string, 'policy'>;
+    readonly expression: PolicyDefinition['expression'];
+    readonly description?: PolicyDefinition['description'];
+    readonly definition: PolicyDefinition;
+}

package/dist/v1/language/policy/resolved.js

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

package/dist/v1/language/resolved.d.ts

@@ -0,0 +1,10 @@
+import type { DefinitionRef } from '../addressing/index.js';
+import type { ResolvedFunction } from './callable/resolved.js';
+import type { AnyResolvedClass } from './class/resolved.js';
+import type { ResolvedCoreDefinition } from './core/resolved.js';
+import type { ResolvedPolicy } from './policy/resolved.js';
+import type { ResolvedView } from './view/resolved.js';
+export type ResolvedDefinition = AnyResolvedClass | ResolvedFunction | ResolvedPolicy | ResolvedView | ResolvedCoreDefinition;
+export type ResolvedDefinitionOf<Kind extends DefinitionRef['kind']> = Extract<ResolvedDefinition, {
+    readonly ref: DefinitionRef<Kind>;
+}>;

package/dist/v1/language/resolved.js

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