@rkmodules/rules 0.0.171 → 0.0.172

package/dist/lib/Engine/cache.d.ts

@@ -2,6 +2,11 @@ import { Tree } from "../DataTree";
 import { CacheInfo, ClearCacheOptions, FunctionCall, PrimitiveFunction, RecOfTrees, RunOptions, VarRef } from "./types";
 export declare const cachePath: (path: string[]) => string;
 export declare function sameRecord(a: Record<string, any>, b: Record<string, any>): boolean;
+/** 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.
+ */
+export declare function sameConfiguration(a: any, b: any, ancestors?: Set<object>): boolean;
 interface PortMemo {
     raw: VarRef;
     paths: string[];
@@ -45,7 +50,7 @@ export declare class ExecutionCache {
     clear(options?: ClearCacheOptions): void;
     visit(run: CacheRun, path: string[]): void;
     finish(run: CacheRun): void;
-    interpolate(run: CacheRun, path: string[], raw: Record<string, VarRef>, scope: Record<string, RecOfTrees>): RecOfTrees;
+    interpolate(run: CacheRun, path: string[], raw: Record<string, VarRef>, scope: Record<string, RecOfTrees>, configuration?: boolean): RecOfTrees;
     key(call: FunctionCall): Record<string, any>;
     get(run: CacheRun, path: string[], kind: CacheInfo["kind"], fn: PrimitiveFunction, call: FunctionCall, inputs: RecOfTrees, params: Record<string, any>): ResultEntry | undefined;
     set(run: CacheRun, path: string[], kind: CacheInfo["kind"], fn: PrimitiveFunction, call: FunctionCall, inputs: RecOfTrees, params: Record<string, any>, result: RecOfTrees, impl: PrimitiveFunction["impl"], createdAt: number): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rkmodules/rules",
-    "version": "0.0.171",
+    "version": "0.0.172",
     "main": "dist/index.cjs.js",
     "module": "dist/index.esm.mjs",
     "types": "./dist/index.d.ts",

package/readme.md

@@ -377,12 +377,17 @@ execute; their individual primitive children follow these policies.
 Treat graph definitions, inputs, parameters, and returned trees as immutable,
 including inside unmarked primitives and event listeners. Do not mutate cached
 outputs or upstream inputs. Update an object/array by replacing its reference.
-Interpolation compares raw port values with `Object.is` and tracks the identities
-of the upstream trees those values reference. A new outer input map with the same
-port values can hit; a newly allocated but deeply equal object/array value misses.
-No serialization or deep equality is used. Unchanged expressions retain their
-reference paths and skip repeated recursive discovery. Function-valued graph input
-defaults still execute each run before their returned values are memoized.
+Graph input/output expressions, call parameters, and call metadata use `Object.is`
+first, then recursive value comparison for arrays and plain objects. Reloading an
+unchanged graph from JSON can therefore reuse cached results. Property and array
+order remain significant; opaque objects (such as class instances) retain identity
+semantics, and distinct cyclic configurations conservatively miss.
+Runtime inputs, evaluated defaults, and upstream dependency trees still use identity
+comparison: a new outer input map with the same port values can hit, but a newly
+allocated runtime object/array value misses even if deeply equal. Unchanged graph
+expressions retain their reference paths and skip repeated recursive discovery.
+Function-valued graph input defaults still execute each run before their returned
+values are memoized. In-place mutations are not detected.
 
 Caches belong to an engine, root graph/function name, and optional `cacheKey`.
 Nested invocation paths distinguish two uses of the same child graph. Use distinct