@rkmodules/rules 0.0.171 → 0.0.172

package/dist/index.esm.mjs

@@ -751,6 +751,50 @@ function sameRecord(a, b) {
     var otherKeys = Object.keys(b);
     return keys.length === otherKeys.length && keys.every(function (key, i) { return key === otherKeys[i] && Object.is(a[key], b[key]); });
 }
+/** Compare immutable graph configuration, never runtime dependency trees.
+ * Preserve key order (interpolation observes it); opaque objects retain identity
+ * semantics. Cyclic configurations conservatively miss instead of recursing forever.
+ */
+function sameConfiguration(a, b, ancestors) {
+    if (Object.is(a, b))
+        return true;
+    if (!a || !b || typeof a !== "object" || typeof b !== "object")
+        return false;
+    var prototype = Object.getPrototypeOf(a);
+    if (prototype !== Object.getPrototypeOf(b))
+        return false;
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+    }
+    else if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    if ((ancestors === null || ancestors === void 0 ? void 0 : ancestors.has(a)) || (ancestors === null || ancestors === void 0 ? void 0 : ancestors.has(b)))
+        return false;
+    var keys = Reflect.ownKeys(a);
+    var otherKeys = Reflect.ownKeys(b);
+    if (keys.length !== otherKeys.length)
+        return false;
+    ancestors = ancestors || new Set();
+    ancestors.add(a);
+    ancestors.add(b);
+    try {
+        return keys.every(function (key, i) {
+            if (key !== otherKeys[i])
+                return false;
+            var left = Object.getOwnPropertyDescriptor(a, key);
+            var right = Object.getOwnPropertyDescriptor(b, key);
+            // Accessors may read external state; do not invoke them for comparison.
+            return "value" in left && "value" in right &&
+                left.enumerable === right.enumerable &&
+                sameConfiguration(left.value, right.value, ancestors);
+        });
+    }
+    finally {
+        ancestors.delete(a);
+        ancestors.delete(b);
+    }
+}
 function put(map, key, value) {
     map.delete(key);
     map.set(key, value);
@@ -848,7 +892,8 @@ var ExecutionCache = /** @class */ (function () {
             finally { if (e_2) throw e_2.error; }
         }
     };
-    ExecutionCache.prototype.interpolate = function (run, path, raw, scope) {
+    ExecutionCache.prototype.interpolate = function (run, path, raw, scope, configuration) {
+        if (configuration === void 0) { configuration = false; }
         var key = cachePath(path);
         run.visited.add(key);
         if (!this.current(run))
@@ -860,13 +905,16 @@ var ExecutionCache = /** @class */ (function () {
             // Deep references depend on the base tree's identity. Unrelated scope
             // entries never invalidate this port; a fresh execution context is fine.
             var old = previous === null || previous === void 0 ? void 0 : previous.ports.get(name);
-            var paths = old && Object.is(old.raw, value) ? old.paths :
+            var sameRaw = old && (configuration
+                ? sameConfiguration(old.raw, value) : Object.is(old.raw, value));
+            var paths = sameRaw ? old.paths :
                 getReferencePaths(value).map(function (path) { return path.split(".").slice(0, 2).join("."); });
             var dependencies = paths.map(function (path) { return getValue$1(scope, path); });
-            var same = old && Object.is(old.raw, value) &&
+            var same = sameRaw &&
                 old.dependencies.length === dependencies.length &&
                 dependencies.every(function (value, i) { return Object.is(value, old.dependencies[i]); });
-            var port = same ? old : {
+            // Remember the latest raw reference so subsequent runs take the fast path.
+            var port = same ? __assign(__assign({}, old), { raw: value }) : {
                 raw: value,
                 paths: paths,
                 dependencies: dependencies,
@@ -891,8 +939,10 @@ var ExecutionCache = /** @class */ (function () {
             return;
         var entry = run.scope[kind].get(key);
         if (entry && entry.definition === fn && entry.impl === fn.impl &&
-            sameRecord(entry.metadata, this.key(call)) && sameRecord(entry.inputs, inputs) &&
-            sameRecord(entry.params, params)) {
+            sameConfiguration(entry.metadata, this.key(call)) && sameRecord(entry.inputs, inputs) &&
+            sameConfiguration(entry.params, params)) {
+            entry.metadata = this.key(call);
+            entry.params = __assign({}, params);
             put(run.scope[kind], key, entry);
             return entry;
         }
@@ -3642,7 +3692,7 @@ var Engine = /** @class */ (function () {
                         if (!fn)
                             throw new Error("function ".concat(fnCall.name, " not found in index"));
                         callPath = __spreadArray(__spreadArray([], __read(path), false), [name_1], false);
-                        inputs_1 = this.cache.interpolate(run, __spreadArray(__spreadArray([], __read(callPath), false), ["$inputs"], false), fnCall.inputs || {}, context.scope);
+                        inputs_1 = this.cache.interpolate(run, __spreadArray(__spreadArray([], __read(callPath), false), ["$inputs"], false), fnCall.inputs || {}, context.scope, true);
                         params_1 = fnCall.params || {};
                         context.calls[name_1] = fnCall;
                         context.inputs[name_1] = inputs_1;
@@ -3666,7 +3716,7 @@ var Engine = /** @class */ (function () {
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
                     case 8:
-                        result = this.cache.interpolate(run, __spreadArray(__spreadArray([], __read(path), false), ["$outputs"], false), node.outputs || {}, context.scope);
+                        result = this.cache.interpolate(run, __spreadArray(__spreadArray([], __read(path), false), ["$outputs"], false), node.outputs || {}, context.scope, true);
                         endTime = performance.now();
                         response = {
                             name: node.name,