@rkmodules/rules 0.0.171 → 0.0.173

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;
         }
@@ -3528,10 +3578,11 @@ var Engine = /** @class */ (function () {
     };
     Engine.prototype.executeCall = function (fn_1, call_1, inputs_1, params_1, context_1, name_1, executionId_1, run_1, path_1) {
         return __awaiter(this, arguments, void 0, function (fn, call, inputs, params, context, name, executionId, run, path, root) {
-            var graphRunner, kind, hit, startTime, start, result, createdAt, impl, _a, endTime, event;
+            var graphRunner, kind, hit, startTime, start, result, createdAt, started_1, activate, impl, endTime, event;
+            var _this = this;
             if (root === void 0) { root = false; }
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         this.cache.visit(run, path);
                         graphRunner = this.graphRunners.get(fn);
@@ -3560,24 +3611,36 @@ var Engine = /** @class */ (function () {
                         createdAt = hit.info.createdAt;
                         return [3 /*break*/, 8];
                     case 1:
-                        context.activations[name] = true;
+                        context.activations[name] = false;
+                        started_1 = false;
+                        activate = function () {
+                            var _a;
+                            if (started_1)
+                                return;
+                            started_1 = true;
+                            (_a = run.onPrimitiveExecution) === null || _a === void 0 ? void 0 : _a.call(run);
+                            context.activations[name] = true;
+                            _this.fireEvent("functionCall", start);
+                        };
                         impl = fn.impl;
-                        console.log("Executing function call: ".concat(name));
-                        _b.label = 2;
+                        _a.label = 2;
                     case 2:
-                        _b.trys.push([2, , 7, 8]);
-                        this.fireEvent("functionCall", start);
+                        _a.trys.push([2, , 7, 8]);
                         if (!graphRunner) return [3 /*break*/, 4];
-                        return [4 /*yield*/, graphRunner(inputs, params, run, path)];
+                        return [4 /*yield*/, graphRunner(inputs, params, __assign(__assign({}, run), { onPrimitiveExecution: activate }), path)];
                     case 3:
-                        _a = (_b.sent()).result;
+                        // Traversal alone is not activity. Defer this graph's call
+                        // event until the first cache miss, including in nested graphs.
+                        result = (_a.sent()).result;
                         return [3 /*break*/, 6];
-                    case 4: return [4 /*yield*/, impl.call(fn, inputs, params, this, root ? null : context, name)];
+                    case 4:
+                        activate();
+                        console.log("Executing function call: ".concat(name));
+                        return [4 /*yield*/, impl.call(fn, inputs, params, this, root ? null : context, name)];
                     case 5:
-                        _a = _b.sent();
-                        _b.label = 6;
+                        result = _a.sent();
+                        _a.label = 6;
                     case 6:
-                        result = _a;
                         createdAt = Date.now();
                         if (kind)
                             this.cache.set(run, path, kind, fn, call, inputs, params, result, impl, createdAt);
@@ -3642,7 +3705,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 +3729,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,