@astrale-os/kernel-dsl 0.2.0-beta.41 → 0.2.0-beta.42

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

@@ -1,7 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { definitionRefIndex, compareDefinitionRefs } from '../../../addressing/ordering.js';
 import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
-const textEncoder = new TextEncoder();
 export function normalizePolicyExpression(value) {
     if ('match' in value) {
         return { match: normalizePolicyPattern(value.match) };
@@ -73,20 +72,22 @@ function normalizePatternNode(value) {
 function canonicalVariableIds(value) {
     const declarations = new Map();
     collectDeclarations(value, declarations);
-    const colors = new Map(declarations);
+    const uses = new Map([...declarations.keys()].map((id) => [id, []]));
+    collectUses(value, uses);
+    let colors = declarations;
+    // Color refinement. Each round names a variable by its declaration and the sorted colors of its
+    // uses, then replaces every name by its fixed-width rank among the round's names. Ranks keep the
+    // names' byte order, so a round decides what it would decide over uncompressed names, while a
+    // name stays linear in its variable's degree instead of embedding every neighbour's name. A
+    // round that reproduces its input is a fixed point of the next ones.
     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('|')}`);
-        }
+        const next = rank(new Map([...uses].map(([id, list]) => {
+            const named = list.map(([prefix, term]) => `${prefix}${termColor(term, colors)}`);
+            return [id, `${declarations.get(id) ?? ''}|${named.sort(compareUtf8Bytes).join('|')}`];
+        })));
         if ([...next].every(([id, color]) => colors.get(id) === color))
             break;
-        colors.clear();
-        for (const [id, color] of next)
-            colors.set(id, color);
+        colors = next;
     }
     const firstUse = new Map();
     collectFirstUseKeys(value, colors, firstUse);
@@ -118,29 +119,34 @@ function collectDeclarations(value, result) {
         for (const child of value.anyOf)
             collectDeclarations(child, result);
 }
-function collectUses(value, target, colors, result) {
+function collectUses(value, 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)}`);
+        if (left.kind === 'variable')
+            result.get(left.id)?.push(['same:', right]);
+        if (right.kind === 'variable')
+            result.get(right.id)?.push(['same:', left]);
         return;
     }
     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)}`);
-        }
+        const edge = definitionRefIndex(value.class);
+        if (value.source.kind === 'variable')
+            result.get(value.source.id)?.push([`s:${edge}:`, value.target]);
+        if (value.target.kind === 'variable')
+            result.get(value.target.id)?.push([`t:${edge}:`, value.source]);
         return;
     }
     if ('exists' in value)
-        return collectUses(value.exists.where, target, colors, result);
+        return collectUses(value.exists.where, result);
     const children = 'allOf' in value ? value.allOf : value.anyOf;
     for (const child of children)
-        collectUses(child, target, colors, result);
+        collectUses(child, result);
+}
+function rank(names) {
+    const distinct = [...new Set(names.values())].sort(compareUtf8Bytes);
+    const width = String(distinct.length).length;
+    const ranks = new Map(distinct.map((name, index) => [name, String(index).padStart(width, '0')]));
+    return new Map([...names].map(([id, name]) => [id, ranks.get(name) ?? '']));
 }
 function termColor(term, colors) {
     if (term.kind === 'variable')
@@ -181,8 +187,10 @@ function collectFirstUseKeys(value, colors, result, prefix = '$') {
     }
     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}`));
+    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}`));
 }
 function patternSignature(value, colors) {
     if ('sameNode' in value)
@@ -255,15 +263,24 @@ function uniqueJson(values) {
         .sort(([left], [right]) => compareUtf8Bytes(left, right))
         .map(([, value]) => value);
 }
+/**
+ * UTF-8 byte order without encoding: it is code-point order, which UTF-16 code units already follow
+ * except that surrogates (U+10000 and above) sort after U+E000–U+FFFF.
+ */
 function compareUtf8Bytes(left, right) {
-    const a = textEncoder.encode(left);
-    const b = textEncoder.encode(right);
-    const length = Math.min(a.length, b.length);
+    const length = Math.min(left.length, right.length);
     for (let index = 0; index < length; index++) {
-        if (a[index] !== b[index])
-            return (a[index] ?? 0) - (b[index] ?? 0);
+        const a = left.charCodeAt(index);
+        const b = right.charCodeAt(index);
+        if (a !== b)
+            return codePointOrder(a) - codePointOrder(b);
     }
-    return a.length - b.length;
+    return left.length - right.length;
+}
+function codePointOrder(unit) {
+    if (unit >= 0xd800 && unit <= 0xdfff)
+        return unit + 0x2000;
+    return unit >= 0xe000 ? unit - 0x800 : unit;
 }
 function isEdge(value) {
     return 'source' in value;

package/package.json

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