@astrale-os/kernel-dsl 0.2.0-beta.45 → 0.2.0-beta.47

package/dist/v1/language/index.js

@@ -1,5 +1,6 @@
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
+export { valueProgramIncludes } from './value/inclusion/includes.js';
 export { stateMachine } from './state/index.js';
 export { PropertyValues } from './class/property-values.js';
 export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

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

@@ -1,4 +1,8 @@
 import type { PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
 export declare function normalizePolicyExpression(value: PolicyExpression): PolicyExpression;
+/**
+ * The fixed point of the single pass: a Pattern the single pass reproduces is returned unchanged,
+ * so the canonical form of every Pattern that was already stable keeps its bytes.
+ */
 export declare function normalizePolicyPattern(value: PolicyPatternExpression): PolicyPatternExpression;
 export declare function normalizePolicyChecks(value: PolicyCheckExpression): PolicyCheckExpression;

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

@@ -10,7 +10,32 @@ export function normalizePolicyExpression(value) {
     }
     return { anyOf: uniqueRefs(value.anyOf) };
 }
+/**
+ * Passes after the first, while one still changes the Pattern. A pass numbers variables by the
+ * operands as written, then merges duplicate operands and flattens nested ones, so its result can
+ * number differently when normalized again; the next pass numbers that result by itself. One
+ * further pass reached the fixed point on every Pattern tested, the other is margin, and a
+ * Pattern still changing keeps its last pass rather than failing.
+ */
+const SETTLING_PASSES = 2;
+/**
+ * The fixed point of the single pass: a Pattern the single pass reproduces is returned unchanged,
+ * so the canonical form of every Pattern that was already stable keeps its bytes.
+ */
 export function normalizePolicyPattern(value) {
+    let current = normalizePatternOnce(value);
+    let encoding = json.serialize(current);
+    for (let pass = 0; pass < SETTLING_PASSES; pass++) {
+        const next = normalizePatternOnce(current);
+        const nextEncoding = json.serialize(next);
+        if (nextEncoding === encoding)
+            return current;
+        current = next;
+        encoding = nextEncoding;
+    }
+    return current;
+}
+function normalizePatternOnce(value) {
     const rewritten = rewriteVariables(value, canonicalVariableIds(value));
     return normalizePatternNode(rewritten);
 }
@@ -71,7 +96,8 @@ function normalizePatternNode(value) {
 }
 function canonicalVariableIds(value) {
     const declarations = new Map();
-    collectDeclarations(value, declarations);
+    const depths = new Map();
+    collectDeclarations(value, declarations, depths);
     const uses = new Map([...declarations.keys()].map((id) => [id, []]));
     collectUses(value, uses);
     let colors = declarations;
@@ -89,8 +115,15 @@ function canonicalVariableIds(value) {
             break;
         colors = next;
     }
+    // Colors ignore where a variable is declared, so two variables can tie on color although
+    // different `exists` declare them, and which of them is numbered first decides which `exists`
+    // declares the smaller id. Their declaration depth tells them apart where it differs: operands of
+    // equal signature are ordered by their signature over depth-scoped colors before authored order,
+    // and the final order compares depth before the authored id (decision
+    // `policy-pattern-canonical-ties`). Both keys only order what color and first use leave tied.
+    const scoped = new Map([...colors].map(([id, color]) => [id, `${color}@${depths.get(id) ?? 0}`]));
     const firstUse = new Map();
-    collectFirstUseKeys(value, colors, firstUse);
+    collectFirstUseKeys(value, colors, scoped, firstUse);
     const ordered = [...declarations.keys()].sort((left, right) => {
         const byColor = compareUtf8Bytes(colors.get(left) ?? '', colors.get(right) ?? '');
         if (byColor !== 0)
@@ -98,26 +131,31 @@ function canonicalVariableIds(value) {
         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.
+        const byDepth = (depths.get(left) ?? 0) - (depths.get(right) ?? 0);
+        if (byDepth !== 0)
+            return byDepth;
+        // A remaining tie keeps the authored order of the ids: such variables were interchangeable in
+        // every admissible Pattern checked (`__tests__/canonical.test.ts`).
         return left - right;
     });
     return new Map(ordered.map((id, index) => [id, index]));
 }
-function collectDeclarations(value, result) {
+/** Each declared variable's selector signature and the number of `exists` around its declaration. */
+function collectDeclarations(value, result, depths, depth = 0) {
     if ('exists' in value) {
         for (const node of value.exists.nodes) {
             result.set(node.variable.id, selectorSignature(node));
+            depths.set(node.variable.id, depth + 1);
         }
-        collectDeclarations(value.exists.where, result);
+        collectDeclarations(value.exists.where, result, depths, depth + 1);
         return;
     }
     if ('allOf' in value)
         for (const child of value.allOf)
-            collectDeclarations(child, result);
+            collectDeclarations(child, result, depths, depth);
     if ('anyOf' in value)
         for (const child of value.anyOf)
-            collectDeclarations(child, result);
+            collectDeclarations(child, result, depths, depth);
 }
 function collectUses(value, result) {
     if ('sameNode' in value) {
@@ -155,7 +193,7 @@ function termColor(term, colors) {
         return `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`;
     return term.kind;
 }
-function collectFirstUseKeys(value, colors, result, prefix = '$') {
+function collectFirstUseKeys(value, colors, scoped, result, prefix = '$') {
     if ('sameNode' in value) {
         for (const term of [value.sameNode.left, value.sameNode.right]) {
             if (term.kind !== 'variable')
@@ -182,15 +220,15 @@ function collectFirstUseKeys(value, colors, result, prefix = '$') {
         return;
     }
     if ('exists' in value) {
-        collectFirstUseKeys(value.exists.where, colors, result, `${prefix}:exists`);
+        collectFirstUseKeys(value.exists.where, colors, scoped, result, `${prefix}:exists`);
         return;
     }
     const key = 'allOf' in value ? 'allOf' : 'anyOf';
     const operands = 'allOf' in value ? value.allOf : value.anyOf;
     const children = operands
-        .map((child) => [patternSignature(child, colors), child])
-        .sort(([left], [right]) => compareUtf8Bytes(left, right));
-    children.forEach(([, child], index) => collectFirstUseKeys(child, colors, result, `${prefix}:${key}:${index}`));
+        .map((child) => [patternSignature(child, colors), patternSignature(child, scoped), child])
+        .sort(([left, leftScoped], [right, rightScoped]) => compareUtf8Bytes(left, right) || compareUtf8Bytes(leftScoped, rightScoped));
+    children.forEach(([, , child], index) => collectFirstUseKeys(child, colors, scoped, result, `${prefix}:${key}:${index}`));
 }
 function patternSignature(value, colors) {
     if ('sameNode' in value)

package/dist/v1/language/value/inclusion/includes.d.ts

@@ -0,0 +1,9 @@
+import type { ValueProgram } from '../compile/model.js';
+/**
+ * Whether `outer` admits every value `inner` admits, under the one V1 evaluator.
+ *
+ * `true` is a proof. `false` only means that no rule proved inclusion: a caller must then decide
+ * the values themselves. Each rule relates one assertion of `outer` to evidence carried by
+ * `inner`; a finite `inner` is decided exactly by evaluating its candidates.
+ */
+export declare function valueProgramIncludes(outer: ValueProgram, inner: ValueProgram): boolean;