@astrale-os/kernel-dsl 0.2.0-beta.29 → 0.2.0-beta.30

package/dist/v1/builder/callable/authoring.d.ts

@@ -14,6 +14,7 @@ declare const CALLABLE_OUTPUT: unique symbol;
 declare const CALLABLE_PROJECTION: unique symbol;
 declare const CALLABLE_PROJECTION_VALUE: unique symbol;
 export interface CallablePolicyContext {
+    sameNode(left: PolicyCheckObject, right: PolicyCheckObject): PolicyCheckExpression;
     readonly input: Readonly<Record<string, Extract<PolicyCheckObject, {
         readonly kind: 'input';
     }>>>;

package/dist/v1/builder/lowering/callable.js

@@ -70,34 +70,38 @@ export class V1CallableCompiler {
             },
         });
         const self = callableSelf();
-        return Object.freeze({
-            input,
-            self,
-            ref: (member) => callableRef(this.context.resolvePolicyObject(member, `${placement.pointer}/policy/ref`)),
-            check: (policy, object) => {
-                const resolvedObject = callablePolicyObject(object);
-                let admittedObject = resolvedObject;
-                if (resolvedObject.kind === 'self') {
-                    if (placement.kind === 'function' || isStatic) {
-                        fail('BUILDER_POLICY_SELF', `${placement.pointer}/policy`, 'self is available only to a non-static Node Method.');
-                    }
+        const admitObject = (object) => {
+            const resolvedObject = callablePolicyObject(object);
+            let admittedObject = resolvedObject;
+            if (resolvedObject.kind === 'self') {
+                if (placement.kind === 'function' || isStatic) {
+                    fail('BUILDER_POLICY_SELF', `${placement.pointer}/policy`, 'self is available only to a non-static Node Method.');
                 }
-                else if (resolvedObject.kind === 'input') {
-                    if (isRequiredDirectNodePath(inputSchema, resolvedObject.field)) {
-                        // The field contract is admitted below as-is.
-                    }
-                    else {
-                        fail('BUILDER_POLICY_INPUT', `${placement.pointer}/policy`, `input.${resolvedObject.field} is not one direct required single-Node path field.`);
-                    }
+            }
+            else if (resolvedObject.kind === 'input') {
+                if (isRequiredDirectNodePath(inputSchema, resolvedObject.field)) {
+                    // The field contract is admitted below as-is.
                 }
                 else {
-                    admittedObject = callableRef(this.context.resolvePolicyObject(resolvedObject.ref, `${placement.pointer}/policy/ref`));
+                    fail('BUILDER_POLICY_INPUT', `${placement.pointer}/policy`, `input.${resolvedObject.field} is not one direct required single-Node path field.`);
                 }
-                return {
-                    check: this.context.resolvePolicy(policy, `${placement.pointer}/policy/check`),
-                    object: admittedObject,
-                };
-            },
+            }
+            else {
+                admittedObject = callableRef(this.context.resolvePolicyObject(resolvedObject.ref, `${placement.pointer}/policy/ref`));
+            }
+            return admittedObject;
+        };
+        return Object.freeze({
+            input,
+            self,
+            ref: (member) => callableRef(this.context.resolvePolicyObject(member, `${placement.pointer}/policy/ref`)),
+            sameNode: (left, right) => ({
+                sameNode: { left: admitObject(left), right: admitObject(right) },
+            }),
+            check: (policy, object) => ({
+                check: this.context.resolvePolicy(policy, `${placement.pointer}/policy/check`),
+                object: admitObject(object),
+            }),
             allOf: (...expressions) => {
                 nonEmpty(expressions, `${placement.pointer}/policy/allOf`);
                 return { allOf: expressions };

package/dist/v1/builder/lowering/policy.js

@@ -20,6 +20,7 @@ export class V1PolicyCompiler {
             };
         }
         const match = input.match(createPatternContext({
+            resolveObject: (member, refPointer) => this.context.resolvePolicyObject(member, refPointer),
             resolveEdgeClass: (definition, refPointer) => this.context.resolveEdgeClass(definition, refPointer),
             resolveNodeClass: (definition, refPointer) => this.context.resolveNodeClass(definition, refPointer),
             pointer,

package/dist/v1/builder/policy/authoring.d.ts

@@ -1,5 +1,6 @@
 import type { ClassRef } from '../../addressing/index.js';
-import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm } from '../../language/policy/model/policy.js';
+import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
+import type { PolicyObjectInput } from '../callable/authoring.js';
 import type { EdgeClass, NodeClass } from '../class/authoring.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
@@ -21,6 +22,8 @@ export interface PolicyExistsContext {
     readonly node: PolicyNodeBinder;
 }
 export interface PolicyPatternContext {
+    ref(member: PolicyObjectInput): CanonicalPolicyPatternTerm;
+    sameNode(left: CanonicalPolicyPatternTerm, right: CanonicalPolicyPatternTerm): PolicyPatternExpression;
     readonly subject: CanonicalPolicyPatternTerm;
     readonly object: CanonicalPolicyPatternTerm;
     readonly source: CanonicalPolicyPatternTerm;
@@ -50,6 +53,7 @@ export interface PolicyBuilder {
 export declare function policyDeclaration(value: Policy): PolicyDeclaration;
 export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
+    readonly resolveObject: (value: PolicyObjectInput, pointer: string) => PolicyObjectRef;
     readonly resolveEdgeClass: (value: Lazy<EdgeClass>, pointer: string) => ClassRef;
     readonly resolveNodeClass: (value: Lazy<NodeClass>, pointer: string) => ClassRef;
     readonly pointer: string;

package/dist/v1/builder/policy/authoring.js

@@ -32,6 +32,11 @@ export function createPatternContext(options) {
     const source = Object.freeze({ kind: 'source' });
     const target = Object.freeze({ kind: 'target' });
     const context = {
+        ref: (member) => ({
+            kind: 'ref',
+            ref: options.resolveObject(member, `${options.pointer}/match/ref`),
+        }),
+        sameNode: (left, right) => ({ sameNode: { left, right } }),
         subject,
         object,
         source,

package/dist/v1/compiled/admission/accept.js

@@ -421,6 +421,14 @@ function policyPattern(input, depth, path) {
     if (depth > 64)
         invalid('Policy pattern depth', undefined, path);
     const value = object(input, 'Policy pattern', path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        exact(value, ['sameNode'], 'Policy equality', path);
+        const pair = object(value.sameNode, 'Policy equality', `${path}/sameNode`);
+        exact(pair, ['left', 'right'], 'Policy equality operands', `${path}/sameNode`);
+        policyTerm(pair.left, false, `${path}/sameNode/left`);
+        policyTerm(pair.right, false, `${path}/sameNode/right`);
+        return;
+    }
     if (Object.hasOwn(value, 'exists')) {
         exact(value, ['exists'], 'Policy exists', path);
         const existsPath = `${path}/exists`;
@@ -484,6 +492,11 @@ function policyPattern(input, depth, path) {
 }
 function policyTerm(input, variableOnly, path) {
     const value = object(input, 'Policy pattern term', path);
+    if (!variableOnly && value.kind === 'ref') {
+        exact(value, ['kind', 'ref'], 'Policy reference term', path);
+        definitionRef(value.ref, undefined, 'Policy reference term', `${path}/ref`);
+        return;
+    }
     if (value.kind === 'variable') {
         exact(value, ['kind', 'id'], 'Policy variable term', path);
         integer(value.id, 'Policy variable id', `${path}/id`);
@@ -502,23 +515,18 @@ function policyCheck(input, depth, path) {
     if (depth > 64)
         invalid('Callable Policy depth', undefined, path);
     const value = object(input, 'Callable Policy', path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        exact(value, ['sameNode'], 'Callable equality', path);
+        const pair = object(value.sameNode, 'Callable equality', `${path}/sameNode`);
+        exact(pair, ['left', 'right'], 'Callable equality operands', `${path}/sameNode`);
+        policyCheckObject(pair.left, `${path}/sameNode/left`);
+        policyCheckObject(pair.right, `${path}/sameNode/right`);
+        return;
+    }
     if (Object.hasOwn(value, 'check')) {
         exact(value, ['check', 'object'], 'Callable Policy check', path);
         definitionRef(value.check, 'policy', 'Callable Policy ref', `${path}/check`);
-        const objectPath = `${path}/object`;
-        const target = object(value.object, 'Callable Policy object', objectPath);
-        if (target.kind === 'self')
-            exact(target, ['kind'], 'Callable Policy self', objectPath);
-        else if (target.kind === 'input') {
-            exact(target, ['kind', 'field'], 'Callable Policy input', objectPath);
-            memberName(target.field, 'Callable Policy input field', `${objectPath}/field`);
-        }
-        else if (target.kind === 'ref') {
-            exact(target, ['kind', 'ref'], 'Callable Policy object ref', objectPath);
-            definitionRef(target.ref, undefined, 'Callable Policy object ref', `${objectPath}/ref`);
-        }
-        else
-            invalid('Callable Policy object', undefined, `${objectPath}/kind`);
+        policyCheckObject(value.object, `${path}/object`);
         return;
     }
     const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
@@ -530,6 +538,21 @@ function policyCheck(input, depth, path) {
     for (const [index, expression] of expressions.entries())
         policyCheck(expression, depth + 1, `${memberPath}/${index}`);
 }
+function policyCheckObject(input, objectPath) {
+    const target = object(input, 'Callable Policy object', objectPath);
+    if (target.kind === 'self')
+        exact(target, ['kind'], 'Callable Policy self', objectPath);
+    else if (target.kind === 'input') {
+        exact(target, ['kind', 'field'], 'Callable Policy input', objectPath);
+        memberName(target.field, 'Callable Policy input field', `${objectPath}/field`);
+    }
+    else if (target.kind === 'ref') {
+        exact(target, ['kind', 'ref'], 'Callable Policy object ref', objectPath);
+        definitionRef(target.ref, undefined, 'Callable Policy object ref', `${objectPath}/ref`);
+    }
+    else
+        invalid('Callable Policy object', undefined, `${objectPath}/kind`);
+}
 function coreEndpoint(input, label, path) {
     const value = object(input, label, path);
     if (value.kind === 'domain')

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

@@ -347,6 +347,11 @@ function validatePolicyExpression(context, entry, expression, path, local) {
     }
 }
 function validatePattern(context, expression, path, scope, declared) {
+    if ('sameNode' in expression) {
+        validatePolicyTerm(expression.sameNode.left, `${path}/sameNode/left`, scope);
+        validatePolicyTerm(expression.sameNode.right, `${path}/sameNode/right`, scope);
+        return;
+    }
     if ('source' in expression) {
         if (context.classes.get(Key.of(expression.class))?.value.kind !== 'edge')
             fail(`${path}/class`, 'Policy pattern Class must resolve to an Edge Class.');
@@ -410,21 +415,22 @@ function validatePolicyCycles(entry, local, entryIndex) {
         visit(name);
 }
 function validateCallablePolicy(context, entry, expression, inputIndex, fields, instanceMethod, path) {
-    if ('check' in expression) {
-        if (expression.check.origin !== entry.origin ||
-            context.policies.get(Key.of(expression.check)) === undefined)
+    if ('check' in expression || 'sameNode' in expression) {
+        if ('check' in expression &&
+            (expression.check.origin !== entry.origin ||
+                context.policies.get(Key.of(expression.check)) === undefined))
             fail(`${path}/check`, 'Callable Policy must reference a local named Policy.');
-        const object = expression.object;
-        if (object.kind === 'self' && !instanceMethod)
-            fail(`${path}/object`, 'self is valid only for an instance Method.');
-        if (object.kind === 'input') {
-            if (fields === undefined ||
-                fields[object.field] === undefined ||
-                !isSingleNodePathField(context, entry, inputIndex, object.field))
-                fail(`${path}/object`, 'Callable Policy input target must be a direct required single-Node Path field.');
+        const objects = 'check' in expression ? { object: expression.object } : expression.sameNode;
+        for (const [side, object] of Object.entries(objects)) {
+            if (object.kind === 'self' && !instanceMethod)
+                fail(`${path}/${side}`, 'self is valid only for an instance Method.');
+            if (object.kind === 'input' &&
+                (fields === undefined ||
+                    fields[object.field] === undefined ||
+                    !isSingleNodePathField(context, entry, inputIndex, object.field))) {
+                fail(`${path}/${side}`, 'Callable Policy input target must be a direct required single-Node Path field.');
+            }
         }
-        // validateClosure already establishes that object refs name existing local
-        // or exact direct-dependency Definitions. Named Policy execution stays local.
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;
@@ -555,6 +561,8 @@ function validateCallablePolicyTyping(context, typing, entry, expression, input,
         fail(path, 'Callable Policy checks exceed the V1 depth, branch, or leaf budget.');
     }
     const visit = (value, pointer) => {
+        if ('sameNode' in value)
+            return;
         if (!('check' in value)) {
             const children = 'allOf' in value ? value.allOf : value.anyOf;
             children.forEach((child, index) => visit(child, `${pointer}/${index}`));
@@ -668,11 +676,15 @@ class CompiledPolicyTyping {
         const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
         for (const key of branch.variables.keys())
             terms.add(key);
+        for (const key of branch.terms.keys())
+            terms.add(key);
         for (const edge of branch.edges) {
             terms.add(termKey(edge.pattern.source, edge.namespace));
             terms.add(termKey(edge.pattern.target, edge.namespace));
         }
         const union = new CompiledUnionFind(terms);
+        for (const [left, right] of branch.equalities)
+            union.join(left, right);
         for (const variant of variants)
             for (const [left, right] of variant.equalities)
                 union.join(left, right);
@@ -716,6 +728,11 @@ class CompiledPolicyTyping {
                 ? this.applyExact(candidates, contract.ref)
                 : uniqueCompiledCandidates(this.allNodeClasses.flatMap((ref) => this.applyExact(candidates, ref)));
         }
+        const referenced = branch.terms.get(term);
+        if (referenced?.kind === 'ref') {
+            const contract = callableObjectContracts(this.context, this.entry, 0, undefined, referenced)?.[0];
+            return contract?.kind === 'exact' ? this.applyExact(candidates, contract.ref) : [];
+        }
         const selector = branch.variables.get(term);
         if (selector === undefined)
             return [];
@@ -870,8 +887,25 @@ function measureCompiledPolicy(origin, name, normalized, visiting) {
     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' ? [term.ref.origin] : []),
+            ]),
+        };
     if ('source' in pattern)
-        return { depth: 1, edgeCounts: [1], domains: new Set([origin, pattern.class.origin]) };
+        return {
+            depth: 1,
+            edgeCounts: [1],
+            domains: new Set([
+                origin,
+                pattern.class.origin,
+                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [term.ref.origin] : []),
+            ]),
+        };
     if ('exists' in pattern) {
         const child = measureCompiledPattern(pattern.exists.where, origin);
         return {

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

@@ -1,5 +1,7 @@
 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, PolicyVariableSelector>;
     readonly requiredVariables: ReadonlySet<string>;

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

@@ -1,3 +1,4 @@
+import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { policyVariableSelector } from '../model/policy.js';
 import { BRANCH_OVERFLOW } from './budgets.js';
 export function branchesOf(pattern, namespace) {
@@ -26,14 +27,7 @@ export function isConnected(branch) {
     const mode = targetMode(branch);
     if (mode === undefined)
         return false;
-    const vertices = new Set(['subject']);
-    for (const edge of branch.edges) {
-        for (const term of [edge.pattern.source, edge.pattern.target]) {
-            if (term.kind === 'object' || term.kind === 'source' || term.kind === 'target') {
-                vertices.add(term.kind);
-            }
-        }
-    }
+    const vertices = new Set(['subject', ...branch.terms.keys()]);
     for (const variable of branch.requiredVariables)
         vertices.add(variable);
     const union = new UnionFind(vertices);
@@ -44,6 +38,8 @@ 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);
 }
@@ -51,12 +47,10 @@ 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';
@@ -65,11 +59,42 @@ export function targetMode(branch) {
     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:${definitionRefIndex(term.ref)}`
+            : term.kind;
 }
 function branchesForNode(pattern, namespace, variables) {
     if ('source' in pattern) {
-        return [{ edges: [{ pattern, namespace }], variables, requiredVariables: new Set(), namespace }];
+        return [
+            {
+                terms: new Map([pattern.source, pattern.target].map((term) => [termKey(term, namespace), term])),
+                equalities: [],
+                edges: [{ pattern, namespace }],
+                variables,
+                requiredVariables: new Set(),
+                namespace,
+            },
+        ];
+    }
+    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)));
@@ -82,10 +107,19 @@ function branchesForNode(pattern, namespace, variables) {
     return 'allOf' in pattern ? branchProduct(children) : capBranches(children.flat());
 }
 function emptyBranch() {
-    return { edges: [], variables: new Map(), requiredVariables: new Set(), namespace: '$' };
+    return {
+        terms: new Map(),
+        equalities: [],
+        edges: [],
+        variables: new Map(),
+        requiredVariables: new Set(),
+        namespace: '$',
+    };
 }
 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]),

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

@@ -8,7 +8,7 @@ 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)
+    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

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

@@ -10,7 +10,17 @@ export type PolicyPatternTerm = {
 } | {
     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';
@@ -53,7 +63,7 @@ export interface PolicyEdgePattern {
     readonly target: PolicyPatternTerm;
     readonly repeat?: PolicyRepeat;
 }
-export type PolicyPatternExpression = PolicyEdgePattern | {
+export type PolicyPatternExpression = PolicyEdgePattern | PolicySameNode<PolicyPatternTerm> | {
     readonly exists: {
         readonly nodes: readonly PolicyVariable[];
         readonly where: PolicyPatternExpression;
@@ -89,7 +99,7 @@ export type PolicyCheckObject = {
 export type PolicyCheckExpression<Policy = PolicyRef, Object = PolicyCheckObject> = {
     readonly check: Policy;
     readonly object: Object;
-} | {
+} | PolicySameNode<Object> | {
     readonly allOf: readonly [
         PolicyCheckExpression<Policy, Object>,
         ...PolicyCheckExpression<Policy, Object>[]

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

@@ -18,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);
@@ -37,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) {
@@ -115,6 +119,14 @@ 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:${definitionRefIndex(value.class)}:${termColor(value.target, colors)}`);
@@ -133,9 +145,22 @@ 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:${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],
@@ -160,6 +185,8 @@ 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:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}:${termColor(value.target, colors)}:${value.repeat?.min ?? 1}:${value.repeat?.max ?? 1}`;
     }
@@ -177,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,
@@ -234,3 +268,8 @@ function compareUtf8Bytes(left, right) {
 function isEdge(value) {
     return 'source' in value;
 }
+function normalizeEquality(value) {
+    return compareUtf8Bytes(json.serialize(value.left), json.serialize(value.right)) <= 0
+        ? value
+        : { left: value.right, right: value.left };
+}

package/dist/v1/schema/resolution/origins.js

@@ -79,7 +79,16 @@ function collectPolicyExpressionRefs(expression, add) {
     refs.forEach(add);
 }
 function collectPolicyPatternRefs(expression, add) {
+    if ('sameNode' in expression) {
+        for (const term of [expression.sameNode.left, expression.sameNode.right])
+            if (term.kind === 'ref')
+                add(term.ref);
+        return;
+    }
     if ('source' in expression) {
+        for (const term of [expression.source, expression.target])
+            if (term.kind === 'ref')
+                add(term.ref);
         add(expression.class);
         return;
     }
@@ -96,6 +105,12 @@ function collectPolicyPatternRefs(expression, add) {
     children.forEach((child) => collectPolicyPatternRefs(child, add));
 }
 function collectPolicyCheckRefs(expression, add) {
+    if ('sameNode' in expression) {
+        for (const term of [expression.sameNode.left, expression.sameNode.right])
+            if (term.kind === 'ref')
+                add(term.ref);
+        return;
+    }
     if ('check' in expression) {
         add(expression.check);
         if (expression.object.kind === 'ref')

package/dist/v1/schema/validation/domain.structure.js

@@ -101,6 +101,7 @@ const policyPatternNodeSchema = discriminatedUnion('kind', [
     policyPatternSourceSchema,
     policyPatternTargetSchema,
     policyPatternVariableSchema,
+    strictObject({ kind: literal('ref'), ref: policyObjectRefSchema }),
 ]);
 const policyVariableSelectorSchema = discriminatedUnion('kind', [
     strictObject({ kind: literal('any') }),
@@ -115,6 +116,9 @@ const policyRepeatSchema = strictObject({
     max: number().int().min(0).max(3),
 });
 const policyPatternExpressionSchema = lazy(() => union([
+    strictObject({
+        sameNode: strictObject({ left: policyPatternNodeSchema, right: policyPatternNodeSchema }),
+    }),
     strictObject({
         source: policyPatternNodeSchema,
         class: classRefSchema,
@@ -146,6 +150,9 @@ const policyCheckObjectSchema = discriminatedUnion('kind', [
     }),
 ]);
 const policyCheckExpressionSchema = lazy(() => union([
+    strictObject({
+        sameNode: strictObject({ left: policyCheckObjectSchema, right: policyCheckObjectSchema }),
+    }),
     strictObject({
         check: policyRefSchema,
         object: policyCheckObjectSchema,

package/dist/v1/schema/validation/policy/budgets.js

@@ -16,7 +16,7 @@ export function validatePolicyBudgets(context) {
         }
         const edgeMaximum = Math.max(0, ...measure.edgeCounts);
         if (edgeMaximum > MAX_EDGES) {
-            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} Edge predicates; the maximum is ${MAX_EDGES}.`);
+            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} graph predicates; the maximum is ${MAX_EDGES}.`);
         }
         if (measure.domains.size > MAX_DOMAINS) {
             context.add('PL_BUDGET', pointer, `Expanded Pattern references ${measure.domains.size} Domains; the maximum is ${MAX_DOMAINS}.`);
@@ -46,11 +46,24 @@ function measurePolicy(context, name, visiting) {
     return combineMeasures('allOf' in declaration ? 'allOf' : 'anyOf', children);
 }
 function measurePattern(pattern, ownOrigin) {
+    if ('sameNode' in pattern)
+        return {
+            depth: 1,
+            edgeCounts: [1],
+            domains: new Set([
+                ownOrigin,
+                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [term.ref.origin] : []),
+            ]),
+        };
     if (isEdge(pattern)) {
         return {
             depth: 1,
             edgeCounts: [1],
-            domains: new Set([ownOrigin, pattern.class.origin]),
+            domains: new Set([
+                ownOrigin,
+                pattern.class.origin,
+                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [term.ref.origin] : []),
+            ]),
         };
     }
     if ('exists' in pattern) {

package/dist/v1/schema/validation/policy/objects.d.ts

@@ -0,0 +1,4 @@
+import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
+import type { PolicyValidationContext } from './context.js';
+import type { ObjectContract } from './typing.js';
+export declare function referenceContracts(validation: PolicyValidationContext, ref: PolicyObjectRef, pointer: string): readonly ObjectContract[] | undefined;

package/dist/v1/schema/validation/policy/objects.js

@@ -0,0 +1,64 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+const formatDefinitionRef = Key.of;
+const KERNEL_ORIGIN = 'kernel.astrale.ai';
+const PROJECTION_CLASS = nodeClassRef('Class');
+const PROJECTION_FUNCTION = nodeClassRef('Function');
+const PROJECTION_POLICY = nodeClassRef('Policy');
+const PROJECTION_VIEW = nodeClassRef('View');
+export function referenceContracts(validation, ref, pointer) {
+    const candidate = validation.environment.candidate;
+    const local = ref.origin === candidate.origin;
+    const direct = Object.values(candidate.dependencies).some((entry) => entry.origin === ref.origin);
+    const owner = local
+        ? candidate
+        : direct
+            ? validation.environment.dependencies.get(ref.origin)
+            : undefined;
+    if (owner === undefined)
+        return invalidPolicyObjectRef(validation, ref, pointer);
+    switch (ref.kind) {
+        case 'class': {
+            const resolved = validation.environment.resolve(ref);
+            return resolved?.ref.kind === ref.kind
+                ? [{ kind: 'exact', ref: PROJECTION_CLASS }]
+                : invalidPolicyObjectRef(validation, ref, pointer);
+        }
+        case 'function':
+            return owner.functions[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
+        case 'policy':
+            return owner.policies[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_POLICY }];
+        case 'view':
+            return owner.views[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_VIEW }];
+        case 'core': {
+            const node = owner.core.nodes[ref.name];
+            if (node === undefined)
+                return invalidPolicyObjectRef(validation, ref, pointer);
+            const resolved = validation.environment.resolve(node.class);
+            const analyzed = validation.analysis.definitions.get(definitionRefIndex(node.class));
+            // Core validation owns invalid Core Class diagnostics. Avoid adding Policy noise for
+            // a Node that cannot materialize in the first place.
+            if (node.class.origin !== owner.origin ||
+                resolved?.ref.kind !== 'class' ||
+                resolved.kind !== 'node' ||
+                analyzed === undefined) {
+                return undefined;
+            }
+            return [{ kind: 'exact', ref: node.class }];
+        }
+    }
+    return invalidPolicyObjectRef(validation, ref, pointer);
+}
+function invalidPolicyObjectRef(validation, ref, pointer) {
+    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local or direct-dependency projected Policy object.`, formatDefinitionRef(ref));
+    return undefined;
+}
+function nodeClassRef(name) {
+    return { origin: KERNEL_ORIGIN, kind: 'class', name };
+}

package/dist/v1/schema/validation/policy/references.js

@@ -3,6 +3,7 @@ import { policyVariableClass } from '../../../language/policy/model/policy.js';
 import { normalizePolicyExpression, normalizePolicyPattern, } from '../../../language/policy/normalization/normalize.js';
 import { MAX_REPEAT, MAX_VARIABLES } from './budgets.js';
 import { escapePointer } from './context.js';
+import { referenceContracts } from './objects.js';
 export function validatePolicyReferences(context) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.policies)) {
         const pointer = `/policies/${escapePointer(name)}`;
@@ -44,6 +45,11 @@ function validateMatch(context, name, pattern, pointer) {
     }
 }
 function validatePatternNode(context, pattern, pointer, scope, declarations, uses) {
+    if ('sameNode' in pattern) {
+        validateTerm(context, pattern.sameNode.left, `${pointer}/sameNode/left`, scope, uses);
+        validateTerm(context, pattern.sameNode.right, `${pointer}/sameNode/right`, scope, uses);
+        return;
+    }
     if (isEdge(pattern)) {
         context.resolveEdge(pattern.class, `${pointer}/class`);
         validateTerm(context, pattern.source, `${pointer}/source`, scope, uses);
@@ -93,6 +99,8 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
     values.forEach((child, index) => validatePatternNode(context, child, `${pointer}/${key}/${index}`, scope, declarations, uses));
 }
 function validateTerm(context, term, pointer, scope, uses) {
+    if (term.kind === 'ref')
+        referenceContracts(context, term.ref, pointer);
     if (term.kind === 'variable') {
         if (!scope.has(term.id)) {
             context.add('PL_VARIABLE_SCOPE', pointer, `Variable ${term.id} is free, escaped, or outside its defining exists scope.`);

package/dist/v1/schema/validation/policy/typing.js

@@ -2,6 +2,7 @@ import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { branchesOf, branchProduct, capBranches, targetMode, termKey, } from '../../../language/policy/analysis/branches.js';
 import { MAX_REPEAT } from './budgets.js';
 import { escapePointer } from './context.js';
+import { referenceContracts } from './objects.js';
 export class PolicyTyping {
     context;
     constructor(context) {
@@ -83,11 +84,15 @@ export class PolicyTyping {
         const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
         for (const key of branch.variables.keys())
             terms.add(key);
+        for (const key of branch.terms.keys())
+            terms.add(key);
         for (const edge of branch.edges) {
             terms.add(termKey(edge.pattern.source, edge.namespace));
             terms.add(termKey(edge.pattern.target, edge.namespace));
         }
         const union = new UnionFind(terms);
+        for (const [left, right] of branch.equalities)
+            union.join(left, right);
         for (const variant of variants) {
             for (const [left, right] of variant.equalities)
                 union.join(left, right);
@@ -136,6 +141,11 @@ export class PolicyTyping {
             }
             return candidates;
         }
+        const referenced = branch.terms.get(term);
+        if (referenced?.kind === 'ref') {
+            const contract = referenceContracts(this.context, referenced.ref, '/policies')?.[0];
+            return contract?.kind === 'exact' ? this.#applyExact(candidates, contract.ref) : [];
+        }
         const selector = branch.variables.get(term);
         if (selector === undefined)
             return [];

package/dist/v1/schema/validation/policy/uses.js

@@ -4,13 +4,9 @@ import { normalizePolicyChecks } from '../../../language/policy/normalization/no
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
 import { MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, measureChecks } from './budgets.js';
 import { escapePointer } from './context.js';
+import { referenceContracts } from './objects.js';
 import { contractOfNodeDefinition } from './typing.js';
 const formatDefinitionRef = Key.of;
-const KERNEL_ORIGIN = 'kernel.astrale.ai';
-const PROJECTION_CLASS = nodeClassRef('Class');
-const PROJECTION_FUNCTION = nodeClassRef('Function');
-const PROJECTION_POLICY = nodeClassRef('Policy');
-const PROJECTION_VIEW = nodeClassRef('View');
 export function validateReadUses(context, typing) {
     validateClassPolicyUses(context, typing, 'read');
 }
@@ -95,6 +91,18 @@ function validateChecks(validation, typing, expression, context) {
     visitChecks(validation, typing, normalized, context, context.pointer);
 }
 function visitChecks(validation, typing, expression, context, pointer) {
+    if ('sameNode' in expression) {
+        for (const [side, object] of Object.entries(expression.sameNode)) {
+            const objectPointer = `${pointer}/sameNode/${side}`;
+            if (object.kind === 'self')
+                selfContracts(validation, context, objectPointer);
+            else if (object.kind === 'input')
+                inputContracts(validation, context, object.field, objectPointer);
+            else
+                referenceContracts(validation, object.ref, objectPointer);
+        }
+        return;
+    }
     if ('check' in expression) {
         if (!validation.resolvePolicy(expression.check, `${pointer}/check`))
             return;
@@ -120,59 +128,6 @@ function visitChecks(validation, typing, expression, context, pointer) {
     }
     values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`));
 }
-function referenceContracts(validation, ref, pointer) {
-    const candidate = validation.environment.candidate;
-    const local = ref.origin === candidate.origin;
-    const direct = Object.values(candidate.dependencies).some((entry) => entry.origin === ref.origin);
-    const owner = local
-        ? candidate
-        : direct
-            ? validation.environment.dependencies.get(ref.origin)
-            : undefined;
-    if (owner === undefined)
-        return invalidPolicyObjectRef(validation, ref, pointer);
-    switch (ref.kind) {
-        case 'class': {
-            const resolved = validation.environment.resolve(ref);
-            return resolved?.ref.kind === ref.kind
-                ? [{ kind: 'exact', ref: PROJECTION_CLASS }]
-                : invalidPolicyObjectRef(validation, ref, pointer);
-        }
-        case 'function':
-            return owner.functions[ref.name] === undefined
-                ? invalidPolicyObjectRef(validation, ref, pointer)
-                : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
-        case 'policy':
-            return owner.policies[ref.name] === undefined
-                ? invalidPolicyObjectRef(validation, ref, pointer)
-                : [{ kind: 'exact', ref: PROJECTION_POLICY }];
-        case 'view':
-            return owner.views[ref.name] === undefined
-                ? invalidPolicyObjectRef(validation, ref, pointer)
-                : [{ kind: 'exact', ref: PROJECTION_VIEW }];
-        case 'core': {
-            const node = owner.core.nodes[ref.name];
-            if (node === undefined)
-                return invalidPolicyObjectRef(validation, ref, pointer);
-            const resolved = validation.environment.resolve(node.class);
-            const analyzed = validation.analysis.definitions.get(definitionRefIndex(node.class));
-            // Core validation owns invalid Core Class diagnostics. Avoid adding Policy noise for
-            // a Node that cannot materialize in the first place.
-            if (node.class.origin !== owner.origin ||
-                resolved?.ref.kind !== 'class' ||
-                resolved.kind !== 'node' ||
-                analyzed === undefined) {
-                return undefined;
-            }
-            return [contractOfNodeDefinition(node.class)];
-        }
-    }
-    return invalidPolicyObjectRef(validation, ref, pointer);
-}
-function invalidPolicyObjectRef(validation, ref, pointer) {
-    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local or direct-dependency projected Policy object.`, formatDefinitionRef(ref));
-    return undefined;
-}
 function selfContracts(validation, context, pointer) {
     if (!context.instanceMethod || context.receiver === undefined) {
         validation.add('PL_USE', pointer, 'self is valid only for a Node instance Method.');
@@ -238,6 +193,3 @@ function checkOperands(value) {
         ? { key: 'allOf', values: value.allOf }
         : { key: 'anyOf', values: value.anyOf };
 }
-function nodeClassRef(name) {
-    return { origin: KERNEL_ORIGIN, kind: 'class', name };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.29",
+  "version": "0.2.0-beta.30",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {