@astrale-os/kernel-dsl 0.2.0-beta.3 → 0.2.0-beta.31

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/{schema → language/definition}/metadata.d.ts

@@ -10,4 +10,3 @@ export declare const icon: Readonly<{
     readonly minLength: 1;
     readonly maxLength: 8000;
 }>;
-//# sourceMappingURL=metadata.d.ts.map

package/dist/v1/{schema → language/definition}/metadata.js

@@ -10,4 +10,3 @@ export const icon = Object.freeze({
     minLength: 1,
     maxLength: 8000,
 });
-//# sourceMappingURL=metadata.js.map

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,26 @@
+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 { stateMachine } from './state/index.js';
+export type { EventOf, StateMachine, StateOf, StateTopology } from './state/index.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 { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } 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,3 @@
+export { stateMachine } from './state/index.js';
+export { PropertyValues } from './class/property-values.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './policy/model/policy.js';

package/dist/v1/{schema/policy/validation → language/policy/analysis}/branches.d.ts

@@ -1,8 +1,9 @@
-import type { ClassRef } from '../../reference.js';
-import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm } from '../ast.js';
+import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm, PolicyVariableSelector } from '../model/policy.js';
 export interface PatternBranch {
+    readonly terms: ReadonlyMap<string, PolicyPatternTerm>;
+    readonly equalities: readonly (readonly [string, string])[];
     readonly edges: readonly PatternEdgeUse[];
-    readonly variables: ReadonlyMap<string, ClassRef>;
+    readonly variables: ReadonlyMap<string, PolicyVariableSelector>;
     readonly requiredVariables: ReadonlySet<string>;
     readonly namespace: string;
 }
@@ -15,7 +16,5 @@ export declare function branchesOf(pattern: PolicyPatternExpression, namespace:
 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;
-/** A normalized branch targets either one object or both authored Edge endpoints, never a mixture. */
 export declare function targetMode(branch: PatternBranch): PolicyTargetMode | undefined;
 export declare function termKey(term: PolicyPatternTerm, namespace: string): string;
-//# sourceMappingURL=branches.d.ts.map

package/dist/v1/{schema/policy/validation → language/policy/analysis}/branches.js

@@ -1,3 +1,5 @@
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
 import { BRANCH_OVERFLOW } from './budgets.js';
 export function branchesOf(pattern, namespace) {
     const variables = collectVariableClasses(pattern, namespace);
@@ -25,7 +27,7 @@ export function isConnected(branch) {
     const mode = targetMode(branch);
     if (mode === undefined)
         return false;
-    const vertices = new Set(mode === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+    const vertices = new Set(['subject', ...branch.terms.keys()]);
     for (const variable of branch.requiredVariables)
         vertices.add(variable);
     const union = new UnionFind(vertices);
@@ -36,34 +38,39 @@ export function isConnected(branch) {
         union.add(target);
         union.join(source, target);
     }
+    for (const [left, right] of branch.equalities)
+        union.join(left, right);
     const root = union.find('subject');
     return [...vertices].every((vertex) => union.find(vertex) === root);
 }
-/** A normalized branch targets either one object or both authored Edge endpoints, never a mixture. */
 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';
-        }
+    for (const term of branch.terms.values()) {
+        object ||= term.kind === 'object';
+        source ||= term.kind === 'source';
+        target ||= term.kind === 'target';
     }
     if (object && !source && !target)
         return 'object';
-    if (!object && source && target)
+    if (!object && (source || target))
         return 'edge';
     return undefined;
 }
 export function termKey(term, namespace) {
-    return term.kind === 'variable' ? variableKey(namespace, term.id) : term.kind;
+    return term.kind === 'variable'
+        ? variableKey(namespace, term.id)
+        : term.kind === 'ref'
+            ? `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`
+            : term.kind;
 }
 function branchesForNode(pattern, namespace, variables) {
-    if (isEdge(pattern)) {
+    if ('source' in pattern) {
         return [
             {
+                terms: new Map([pattern.source, pattern.target].map((term) => [termKey(term, namespace), term])),
+                equalities: [],
                 edges: [{ pattern, namespace }],
                 variables,
                 requiredVariables: new Set(),
@@ -71,6 +78,24 @@ function branchesForNode(pattern, namespace, variables) {
             },
         ];
     }
+    if ('sameNode' in pattern) {
+        const terms = new Map([pattern.sameNode.left, pattern.sameNode.right].map((term) => [
+            termKey(term, namespace),
+            term,
+        ]));
+        return [
+            {
+                terms,
+                equalities: [
+                    [termKey(pattern.sameNode.left, namespace), termKey(pattern.sameNode.right, namespace)],
+                ],
+                edges: [],
+                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) => ({
@@ -78,12 +103,13 @@ function branchesForNode(pattern, namespace, variables) {
             requiredVariables: new Set([...branch.requiredVariables, ...direct]),
         }));
     }
-    const { key, values } = patternOperands(pattern);
-    const children = values.map((child) => branchesForNode(child, namespace, variables));
-    return key === 'allOf' ? branchProduct(children) : capBranches(children.flat());
+    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 {
+        terms: new Map(),
+        equalities: [],
         edges: [],
         variables: new Map(),
         requiredVariables: new Set(),
@@ -92,6 +118,8 @@ function emptyBranch() {
 }
 function mergeBranches(left, right) {
     return {
+        terms: new Map([...left.terms, ...right.terms]),
+        equalities: [...left.equalities, ...right.equalities],
         edges: [...left.edges, ...right.edges],
         variables: new Map([...left.variables, ...right.variables]),
         requiredVariables: new Set([...left.requiredVariables, ...right.requiredVariables]),
@@ -103,7 +131,7 @@ function collectVariableClasses(pattern, namespace) {
     const visit = (node) => {
         if ('exists' in node) {
             for (const variable of node.exists.nodes) {
-                result.set(variableKey(namespace, variable.variable.id), variable.class);
+                result.set(variableKey(namespace, variable.variable.id), policyVariableSelector(variable));
             }
             visit(node.exists.where);
         }
@@ -118,14 +146,6 @@ function collectVariableClasses(pattern, namespace) {
 function variableKey(namespace, id) {
     return `variable:${namespace}:${id}`;
 }
-function patternOperands(value) {
-    return 'allOf' in value
-        ? { key: 'allOf', values: value.allOf }
-        : { key: 'anyOf', values: value.anyOf };
-}
-function isEdge(value) {
-    return 'source' in value;
-}
 class UnionFind {
     #parents = new Map();
     constructor(values) {
@@ -152,4 +172,3 @@ class UnionFind {
             this.#parents.set(b, a);
     }
 }
-//# sourceMappingURL=branches.js.map

package/dist/v1/{schema/policy/validation → language/policy/analysis}/budgets.d.ts

@@ -1,5 +1,4 @@
-import type { PolicyCheckExpression } from '../ast.js';
-import type { PolicyValidationContext } from './context.js';
+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;
@@ -14,6 +13,4 @@ export interface CheckMeasure {
     readonly branches: number;
     readonly leaves: number;
 }
-export declare function validatePolicyBudgets(context: PolicyValidationContext): void;
 export declare function measureChecks(expression: PolicyCheckExpression): CheckMeasure;
-//# sourceMappingURL=budgets.d.ts.map

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 || 'sameNode' 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,4 @@
+export type * from './model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './model/policy.js';
+export type * from './resolved.js';
+export * from './normalization/normalize.js';

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

@@ -0,0 +1,2 @@
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './model/policy.js';
+export * from './normalization/normalize.js';

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

@@ -0,0 +1,115 @@
+import type { CoreRef, ClassRef, FunctionRef, PolicyRef, ViewRef, DefinitionBase, MethodAddress } 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;
+} | {
+    readonly kind: 'ref';
+    readonly ref: PolicyObjectRef;
+};
+/** Identity equality; both terms must resolve to one valid Node. */
+export interface PolicySameNode<Term> {
+    readonly sameNode: {
+        readonly left: Term;
+        readonly right: Term;
+    };
+}
+export interface ExactPolicyVariable {
+    readonly variable: {
+        readonly kind: 'variable';
+        readonly id: number;
+    };
+    readonly class: ClassRef;
+}
+export interface SelectedPolicyVariable {
+    readonly variable: {
+        readonly kind: 'variable';
+        readonly id: number;
+    };
+    readonly selector: {
+        readonly kind: 'any';
+    } | {
+        readonly kind: 'satisfies';
+        readonly class: ClassRef;
+    };
+}
+/**
+ * An existential Node binding. The class-bearing legacy form is deliberately retained as the
+ * canonical exact selector so persisted V1 DomainSchema documents keep their original meaning.
+ */
+export type PolicyVariable = ExactPolicyVariable | SelectedPolicyVariable;
+export type PolicyVariableSelector = {
+    readonly kind: 'exact';
+    readonly class: ClassRef;
+} | SelectedPolicyVariable['selector'];
+/** Resolve the semantic selector while preserving the legacy exact wire representation. */
+export declare function policyVariableSelector(variable: PolicyVariable): PolicyVariableSelector;
+/** Return the selector's referenced Class, when it has one. */
+export declare function policyVariableClass(variable: PolicyVariable): ClassRef | undefined;
+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 | PolicySameNode<PolicyPatternTerm> | {
+    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 | MethodAddress;
+/** Exact projected identity, including Class-owned Method declarations. */
+export declare function policyObjectKey(ref: PolicyObjectRef): string;
+export declare function policyObjectOrigin(ref: PolicyObjectRef): string;
+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;
+} | PolicySameNode<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,18 @@
+/** Resolve the semantic selector while preserving the legacy exact wire representation. */
+export function policyVariableSelector(variable) {
+    return 'class' in variable ? { kind: 'exact', class: variable.class } : variable.selector;
+}
+/** Return the selector's referenced Class, when it has one. */
+export function policyVariableClass(variable) {
+    const selector = policyVariableSelector(variable);
+    return selector.kind === 'any' ? undefined : selector.class;
+}
+/** Exact projected identity, including Class-owned Method declarations. */
+export function policyObjectKey(ref) {
+    return ref.kind === 'method'
+        ? `${ref.owner.origin}:class.${ref.owner.name}.method.${ref.name}`
+        : `${ref.origin}:${ref.kind}.${ref.name}`;
+}
+export function policyObjectOrigin(ref) {
+    return ref.kind === 'method' ? ref.owner.origin : ref.origin;
+}

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/{schema/policy → language/policy/normalization}/normalize.js

@@ -1,14 +1,15 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { schemaRefIndex, compareSchemaRefs } from '../reference.js';
+import { definitionRefIndex, compareDefinitionRefs } from '../../../addressing/ordering.js';
+import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
 const textEncoder = new TextEncoder();
-export function normalizePolicyDeclaration(value) {
+export function normalizePolicyExpression(value) {
     if ('match' in value) {
-        return withDescription(value, { match: normalizePolicyPattern(value.match) });
+        return { match: normalizePolicyPattern(value.match) };
     }
     if ('allOf' in value) {
-        return withDescription(value, { allOf: uniqueRefs(value.allOf) });
+        return { allOf: uniqueRefs(value.allOf) };
     }
-    return withDescription(value, { anyOf: uniqueRefs(value.anyOf) });
+    return { anyOf: uniqueRefs(value.anyOf) };
 }
 export function normalizePolicyPattern(value) {
     const rewritten = rewriteVariables(value, canonicalVariableIds(value));
@@ -17,6 +18,8 @@ export function normalizePolicyPattern(value) {
 export function normalizePolicyChecks(value) {
     if ('check' in value)
         return value;
+    if ('sameNode' in value)
+        return { sameNode: normalizeEquality(value.sameNode) };
     if ('allOf' in value) {
         const children = value.allOf.flatMap((child) => {
             const normalized = normalizePolicyChecks(child);
@@ -36,6 +39,8 @@ function policyCheckComposition(values) {
     return values;
 }
 function normalizePatternNode(value) {
+    if ('sameNode' in value)
+        return { sameNode: normalizeEquality(value.sameNode) };
     if (isEdge(value)) {
         const repeat = value.repeat;
         if (repeat?.min === 1 && repeat.max === 1) {
@@ -101,7 +106,7 @@ function canonicalVariableIds(value) {
 function collectDeclarations(value, result) {
     if ('exists' in value) {
         for (const node of value.exists.nodes) {
-            result.set(node.variable.id, schemaRefIndex(node.class));
+            result.set(node.variable.id, selectorSignature(node));
         }
         collectDeclarations(value.exists.where, result);
         return;
@@ -114,12 +119,20 @@ function collectDeclarations(value, result) {
             collectDeclarations(child, result);
 }
 function collectUses(value, target, colors, result) {
+    if ('sameNode' in value) {
+        const { left, right } = value.sameNode;
+        if (left.kind === 'variable' && left.id === target)
+            result.push(`same:${termColor(right, colors)}`);
+        if (right.kind === 'variable' && right.id === target)
+            result.push(`same:${termColor(left, colors)}`);
+        return;
+    }
     if (isEdge(value)) {
         if (value.source.kind === 'variable' && value.source.id === target) {
-            result.push(`s:${schemaRefIndex(value.class)}:${termColor(value.target, colors)}`);
+            result.push(`s:${definitionRefIndex(value.class)}:${termColor(value.target, colors)}`);
         }
         if (value.target.kind === 'variable' && value.target.id === target) {
-            result.push(`t:${schemaRefIndex(value.class)}:${termColor(value.source, colors)}`);
+            result.push(`t:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}`);
         }
         return;
     }
@@ -132,16 +145,29 @@ function collectUses(value, target, colors, result) {
 function termColor(term, colors) {
     if (term.kind === 'variable')
         return `variable:${colors.get(term.id) ?? '?'}`;
+    if (term.kind === 'ref')
+        return `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`;
     return term.kind;
 }
 function collectFirstUseKeys(value, colors, result, prefix = '$') {
+    if ('sameNode' in value) {
+        for (const term of [value.sameNode.left, value.sameNode.right]) {
+            if (term.kind !== 'variable')
+                continue;
+            const key = `${prefix}:same`;
+            const current = result.get(term.id);
+            if (current === undefined || key < current)
+                result.set(term.id, key);
+        }
+        return;
+    }
     if (isEdge(value)) {
         for (const [position, term] of [
             ['source', value.source],
             ['target', value.target],
         ]) {
             if (term.kind === 'variable') {
-                const key = `${prefix}:${schemaRefIndex(value.class)}:${position}`;
+                const key = `${prefix}:${definitionRefIndex(value.class)}:${position}`;
                 const current = result.get(term.id);
                 if (current === undefined || key < current)
                     result.set(term.id, key);
@@ -159,8 +185,10 @@ function collectFirstUseKeys(value, colors, result, prefix = '$') {
     children.forEach((child, index) => collectFirstUseKeys(child, colors, result, `${prefix}:${key}:${index}`));
 }
 function patternSignature(value, colors) {
+    if ('sameNode' in value)
+        return `same:${[termColor(value.sameNode.left, colors), termColor(value.sameNode.right, colors)].sort(compareUtf8Bytes).join(':')}`;
     if (isEdge(value)) {
-        return `edge:${schemaRefIndex(value.class)}:${termColor(value.source, colors)}:${termColor(value.target, colors)}:${value.repeat?.min ?? 1}:${value.repeat?.max ?? 1}`;
+        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
@@ -176,6 +204,13 @@ function patternSignature(value, colors) {
         .join('|')}`;
 }
 function rewriteVariables(value, ids) {
+    if ('sameNode' in value)
+        return {
+            sameNode: {
+                left: rewriteTerm(value.sameNode.left, ids),
+                right: rewriteTerm(value.sameNode.right, ids),
+            },
+        };
     if (isEdge(value)) {
         return {
             ...value,
@@ -186,10 +221,15 @@ function rewriteVariables(value, 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,
-                })),
+                nodes: value.exists.nodes.map((node) => {
+                    const variable = {
+                        kind: 'variable',
+                        id: ids.get(node.variable.id) ?? node.variable.id,
+                    };
+                    return 'class' in node
+                        ? { variable, class: node.class }
+                        : { variable, selector: node.selector };
+                }),
                 where: rewriteVariables(value.exists.where, ids),
             },
         };
@@ -198,12 +238,16 @@ function rewriteVariables(value, ids) {
         return { allOf: value.allOf.map((child) => rewriteVariables(child, ids)) };
     return { anyOf: value.anyOf.map((child) => rewriteVariables(child, ids)) };
 }
+function selectorSignature(node) {
+    const selector = policyVariableSelector(node);
+    return selector.kind === 'any' ? 'any' : `${selector.kind}:${definitionRefIndex(selector.class)}`;
+}
 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) => [schemaRefIndex(value), value]));
-    return [...byKey.values()].sort(compareSchemaRefs);
+    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]));
@@ -221,10 +265,11 @@ function compareUtf8Bytes(left, right) {
     }
     return a.length - b.length;
 }
-function withDescription(source, value) {
-    return source.description === undefined ? value : { description: source.description, ...value };
-}
 function isEdge(value) {
     return 'source' in value;
 }
-//# sourceMappingURL=normalize.js.map
+function normalizeEquality(value) {
+    return compareUtf8Bytes(json.serialize(value.left), json.serialize(value.right)) <= 0
+        ? value
+        : { left: value.right, right: value.left };
+}

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 {};

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

@@ -0,0 +1,3 @@
+export { stateMachine } from './machine.js';
+export type { EventOf, StateMachine, StateOf } from './machine.js';
+export type { StateTopology } from './topology.js';