@decaf-ts/integrations 0.3.8 → 0.3.9

package/lib/esm/graph/engine/loops/WhileGraphNodeExecutor.js

@@ -0,0 +1,73 @@
+import { GRAPH_DEFAULT_MAX_LOOP_ITERATIONS } from "./../constants.js";
+import { GraphExecutionEventType } from "./../../shared/constants.js";
+import { GraphInputError } from "./../errors/GraphInputError.js";
+import { GraphLoopLimitError } from "./../errors/GraphLoopLimitError.js";
+import { GraphConditionEvaluator } from "./GraphConditionEvaluator.js";
+/**
+ * Executor for `core.loop.while` nodes.
+ *
+ * Expects input:
+ * - `state`: initial state
+ *
+ * Produces output:
+ * - `state`: final state
+ * - `iterations`: number of iterations executed
+ */
+export class WhileGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+        this.evaluator = new GraphConditionEvaluator();
+    }
+    async execute(input, context) {
+        const metadata = this.extractMetadata(context);
+        const maxIterations = metadata.maxIterations ?? GRAPH_DEFAULT_MAX_LOOP_ITERATIONS;
+        const condition = metadata.condition;
+        if (!condition) {
+            throw new GraphInputError("while node is missing a condition");
+        }
+        const statePort = metadata.statePort ?? "state";
+        const bodyWorkflow = metadata.body;
+        let state = input.state;
+        let iteration = 0;
+        await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });
+        while (this.evaluator.evaluate(condition, state)) {
+            if (iteration >= maxIterations) {
+                await context.emit({
+                    type: GraphExecutionEventType.LOOP_LIMIT_REACHED,
+                    iteration,
+                });
+                throw new GraphLoopLimitError(`while loop exceeded max iterations (${maxIterations})`);
+            }
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_CONDITION_EVALUATED,
+                iteration,
+                payload: { result: true },
+            });
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_ITERATION_STARTED,
+                iteration,
+            });
+            const childResult = await this.engine.execute(bodyWorkflow, { [statePort]: state, iteration }, {
+                parentRunId: context.runId,
+                path: [...context.path, `iteration:${iteration}`],
+            });
+            state = childResult.outputs[statePort];
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,
+                iteration,
+            });
+            iteration++;
+        }
+        await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });
+        return { [statePort]: state, iterations: iteration };
+    }
+    extractMetadata(context) {
+        const raw = context.node.graph?.metadata?.loop ??
+            context.metadata?.loop;
+        if (!raw) {
+            throw new GraphInputError("while node is missing loop metadata");
+        }
+        return raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/loops/index.js

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/loops
+ * @summary Structured loop executors.
+ * @description Re-exports the condition evaluator, loop execution context, and foreach/while/until executors.
+ */
+export * from "./GraphConditionEvaluator.js";
+export * from "./ConditionExpressionEvaluator.js";
+export * from "./GraphLoopExecutionContext.js";
+export * from "./ForeachGraphNodeExecutor.js";
+export * from "./WhileGraphNodeExecutor.js";
+export * from "./UntilGraphNodeExecutor.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2xvb3BzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCw2Q0FBMEM7QUFDMUMsa0RBQStDO0FBQy9DLCtDQUE0QztBQUM1Qyw4Q0FBMkM7QUFDM0MsNENBQXlDO0FBQ3pDLDRDQUF5QyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvbG9vcHNcbiAqIEBzdW1tYXJ5IFN0cnVjdHVyZWQgbG9vcCBleGVjdXRvcnMuXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgY29uZGl0aW9uIGV2YWx1YXRvciwgbG9vcCBleGVjdXRpb24gY29udGV4dCwgYW5kIGZvcmVhY2gvd2hpbGUvdW50aWwgZXhlY3V0b3JzLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaENvbmRpdGlvbkV2YWx1YXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ29uZGl0aW9uRXhwcmVzc2lvbkV2YWx1YXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhMb29wRXhlY3V0aW9uQ29udGV4dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vRm9yZWFjaEdyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9XaGlsZUdyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9VbnRpbEdyYXBoTm9kZUV4ZWN1dG9yXCI7XG4iXX0=

package/lib/esm/graph/engine/pinning/GraphPinningDependencyResolver.js

@@ -0,0 +1,23 @@
+import { GraphTopology } from "./../planning/GraphTopology.js";
+/**
+ * Resolves the upstream dependency subtree of a node for pinning operations.
+ */
+export class GraphPinningDependencyResolver {
+    /**
+     * Returns the set of upstream node ids that the given node depends on,
+     * excluding the workflow boundary.
+     */
+    getDependencies(plan, nodeId) {
+        return GraphTopology.upstreamNodes(nodeId, plan.incomingByNode, false);
+    }
+    /**
+     * Returns the full set of node ids to pin: the node itself plus all its
+     * upstream dependencies.
+     */
+    getPinSet(plan, nodeId) {
+        const deps = this.getDependencies(plan, nodeId);
+        deps.add(nodeId);
+        return deps;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/pinning/GraphPinningMetadata.js

@@ -0,0 +1,15 @@
+/**
+ * Default pinning metadata applied when `@pinnable()` is used without options.
+ */
+export const DEFAULT_PINNING_METADATA = {
+    enabled: true,
+    strategy: "manual",
+    includeDependencies: true,
+};
+/**
+ * Returns `true` when the given metadata allows pinning.
+ */
+export function isPinnable(metadata) {
+    return metadata?.enabled === true && metadata.strategy !== "disabled";
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhQaW5uaW5nTWV0YWRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3Bpbm5pbmcvR3JhcGhQaW5uaW5nTWV0YWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0E7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBeUI7SUFDNUQsT0FBTyxFQUFFLElBQUk7SUFDYixRQUFRLEVBQUUsUUFBUTtJQUNsQixtQkFBbUIsRUFBRSxJQUFJO0NBQzFCLENBQUM7QUFFRjs7R0FFRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQUMsUUFBMEM7SUFDbkUsT0FBTyxRQUFRLEVBQUUsT0FBTyxLQUFLLElBQUksSUFBSSxRQUFRLENBQUMsUUFBUSxLQUFLLFVBQVUsQ0FBQztBQUN4RSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9waW5uaW5nL0dyYXBoUGlubmluZ01ldGFkYXRhXG4gKiBAc3VtbWFyeSBQaW5uaW5nIG1ldGFkYXRhIGRlZmF1bHRzIGFuZCBoZWxwZXJzLlxuICogQGRlc2NyaXB0aW9uIFByb3ZpZGVzIGRlZmF1bHQgcGlubmluZyBtZXRhZGF0YSB2YWx1ZXMgYW5kIGEgaGVscGVyIHRvIGNoZWNrIHBpbm5hYmlsaXR5LiBUaGUgYEdyYXBoUGlubmluZ01ldGFkYXRhYCB0eXBlIGl0c2VsZiBpcyBkZWZpbmVkIGluIGAuLi90eXBlc2AgYW5kIHJlLWV4cG9ydGVkIGZyb20gdGhlIHBhY2thZ2Ugcm9vdC5cbiAqL1xuaW1wb3J0IHR5cGUgeyBHcmFwaFBpbm5pbmdNZXRhZGF0YSB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG4vKipcbiAqIERlZmF1bHQgcGlubmluZyBtZXRhZGF0YSBhcHBsaWVkIHdoZW4gYEBwaW5uYWJsZSgpYCBpcyB1c2VkIHdpdGhvdXQgb3B0aW9ucy5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfUElOTklOR19NRVRBREFUQTogR3JhcGhQaW5uaW5nTWV0YWRhdGEgPSB7XG4gIGVuYWJsZWQ6IHRydWUsXG4gIHN0cmF0ZWd5OiBcIm1hbnVhbFwiLFxuICBpbmNsdWRlRGVwZW5kZW5jaWVzOiB0cnVlLFxufTtcblxuLyoqXG4gKiBSZXR1cm5zIGB0cnVlYCB3aGVuIHRoZSBnaXZlbiBtZXRhZGF0YSBhbGxvd3MgcGlubmluZy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzUGlubmFibGUobWV0YWRhdGE6IEdyYXBoUGlubmluZ01ldGFkYXRhIHwgdW5kZWZpbmVkKTogYm9vbGVhbiB7XG4gIHJldHVybiBtZXRhZGF0YT8uZW5hYmxlZCA9PT0gdHJ1ZSAmJiBtZXRhZGF0YS5zdHJhdGVneSAhPT0gXCJkaXNhYmxlZFwiO1xufVxuIl19

package/lib/esm/graph/engine/pinning/GraphPinningPolicy.js

@@ -0,0 +1,29 @@
+import { DEFAULT_PINNING_METADATA, isPinnable } from "./GraphPinningMetadata.js";
+/**
+ * Policy that decides pinning behaviour for a plan node.
+ */
+export class GraphPinningPolicy {
+    /** Returns whether the node is allowed to be pinned. */
+    canPin(node) {
+        return isPinnable(this.getPinningMetadata(node));
+    }
+    /** Returns whether the engine should attempt to use a pinned value for the node. */
+    shouldUsePinnedValue(node) {
+        const metadata = this.getPinningMetadata(node);
+        return metadata.enabled === true && metadata.strategy !== "disabled";
+    }
+    /** Returns whether automatic pinning should occur after execution. */
+    shouldAutoPin(node) {
+        const metadata = this.getPinningMetadata(node);
+        return metadata.enabled === true && metadata.strategy === "automatic";
+    }
+    /** Extracts pinning metadata from a plan node. */
+    getPinningMetadata(node) {
+        const raw = node.definition?.graph?.metadata?.pinnable ??
+            node.metadata?.pinnable;
+        return raw
+            ? { ...DEFAULT_PINNING_METADATA, ...raw }
+            : { ...DEFAULT_PINNING_METADATA, enabled: false };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/pinning/GraphPinningService.js

@@ -0,0 +1,186 @@
+/**
+ * @module integrations/graph/pinning/GraphPinningService
+ * @summary Service for pinning and unpinning graph node values.
+ * @description Computes stable fingerprints, pins/unpins nodes and their upstream dependencies, reads pinned values, and emits pinning events. Pinning is all-or-nothing: if any upstream dependency is not pinnable, the operation fails.
+ */
+import { GRAPH_PINNING_METADATA_KEY } from "./../constants.js";
+import { GraphPinningError } from "./../errors/GraphPinningError.js";
+import { GraphTopology } from "./../planning/GraphTopology.js";
+/**
+ * Service that manages pinning and unpinning of graph node values.
+ */
+export class GraphPinningService {
+    constructor(store, policy, dependencyResolver) {
+        this.store = store;
+        this.policy = policy;
+        this.dependencyResolver = dependencyResolver;
+    }
+    /**
+     * Pins a node and all its upstream dependencies.
+     *
+     * @throws {GraphPinningError} when the node or any dependency is not pinnable.
+     */
+    async pinNode(options) {
+        const plan = options.plan;
+        const includeDependencies = options.includeDependencies ?? true;
+        const pinSet = includeDependencies
+            ? this.dependencyResolver.getPinSet(plan, options.nodeId)
+            : new Set([options.nodeId]);
+        // Validate all-or-nothing
+        for (const nodeId of pinSet) {
+            const node = plan.nodes.find((n) => n.id === nodeId);
+            if (!node) {
+                throw new GraphPinningError(`Node '${nodeId}' not found in plan`);
+            }
+            if (!this.policy.canPin(node)) {
+                throw new GraphPinningError(`Node '${nodeId}' is not pinnable`, { nodeId });
+            }
+        }
+        // Pin dependencies first, then the selected node
+        const ordered = this.topologicalOrder(plan, pinSet);
+        for (const nodeId of ordered) {
+            const node = plan.nodes.find((n) => n.id === nodeId);
+            const result = options.result.nodeResults[nodeId];
+            if (!result || !result.outputs) {
+                throw new GraphPinningError(`Node '${nodeId}' has no completed output to pin`);
+            }
+            const inputs = result.inputs ?? {};
+            const depFingerprints = this.dependencyFingerprints(plan, nodeId, options.result);
+            const key = this.createValueKey(options.workflow, node, inputs, depFingerprints, options.namespace);
+            const now = new Date().toISOString();
+            const cached = {
+                key,
+                outputs: result.outputs,
+                pinned: true,
+                createdAt: now,
+                updatedAt: now,
+                metadata: { ...options.result.metadata, nodeId },
+            };
+            await this.store.writeCached(key, cached);
+        }
+    }
+    /**
+     * Unpins a single node (does not unpin dependents in v1).
+     */
+    async unpinNode(options) {
+        const key = {
+            workflowId: options.workflow.name,
+            nodeId: options.nodeId,
+            fingerprint: options.fingerprint,
+            namespace: options.namespace,
+        };
+        await this.store.deleteCached(key);
+    }
+    /**
+     * Reads a pinned value for a node, returning `undefined` when no valid
+     * pinned value exists.
+     */
+    async readPinnedValue(workflow, node, inputs, dependencyFingerprints, namespace) {
+        const key = this.createValueKey(workflow, node, inputs, dependencyFingerprints, namespace);
+        const cached = await this.store.readCached(key);
+        if (cached && cached.pinned) {
+            if (cached.expiresAt && new Date(cached.expiresAt) < new Date()) {
+                return undefined;
+            }
+            return cached;
+        }
+        return undefined;
+    }
+    /**
+     * Creates a stable value key for a node.
+     */
+    createValueKey(workflow, node, inputs, dependencyFingerprints, namespace) {
+        return {
+            workflowId: workflow.name,
+            nodeId: node.id,
+            fingerprint: this.computeFingerprint(workflow, node, inputs, dependencyFingerprints),
+            namespace,
+        };
+    }
+    /**
+     * Computes a stable fingerprint for a node's inputs and dependencies.
+     */
+    computeFingerprint(workflow, node, inputs, dependencyFingerprints) {
+        const data = {
+            workflowId: workflow.name,
+            nodeId: node.id,
+            nodeKind: node.kind,
+            nodeDefinitionVersion: node.definition?.graph?.metadata?.version,
+            inputs: this.stableSerialize(inputs),
+            dependencyFingerprints: this.stableSerialize(dependencyFingerprints),
+        };
+        const json = this.stableSerialize(data);
+        // Use a deterministic non-cryptographic hash that works in both browser
+        // and Node environments without requiring `node:crypto`.
+        return this.simpleHash(json);
+    }
+    /**
+     * Returns a topological ordering of the given node set.
+     */
+    topologicalOrder(plan, nodeSet) {
+        const result = [];
+        const visited = new Set();
+        const visit = (nodeId) => {
+            if (visited.has(nodeId))
+                return;
+            visited.add(nodeId);
+            const deps = GraphTopology.upstreamNodes(nodeId, plan.incomingByNode, false);
+            for (const dep of deps) {
+                if (nodeSet.has(dep))
+                    visit(dep);
+            }
+            result.push(nodeId);
+        };
+        for (const nodeId of nodeSet)
+            visit(nodeId);
+        return result;
+    }
+    /**
+     * Computes fingerprints for all upstream dependencies of a node.
+     */
+    dependencyFingerprints(plan, nodeId, result) {
+        const deps = this.dependencyResolver.getDependencies(plan, nodeId);
+        const fingerprints = {};
+        for (const dep of deps) {
+            const node = plan.nodes.find((n) => n.id === dep);
+            if (node) {
+                const depResult = result.nodeResults[dep];
+                const inputs = depResult?.inputs ?? {};
+                const nestedDeps = this.dependencyFingerprints(plan, dep, result);
+                fingerprints[dep] = this.computeFingerprint(plan.workflow, node, inputs, nestedDeps);
+            }
+        }
+        return fingerprints;
+    }
+    /**
+     * Serializes a value with recursively sorted keys for stable hashing.
+     */
+    stableSerialize(value) {
+        if (value === null || typeof value !== "object") {
+            return JSON.stringify(value);
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map((v) => this.stableSerialize(v)).join(",")}]`;
+        }
+        const keys = Object.keys(value).sort();
+        const pairs = keys.map((k) => `${JSON.stringify(k)}:${this.stableSerialize(value[k])}`);
+        return `{${pairs.join(",")}}`;
+    }
+    /**
+     * Simple non-cryptographic hash for browser environments where
+     * `node:crypto` is unavailable. Produces a deterministic hex-like string
+     * from the input. This is NOT cryptographically secure but is sufficient
+     * for fingerprint-based cache keys.
+     */
+    simpleHash(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash |= 0;
+        }
+        return `fp_${Math.abs(hash).toString(16).padStart(8, "0")}_${str.length}`;
+    }
+}
+void GRAPH_PINNING_METADATA_KEY;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphPinningService.js","sourceRoot":"","sources":["../../../../../src/graph/engine/pinning/GraphPinningService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/pinning/GraphPinningService\n * @summary Service for pinning and unpinning graph node values.\n * @description Computes stable fingerprints, pins/unpins nodes and their upstream dependencies, reads pinned values, and emits pinning events. Pinning is all-or-nothing: if any upstream dependency is not pinnable, the operation fails.\n */\nimport { GRAPH_PINNING_METADATA_KEY } from \"../constants\";\nimport { GraphPinningError } from \"../errors/GraphPinningError\";\nimport type { GraphExecutionPlan } from \"../planning/GraphExecutionPlan\";\nimport type { GraphExecutionPlanNode } from \"../planning/GraphExecutionPlanNode\";\nimport { GraphTopology } from \"../planning/GraphTopology\";\nimport type { GraphValueStore } from \"../store/GraphValueStore\";\nimport type { GraphValueKey } from \"../store/GraphValueKey\";\nimport type { GraphCachedValue } from \"../store/GraphCachedValue\";\nimport type {\n  GraphExecutionResult,\n  GraphExecutionValues,\n  GraphPinNodeOptions,\n  GraphUnpinNodeOptions,\n} from \"../types\";\nimport type { GraphWorkflowDefinition } from \"@decaf-ts/ui-decorators/graph\";\n\nimport type { GraphPinningPolicy } from \"./GraphPinningPolicy\";\nimport type { GraphPinningDependencyResolver } from \"./GraphPinningDependencyResolver\";\n\n/**\n * Service that manages pinning and unpinning of graph node values.\n */\nexport class GraphPinningService {\n  constructor(\n    private readonly store: GraphValueStore,\n    private readonly policy: GraphPinningPolicy,\n    private readonly dependencyResolver: GraphPinningDependencyResolver\n  ) {}\n\n  /**\n   * Pins a node and all its upstream dependencies.\n   *\n   * @throws {GraphPinningError} when the node or any dependency is not pinnable.\n   */\n  async pinNode(options: GraphPinNodeOptions): Promise<void> {\n    const plan = options.plan as GraphExecutionPlan;\n    const includeDependencies = options.includeDependencies ?? true;\n\n    const pinSet = includeDependencies\n      ? this.dependencyResolver.getPinSet(plan, options.nodeId)\n      : new Set([options.nodeId]);\n\n    // Validate all-or-nothing\n    for (const nodeId of pinSet) {\n      const node = plan.nodes.find((n) => n.id === nodeId);\n      if (!node) {\n        throw new GraphPinningError(`Node '${nodeId}' not found in plan`);\n      }\n      if (!this.policy.canPin(node)) {\n        throw new GraphPinningError(\n          `Node '${nodeId}' is not pinnable`,\n          { nodeId }\n        );\n      }\n    }\n\n    // Pin dependencies first, then the selected node\n    const ordered = this.topologicalOrder(plan, pinSet);\n    for (const nodeId of ordered) {\n      const node = plan.nodes.find((n) => n.id === nodeId)!;\n      const result = options.result.nodeResults[nodeId];\n      if (!result || !result.outputs) {\n        throw new GraphPinningError(\n          `Node '${nodeId}' has no completed output to pin`\n        );\n      }\n      const inputs = result.inputs ?? {};\n      const depFingerprints = this.dependencyFingerprints(plan, nodeId, options.result);\n      const key = this.createValueKey(options.workflow, node, inputs, depFingerprints, options.namespace);\n      const now = new Date().toISOString();\n      const cached: GraphCachedValue = {\n        key,\n        outputs: result.outputs,\n        pinned: true,\n        createdAt: now,\n        updatedAt: now,\n        metadata: { ...options.result.metadata, nodeId },\n      };\n      await this.store.writeCached(key, cached);\n    }\n  }\n\n  /**\n   * Unpins a single node (does not unpin dependents in v1).\n   */\n  async unpinNode(options: GraphUnpinNodeOptions): Promise<void> {\n    const key: GraphValueKey = {\n      workflowId: options.workflow.name,\n      nodeId: options.nodeId,\n      fingerprint: options.fingerprint,\n      namespace: options.namespace,\n    };\n    await this.store.deleteCached(key);\n  }\n\n  /**\n   * Reads a pinned value for a node, returning `undefined` when no valid\n   * pinned value exists.\n   */\n  async readPinnedValue(\n    workflow: GraphWorkflowDefinition,\n    node: GraphExecutionPlanNode,\n    inputs: GraphExecutionValues,\n    dependencyFingerprints: Record<string, string>,\n    namespace?: string\n  ): Promise<GraphCachedValue | undefined> {\n    const key = this.createValueKey(workflow, node, inputs, dependencyFingerprints, namespace);\n    const cached = await this.store.readCached(key);\n    if (cached && cached.pinned) {\n      if (cached.expiresAt && new Date(cached.expiresAt) < new Date()) {\n        return undefined;\n      }\n      return cached;\n    }\n    return undefined;\n  }\n\n  /**\n   * Creates a stable value key for a node.\n   */\n  createValueKey(\n    workflow: GraphWorkflowDefinition,\n    node: GraphExecutionPlanNode,\n    inputs: GraphExecutionValues,\n    dependencyFingerprints: Record<string, string>,\n    namespace?: string\n  ): GraphValueKey {\n    return {\n      workflowId: workflow.name,\n      nodeId: node.id,\n      fingerprint: this.computeFingerprint(workflow, node, inputs, dependencyFingerprints),\n      namespace,\n    };\n  }\n\n  /**\n   * Computes a stable fingerprint for a node's inputs and dependencies.\n   */\n  computeFingerprint(\n    workflow: GraphWorkflowDefinition,\n    node: GraphExecutionPlanNode,\n    inputs: GraphExecutionValues,\n    dependencyFingerprints: Record<string, string>\n  ): string {\n    const data = {\n      workflowId: workflow.name,\n      nodeId: node.id,\n      nodeKind: node.kind,\n      nodeDefinitionVersion: (node.definition as any)?.graph?.metadata?.version,\n      inputs: this.stableSerialize(inputs),\n      dependencyFingerprints: this.stableSerialize(dependencyFingerprints),\n    };\n    const json = this.stableSerialize(data);\n    // Use a deterministic non-cryptographic hash that works in both browser\n    // and Node environments without requiring `node:crypto`.\n    return this.simpleHash(json);\n  }\n\n  /**\n   * Returns a topological ordering of the given node set.\n   */\n  private topologicalOrder(\n    plan: GraphExecutionPlan,\n    nodeSet: Set<string>\n  ): string[] {\n    const result: string[] = [];\n    const visited = new Set<string>();\n    const visit = (nodeId: string) => {\n      if (visited.has(nodeId)) return;\n      visited.add(nodeId);\n      const deps = GraphTopology.upstreamNodes(nodeId, plan.incomingByNode, false);\n      for (const dep of deps) {\n        if (nodeSet.has(dep)) visit(dep);\n      }\n      result.push(nodeId);\n    };\n    for (const nodeId of nodeSet) visit(nodeId);\n    return result;\n  }\n\n  /**\n   * Computes fingerprints for all upstream dependencies of a node.\n   */\n  private dependencyFingerprints(\n    plan: GraphExecutionPlan,\n    nodeId: string,\n    result: GraphExecutionResult\n  ): Record<string, string> {\n    const deps = this.dependencyResolver.getDependencies(plan, nodeId);\n    const fingerprints: Record<string, string> = {};\n    for (const dep of deps) {\n      const node = plan.nodes.find((n) => n.id === dep);\n      if (node) {\n        const depResult = result.nodeResults[dep];\n        const inputs = depResult?.inputs ?? {};\n        const nestedDeps = this.dependencyFingerprints(plan, dep, result);\n        fingerprints[dep] = this.computeFingerprint(plan.workflow, node, inputs, nestedDeps);\n      }\n    }\n    return fingerprints;\n  }\n\n  /**\n   * Serializes a value with recursively sorted keys for stable hashing.\n   */\n  private stableSerialize(value: unknown): string {\n    if (value === null || typeof value !== \"object\") {\n      return JSON.stringify(value);\n    }\n    if (Array.isArray(value)) {\n      return `[${value.map((v) => this.stableSerialize(v)).join(\",\")}]`;\n    }\n    const keys = Object.keys(value).sort();\n    const pairs = keys.map(\n      (k) => `${JSON.stringify(k)}:${this.stableSerialize((value as any)[k])}`\n    );\n    return `{${pairs.join(\",\")}}`;\n  }\n\n  /**\n   * Simple non-cryptographic hash for browser environments where\n   * `node:crypto` is unavailable. Produces a deterministic hex-like string\n   * from the input. This is NOT cryptographically secure but is sufficient\n   * for fingerprint-based cache keys.\n   */\n  private simpleHash(str: string): string {\n    let hash = 0;\n    for (let i = 0; i < str.length; i++) {\n      const char = str.charCodeAt(i);\n      hash = (hash << 5) - hash + char;\n      hash |= 0;\n    }\n    return `fp_${Math.abs(hash).toString(16).padStart(8, \"0\")}_${str.length}`;\n  }\n}\n\nvoid GRAPH_PINNING_METADATA_KEY;\n"]}

package/lib/esm/graph/engine/pinning/index.js

@@ -0,0 +1,10 @@
+/**
+ * @module integrations/graph/pinning
+ * @summary Graph pinning subsystem.
+ * @description Re-exports the pinning metadata, policy, dependency resolver, and service.
+ */
+export * from "./GraphPinningMetadata.js";
+export * from "./GraphPinningPolicy.js";
+export * from "./GraphPinningDependencyResolver.js";
+export * from "./GraphPinningService.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3Bpbm5pbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILDBDQUF1QztBQUN2Qyx3Q0FBcUM7QUFDckMsb0RBQWlEO0FBQ2pELHlDQUFzQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvcGlubmluZ1xuICogQHN1bW1hcnkgR3JhcGggcGlubmluZyBzdWJzeXN0ZW0uXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgcGlubmluZyBtZXRhZGF0YSwgcG9saWN5LCBkZXBlbmRlbmN5IHJlc29sdmVyLCBhbmQgc2VydmljZS5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nTWV0YWRhdGFcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoUGlubmluZ1BvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nRGVwZW5kZW5jeVJlc29sdmVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaFBpbm5pbmdTZXJ2aWNlXCI7XG4iXX0=

package/lib/esm/graph/engine/planning/GraphExecutionPlan.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2dyYXBoL2VuZ2luZS9wbGFubmluZy9HcmFwaEV4ZWN1dGlvblBsYW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvcGxhbm5pbmcvR3JhcGhFeGVjdXRpb25QbGFuXG4gKiBAc3VtbWFyeSBUaGUgY29tcGxldGUgZXhlY3V0aW9uIHBsYW4gZm9yIGEgd29ya2Zsb3cuXG4gKiBAZGVzY3JpcHRpb24gQ29udGFpbnMgcmVzb2x2ZWQgbm9kZXMsIGVkZ2VzLCB0b3BvbG9naWNhbCBsYXllcnMsIGFuZCBpbmNvbWluZy9vdXRnb2luZyBtYXBzLlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoV29ya2Zsb3dEZWZpbml0aW9uIH0gZnJvbSBcIkBkZWNhZi10cy91aS1kZWNvcmF0b3JzL2dyYXBoXCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uUGxhbk5vZGUgfSBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblBsYW5Ob2RlXCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uUGxhbkVkZ2UgfSBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblBsYW5FZGdlXCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uUGxhbkxheWVyIH0gZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25QbGFuTGF5ZXJcIjtcblxuLyoqXG4gKiBUaGUgcmVzb2x2ZWQgZXhlY3V0aW9uIHBsYW4gZm9yIGEgc2luZ2xlIHdvcmtmbG93LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEdyYXBoRXhlY3V0aW9uUGxhbiB7XG4gIHdvcmtmbG93OiBHcmFwaFdvcmtmbG93RGVmaW5pdGlvbjtcbiAgd29ya2Zsb3dJZDogc3RyaW5nO1xuICBub2RlczogR3JhcGhFeGVjdXRpb25QbGFuTm9kZVtdO1xuICBlZGdlczogR3JhcGhFeGVjdXRpb25QbGFuRWRnZVtdO1xuICBsYXllcnM6IEdyYXBoRXhlY3V0aW9uUGxhbkxheWVyW107XG4gIGluY29taW5nQnlOb2RlOiBNYXA8c3RyaW5nLCBHcmFwaEV4ZWN1dGlvblBsYW5FZGdlW10+O1xuICBvdXRnb2luZ0J5Tm9kZTogTWFwPHN0cmluZywgR3JhcGhFeGVjdXRpb25QbGFuRWRnZVtdPjtcbn1cbiJdfQ==

package/lib/esm/graph/engine/planning/GraphExecutionPlanEdge.js

@@ -0,0 +1,7 @@
+/**
+ * @module integrations/graph/planning/GraphExecutionPlanEdge
+ * @summary Plan edge type for the execution plan.
+ * @description Represents a directed value route between two endpoints (node-to-node or node-to-workflow-boundary).
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuRWRnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvcGxhbm5pbmcvR3JhcGhFeGVjdXRpb25QbGFuRWRnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9wbGFubmluZy9HcmFwaEV4ZWN1dGlvblBsYW5FZGdlXG4gKiBAc3VtbWFyeSBQbGFuIGVkZ2UgdHlwZSBmb3IgdGhlIGV4ZWN1dGlvbiBwbGFuLlxuICogQGRlc2NyaXB0aW9uIFJlcHJlc2VudHMgYSBkaXJlY3RlZCB2YWx1ZSByb3V0ZSBiZXR3ZWVuIHR3byBlbmRwb2ludHMgKG5vZGUtdG8tbm9kZSBvciBub2RlLXRvLXdvcmtmbG93LWJvdW5kYXJ5KS5cbiAqL1xuXG4vKipcbiAqIEFuIGVkZ2UgaW4gdGhlIGV4ZWN1dGlvbiBwbGFuIHJlcHJlc2VudGluZyBhIHZhbHVlIHJvdXRlIGZyb20gYSBzb3VyY2VcbiAqIHBvcnQgdG8gYSB0YXJnZXQgcG9ydC5cbiAqXG4gKiBgc291cmNlTm9kZUlkYCBvciBgdGFyZ2V0Tm9kZUlkYCBtYXkgYmUge0BsaW5rIEdSQVBIX1dPUktGTE9XX0JPVU5EQVJZfSB3aGVuXG4gKiB0aGUgZWRnZSBjb25uZWN0cyB0byB0aGUgd29ya2Zsb3cgYm91bmRhcnkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR3JhcGhFeGVjdXRpb25QbGFuRWRnZSB7XG4gIGlkOiBzdHJpbmc7XG4gIHNvdXJjZU5vZGVJZDogc3RyaW5nO1xuICBzb3VyY2VQb3J0OiBzdHJpbmc7XG4gIHRhcmdldE5vZGVJZDogc3RyaW5nO1xuICB0YXJnZXRQb3J0OiBzdHJpbmc7XG4gIGxhYmVsPzogc3RyaW5nO1xuICBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xufVxuIl19

package/lib/esm/graph/engine/planning/GraphExecutionPlanLayer.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuTGF5ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3BsYW5uaW5nL0dyYXBoRXhlY3V0aW9uUGxhbkxheWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL3BsYW5uaW5nL0dyYXBoRXhlY3V0aW9uUGxhbkxheWVyXG4gKiBAc3VtbWFyeSBBIGxheWVyIG9mIG5vZGVzIHRoYXQgY2FuIGV4ZWN1dGUgaW4gcGFyYWxsZWwuXG4gKiBAZGVzY3JpcHRpb24gUHJvZHVjZWQgYnkgdGhlIHRvcG9sb2dpY2FsIHBsYW5uZXI7IGFsbCBub2RlcyBpbiBhIGxheWVyIGhhdmUgbm8gZGVwZW5kZW5jaWVzIG9uIGVhY2ggb3RoZXIuXG4gKi9cbmltcG9ydCB0eXBlIHsgR3JhcGhFeGVjdXRpb25QbGFuTm9kZSB9IGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uUGxhbk5vZGVcIjtcblxuLyoqXG4gKiBBIHRvcG9sb2dpY2FsIGxheWVyIG9mIG5vZGVzIHRoYXQgbWF5IGV4ZWN1dGUgaW4gcGFyYWxsZWwuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR3JhcGhFeGVjdXRpb25QbGFuTGF5ZXIge1xuICBpbmRleDogbnVtYmVyO1xuICBub2RlczogR3JhcGhFeGVjdXRpb25QbGFuTm9kZVtdO1xufVxuIl19

package/lib/esm/graph/engine/planning/GraphExecutionPlanNode.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvcGxhbm5pbmcvR3JhcGhFeGVjdXRpb25QbGFuTm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9wbGFubmluZy9HcmFwaEV4ZWN1dGlvblBsYW5Ob2RlXG4gKiBAc3VtbWFyeSBQbGFuIG5vZGUgdHlwZSBmb3IgdGhlIGV4ZWN1dGlvbiBwbGFuLlxuICogQGRlc2NyaXB0aW9uIFJlcHJlc2VudHMgYSBzaW5nbGUgbm9kZSByZXNvbHZlZCBmcm9tIGEgd29ya2Zsb3cgZGVmaW5pdGlvbiwgcmVhZHkgZm9yIGV4ZWN1dGlvbi5cbiAqL1xuaW1wb3J0IHR5cGUge1xuICBHcmFwaE5vZGVEZWZpbml0aW9uLFxuICBHcmFwaFdvcmtmbG93Tm9kZU1ldGFkYXRhLFxufSBmcm9tIFwiQGRlY2FmLXRzL3VpLWRlY29yYXRvcnMvZ3JhcGhcIjtcblxuLyoqXG4gKiBBIG5vZGUgaW4gdGhlIGV4ZWN1dGlvbiBwbGFuLCBkZXJpdmVkIGZyb20gYSB3b3JrZmxvdydzIG5vZGUgbWV0YWRhdGEgYW5kXG4gKiBpdHMgcmVzb2x2ZWQgZ3JhcGggZGVmaW5pdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBHcmFwaEV4ZWN1dGlvblBsYW5Ob2RlIHtcbiAgaWQ6IHN0cmluZztcbiAga2luZDogc3RyaW5nO1xuICBsYWJlbD86IHN0cmluZztcbiAgc291cmNlOiBHcmFwaFdvcmtmbG93Tm9kZU1ldGFkYXRhO1xuICBkZWZpbml0aW9uOiBHcmFwaE5vZGVEZWZpbml0aW9uO1xuICBpbnB1dFBvcnRzOiBzdHJpbmdbXTtcbiAgb3V0cHV0UG9ydHM6IHN0cmluZ1tdO1xuICBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xufVxuIl19