@decaf-ts/integrations 0.3.8 → 0.3.9

package/lib/cjs/graph/engine/pinning/GraphPinningDependencyResolver.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphPinningDependencyResolver = void 0;
+const GraphTopology_js_1 = require("./../planning/GraphTopology.cjs");
+/**
+ * Resolves the upstream dependency subtree of a node for pinning operations.
+ */
+class GraphPinningDependencyResolver {
+    /**
+     * Returns the set of upstream node ids that the given node depends on,
+     * excluding the workflow boundary.
+     */
+    getDependencies(plan, nodeId) {
+        return GraphTopology_js_1.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;
+    }
+}
+exports.GraphPinningDependencyResolver = GraphPinningDependencyResolver;
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/engine/pinning/GraphPinningMetadata.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PINNING_METADATA = void 0;
+exports.isPinnable = isPinnable;
+/**
+ * Default pinning metadata applied when `@pinnable()` is used without options.
+ */
+exports.DEFAULT_PINNING_METADATA = {
+    enabled: true,
+    strategy: "manual",
+    includeDependencies: true,
+};
+/**
+ * Returns `true` when the given metadata allows pinning.
+ */
+function isPinnable(metadata) {
+    return metadata?.enabled === true && metadata.strategy !== "disabled";
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhQaW5uaW5nTWV0YWRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3Bpbm5pbmcvR3JhcGhQaW5uaW5nTWV0YWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0E7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBeUI7SUFDNUQsT0FBTyxFQUFFLElBQUk7SUFDYixRQUFRLEVBQUUsUUFBUTtJQUNsQixtQkFBbUIsRUFBRSxJQUFJO0NBQzFCLENBQUM7QUFFRjs7R0FFRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQUMsUUFBMEM7SUFDbkUsT0FBTyxRQUFRLEVBQUUsT0FBTyxLQUFLLElBQUksSUFBSSxRQUFRLENBQUMsUUFBUSxLQUFLLFVBQVUsQ0FBQztBQUN4RSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9waW5uaW5nL0dyYXBoUGlubmluZ01ldGFkYXRhXG4gKiBAc3VtbWFyeSBQaW5uaW5nIG1ldGFkYXRhIGRlZmF1bHRzIGFuZCBoZWxwZXJzLlxuICogQGRlc2NyaXB0aW9uIFByb3ZpZGVzIGRlZmF1bHQgcGlubmluZyBtZXRhZGF0YSB2YWx1ZXMgYW5kIGEgaGVscGVyIHRvIGNoZWNrIHBpbm5hYmlsaXR5LiBUaGUgYEdyYXBoUGlubmluZ01ldGFkYXRhYCB0eXBlIGl0c2VsZiBpcyBkZWZpbmVkIGluIGAuLi90eXBlc2AgYW5kIHJlLWV4cG9ydGVkIGZyb20gdGhlIHBhY2thZ2Ugcm9vdC5cbiAqL1xuaW1wb3J0IHR5cGUgeyBHcmFwaFBpbm5pbmdNZXRhZGF0YSB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG4vKipcbiAqIERlZmF1bHQgcGlubmluZyBtZXRhZGF0YSBhcHBsaWVkIHdoZW4gYEBwaW5uYWJsZSgpYCBpcyB1c2VkIHdpdGhvdXQgb3B0aW9ucy5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfUElOTklOR19NRVRBREFUQTogR3JhcGhQaW5uaW5nTWV0YWRhdGEgPSB7XG4gIGVuYWJsZWQ6IHRydWUsXG4gIHN0cmF0ZWd5OiBcIm1hbnVhbFwiLFxuICBpbmNsdWRlRGVwZW5kZW5jaWVzOiB0cnVlLFxufTtcblxuLyoqXG4gKiBSZXR1cm5zIGB0cnVlYCB3aGVuIHRoZSBnaXZlbiBtZXRhZGF0YSBhbGxvd3MgcGlubmluZy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzUGlubmFibGUobWV0YWRhdGE6IEdyYXBoUGlubmluZ01ldGFkYXRhIHwgdW5kZWZpbmVkKTogYm9vbGVhbiB7XG4gIHJldHVybiBtZXRhZGF0YT8uZW5hYmxlZCA9PT0gdHJ1ZSAmJiBtZXRhZGF0YS5zdHJhdGVneSAhPT0gXCJkaXNhYmxlZFwiO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/engine/pinning/GraphPinningPolicy.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphPinningPolicy = void 0;
+const GraphPinningMetadata_js_1 = require("./GraphPinningMetadata.cjs");
+/**
+ * Policy that decides pinning behaviour for a plan node.
+ */
+class GraphPinningPolicy {
+    /** Returns whether the node is allowed to be pinned. */
+    canPin(node) {
+        return (0, GraphPinningMetadata_js_1.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
+            ? { ...GraphPinningMetadata_js_1.DEFAULT_PINNING_METADATA, ...raw }
+            : { ...GraphPinningMetadata_js_1.DEFAULT_PINNING_METADATA, enabled: false };
+    }
+}
+exports.GraphPinningPolicy = GraphPinningPolicy;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhQaW5uaW5nUG9saWN5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2dyYXBoL2VuZ2luZS9waW5uaW5nL0dyYXBoUGlubmluZ1BvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFPQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsVUFBVSxFQUFFLGtDQUErQjtBQUU5RTs7R0FFRztBQUNILE1BQU0sT0FBTyxrQkFBa0I7SUFDN0Isd0RBQXdEO0lBQ3hELE1BQU0sQ0FBQyxJQUE0QjtRQUNqQyxPQUFPLFVBQVUsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNuRCxDQUFDO0lBRUQsb0ZBQW9GO0lBQ3BGLG9CQUFvQixDQUFDLElBQTRCO1FBQy9DLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMvQyxPQUFPLFFBQVEsQ0FBQyxPQUFPLEtBQUssSUFBSSxJQUFJLFFBQVEsQ0FBQyxRQUFRLEtBQUssVUFBVSxDQUFDO0lBQ3ZFLENBQUM7SUFFRCxzRUFBc0U7SUFDdEUsYUFBYSxDQUFDLElBQTRCO1FBQ3hDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMvQyxPQUFPLFFBQVEsQ0FBQyxPQUFPLEtBQUssSUFBSSxJQUFJLFFBQVEsQ0FBQyxRQUFRLEtBQUssV0FBVyxDQUFDO0lBQ3hFLENBQUM7SUFFRCxrREFBa0Q7SUFDbEQsa0JBQWtCLENBQUMsSUFBNEI7UUFDN0MsTUFBTSxHQUFHLEdBQ04sSUFBSSxDQUFDLFVBQWtCLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxRQUFRO1lBQ2xELElBQUksQ0FBQyxRQUFnQixFQUFFLFFBQVEsQ0FBQztRQUNuQyxPQUFPLEdBQUc7WUFDUixDQUFDLENBQUMsRUFBRSxHQUFHLHdCQUF3QixFQUFFLEdBQUcsR0FBRyxFQUFFO1lBQ3pDLENBQUMsQ0FBQyxFQUFFLEdBQUcsd0JBQXdCLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxDQUFDO0lBQ3RELENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvcGlubmluZy9HcmFwaFBpbm5pbmdQb2xpY3lcbiAqIEBzdW1tYXJ5IERlY2lkZXMgd2hldGhlciBhIG5vZGUgY2FuIGJlIHBpbm5lZCBhbmQgd2hldGhlciBwaW5uZWQgdmFsdWVzIHNob3VsZCBiZSB1c2VkLlxuICogQGRlc2NyaXB0aW9uIFJlYWRzIHBpbm5pbmcgbWV0YWRhdGEgZnJvbSBwbGFuIG5vZGVzIGFuZCBlbmZvcmNlcyB0aGUgcGlubmluZyBzdHJhdGVneS5cbiAqL1xuaW1wb3J0IHR5cGUgeyBHcmFwaEV4ZWN1dGlvblBsYW5Ob2RlIH0gZnJvbSBcIi4uL3BsYW5uaW5nL0dyYXBoRXhlY3V0aW9uUGxhbk5vZGVcIjtcbmltcG9ydCB0eXBlIHsgR3JhcGhQaW5uaW5nTWV0YWRhdGEgfSBmcm9tIFwiLi4vdHlwZXNcIjtcbmltcG9ydCB7IERFRkFVTFRfUElOTklOR19NRVRBREFUQSwgaXNQaW5uYWJsZSB9IGZyb20gXCIuL0dyYXBoUGlubmluZ01ldGFkYXRhXCI7XG5cbi8qKlxuICogUG9saWN5IHRoYXQgZGVjaWRlcyBwaW5uaW5nIGJlaGF2aW91ciBmb3IgYSBwbGFuIG5vZGUuXG4gKi9cbmV4cG9ydCBjbGFzcyBHcmFwaFBpbm5pbmdQb2xpY3kge1xuICAvKiogUmV0dXJucyB3aGV0aGVyIHRoZSBub2RlIGlzIGFsbG93ZWQgdG8gYmUgcGlubmVkLiAqL1xuICBjYW5QaW4obm9kZTogR3JhcGhFeGVjdXRpb25QbGFuTm9kZSk6IGJvb2xlYW4ge1xuICAgIHJldHVybiBpc1Bpbm5hYmxlKHRoaXMuZ2V0UGlubmluZ01ldGFkYXRhKG5vZGUpKTtcbiAgfVxuXG4gIC8qKiBSZXR1cm5zIHdoZXRoZXIgdGhlIGVuZ2luZSBzaG91bGQgYXR0ZW1wdCB0byB1c2UgYSBwaW5uZWQgdmFsdWUgZm9yIHRoZSBub2RlLiAqL1xuICBzaG91bGRVc2VQaW5uZWRWYWx1ZShub2RlOiBHcmFwaEV4ZWN1dGlvblBsYW5Ob2RlKTogYm9vbGVhbiB7XG4gICAgY29uc3QgbWV0YWRhdGEgPSB0aGlzLmdldFBpbm5pbmdNZXRhZGF0YShub2RlKTtcbiAgICByZXR1cm4gbWV0YWRhdGEuZW5hYmxlZCA9PT0gdHJ1ZSAmJiBtZXRhZGF0YS5zdHJhdGVneSAhPT0gXCJkaXNhYmxlZFwiO1xuICB9XG5cbiAgLyoqIFJldHVybnMgd2hldGhlciBhdXRvbWF0aWMgcGlubmluZyBzaG91bGQgb2NjdXIgYWZ0ZXIgZXhlY3V0aW9uLiAqL1xuICBzaG91bGRBdXRvUGluKG5vZGU6IEdyYXBoRXhlY3V0aW9uUGxhbk5vZGUpOiBib29sZWFuIHtcbiAgICBjb25zdCBtZXRhZGF0YSA9IHRoaXMuZ2V0UGlubmluZ01ldGFkYXRhKG5vZGUpO1xuICAgIHJldHVybiBtZXRhZGF0YS5lbmFibGVkID09PSB0cnVlICYmIG1ldGFkYXRhLnN0cmF0ZWd5ID09PSBcImF1dG9tYXRpY1wiO1xuICB9XG5cbiAgLyoqIEV4dHJhY3RzIHBpbm5pbmcgbWV0YWRhdGEgZnJvbSBhIHBsYW4gbm9kZS4gKi9cbiAgZ2V0UGlubmluZ01ldGFkYXRhKG5vZGU6IEdyYXBoRXhlY3V0aW9uUGxhbk5vZGUpOiBHcmFwaFBpbm5pbmdNZXRhZGF0YSB7XG4gICAgY29uc3QgcmF3ID1cbiAgICAgIChub2RlLmRlZmluaXRpb24gYXMgYW55KT8uZ3JhcGg/Lm1ldGFkYXRhPy5waW5uYWJsZSA/P1xuICAgICAgKG5vZGUubWV0YWRhdGEgYXMgYW55KT8ucGlubmFibGU7XG4gICAgcmV0dXJuIHJhd1xuICAgICAgPyB7IC4uLkRFRkFVTFRfUElOTklOR19NRVRBREFUQSwgLi4ucmF3IH1cbiAgICAgIDogeyAuLi5ERUZBVUxUX1BJTk5JTkdfTUVUQURBVEEsIGVuYWJsZWQ6IGZhbHNlIH07XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/engine/pinning/GraphPinningService.cjs

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphPinningService = void 0;
+/**
+ * @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.
+ */
+const constants_js_1 = require("./../constants.cjs");
+const GraphPinningError_js_1 = require("./../errors/GraphPinningError.cjs");
+const GraphTopology_js_1 = require("./../planning/GraphTopology.cjs");
+/**
+ * Service that manages pinning and unpinning of graph node values.
+ */
+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_js_1.GraphPinningError(`Node '${nodeId}' not found in plan`);
+            }
+            if (!this.policy.canPin(node)) {
+                throw new GraphPinningError_js_1.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_js_1.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_js_1.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}`;
+    }
+}
+exports.GraphPinningService = GraphPinningService;
+void constants_js_1.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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphPinningService.js","sourceRoot":"","sources":["GraphPinningService.js"],"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.js\";\nimport { GraphPinningError } from \"./../errors/GraphPinningError.js\";\nimport { GraphTopology } from \"./../planning/GraphTopology.js\";\n/**\n * Service that manages pinning and unpinning of graph node values.\n */\nexport class GraphPinningService {\n    constructor(store, policy, dependencyResolver) {\n        this.store = store;\n        this.policy = policy;\n        this.dependencyResolver = dependencyResolver;\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) {\n        const plan = options.plan;\n        const includeDependencies = options.includeDependencies ?? true;\n        const pinSet = includeDependencies\n            ? this.dependencyResolver.getPinSet(plan, options.nodeId)\n            : new Set([options.nodeId]);\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(`Node '${nodeId}' is not pinnable`, { nodeId });\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(`Node '${nodeId}' has no completed output to pin`);\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 = {\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     * Unpins a single node (does not unpin dependents in v1).\n     */\n    async unpinNode(options) {\n        const key = {\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     * Reads a pinned value for a node, returning `undefined` when no valid\n     * pinned value exists.\n     */\n    async readPinnedValue(workflow, node, inputs, dependencyFingerprints, namespace) {\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     * Creates a stable value key for a node.\n     */\n    createValueKey(workflow, node, inputs, dependencyFingerprints, namespace) {\n        return {\n            workflowId: workflow.name,\n            nodeId: node.id,\n            fingerprint: this.computeFingerprint(workflow, node, inputs, dependencyFingerprints),\n            namespace,\n        };\n    }\n    /**\n     * Computes a stable fingerprint for a node's inputs and dependencies.\n     */\n    computeFingerprint(workflow, node, inputs, dependencyFingerprints) {\n        const data = {\n            workflowId: workflow.name,\n            nodeId: node.id,\n            nodeKind: node.kind,\n            nodeDefinitionVersion: node.definition?.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     * Returns a topological ordering of the given node set.\n     */\n    topologicalOrder(plan, nodeSet) {\n        const result = [];\n        const visited = new Set();\n        const visit = (nodeId) => {\n            if (visited.has(nodeId))\n                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))\n                    visit(dep);\n            }\n            result.push(nodeId);\n        };\n        for (const nodeId of nodeSet)\n            visit(nodeId);\n        return result;\n    }\n    /**\n     * Computes fingerprints for all upstream dependencies of a node.\n     */\n    dependencyFingerprints(plan, nodeId, result) {\n        const deps = this.dependencyResolver.getDependencies(plan, nodeId);\n        const fingerprints = {};\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     * Serializes a value with recursively sorted keys for stable hashing.\n     */\n    stableSerialize(value) {\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((k) => `${JSON.stringify(k)}:${this.stableSerialize(value[k])}`);\n        return `{${pairs.join(\",\")}}`;\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    simpleHash(str) {\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}\nvoid GRAPH_PINNING_METADATA_KEY;\n//# 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/cjs/graph/{pinning → engine/pinning}/index.cjs

@@ -23,5 +23,5 @@ __exportStar(require("./GraphPinningMetadata.cjs"), exports);
 __exportStar(require("./GraphPinningPolicy.cjs"), exports);
 __exportStar(require("./GraphPinningDependencyResolver.cjs"), exports);
 __exportStar(require("./GraphPinningService.cjs"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ3JhcGgvcGlubmluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsMENBQXVDO0FBQ3ZDLHdDQUFxQztBQUNyQyxvREFBaUQ7QUFDakQseUNBQXNDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9waW5uaW5nXG4gKiBAc3VtbWFyeSBHcmFwaCBwaW5uaW5nIHN1YnN5c3RlbS5cbiAqIEBkZXNjcmlwdGlvbiBSZS1leHBvcnRzIHRoZSBwaW5uaW5nIG1ldGFkYXRhLCBwb2xpY3ksIGRlcGVuZGVuY3kgcmVzb2x2ZXIsIGFuZCBzZXJ2aWNlLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaFBpbm5pbmdNZXRhZGF0YVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nUG9saWN5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaFBpbm5pbmdEZXBlbmRlbmN5UmVzb2x2ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoUGlubmluZ1NlcnZpY2VcIjtcbiJdfQ==
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7Ozs7R0FJRztBQUNILDREQUEwQztBQUMxQywwREFBd0M7QUFDeEMsc0VBQW9EO0FBQ3BELDJEQUF5QztBQUN6QywweUJBQTB5QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvcGlubmluZ1xuICogQHN1bW1hcnkgR3JhcGggcGlubmluZyBzdWJzeXN0ZW0uXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgcGlubmluZyBtZXRhZGF0YSwgcG9saWN5LCBkZXBlbmRlbmN5IHJlc29sdmVyLCBhbmQgc2VydmljZS5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nTWV0YWRhdGEuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoUGlubmluZ1BvbGljeS5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nRGVwZW5kZW5jeVJlc29sdmVyLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaFBpbm5pbmdTZXJ2aWNlLmpzXCI7XG4vLyMgc291cmNlTWFwcGluZ1VSTD1kYXRhOmFwcGxpY2F0aW9uL2pzb247YmFzZTY0LGV5SjJaWEp6YVc5dUlqb3pMQ0ptYVd4bElqb2lhVzVrWlhndWFuTWlMQ0p6YjNWeVkyVlNiMjkwSWpvaUlpd2ljMjkxY21ObGN5STZXeUl1TGk4dUxpOHVMaTh1TGk5emNtTXZaM0poY0dndmNHbHVibWx1Wnk5cGJtUmxlQzUwY3lKZExDSnVZVzFsY3lJNlcxMHNJbTFoY0hCcGJtZHpJam9pUVVGQlFUczdPenRIUVVsSE8wRkJRMGdzTUVOQlFYVkRPMEZCUTNaRExIZERRVUZ4UXp0QlFVTnlReXh2UkVGQmFVUTdRVUZEYWtRc2VVTkJRWE5ESWl3aWMyOTFjbU5sYzBOdmJuUmxiblFpT2xzaUx5b3FYRzRnS2lCQWJXOWtkV3hsSUdsdWRHVm5jbUYwYVc5dWN5OW5jbUZ3YUM5d2FXNXVhVzVuWEc0Z0tpQkFjM1Z0YldGeWVTQkhjbUZ3YUNCd2FXNXVhVzVuSUhOMVluTjVjM1JsYlM1Y2JpQXFJRUJrWlhOamNtbHdkR2x2YmlCU1pTMWxlSEJ2Y25SeklIUm9aU0J3YVc1dWFXNW5JRzFsZEdGa1lYUmhMQ0J3YjJ4cFkza3NJR1JsY0dWdVpHVnVZM2tnY21WemIyeDJaWElzSUdGdVpDQnpaWEoyYVdObExseHVJQ292WEc1bGVIQnZjblFnS2lCbWNtOXRJRndpTGk5SGNtRndhRkJwYm01cGJtZE5aWFJoWkdGMFlWd2lPMXh1Wlhod2IzSjBJQ29nWm5KdmJTQmNJaTR2UjNKaGNHaFFhVzV1YVc1blVHOXNhV041WENJN1hHNWxlSEJ2Y25RZ0tpQm1jbTl0SUZ3aUxpOUhjbUZ3YUZCcGJtNXBibWRFWlhCbGJtUmxibU41VW1WemIyeDJaWEpjSWp0Y2JtVjRjRzl5ZENBcUlHWnliMjBnWENJdUwwZHlZWEJvVUdsdWJtbHVaMU5sY25acFkyVmNJanRjYmlKZGZRPT0iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3Bpbm5pbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILDBDQUF1QztBQUN2Qyx3Q0FBcUM7QUFDckMsb0RBQWlEO0FBQ2pELHlDQUFzQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvcGlubmluZ1xuICogQHN1bW1hcnkgR3JhcGggcGlubmluZyBzdWJzeXN0ZW0uXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgcGlubmluZyBtZXRhZGF0YSwgcG9saWN5LCBkZXBlbmRlbmN5IHJlc29sdmVyLCBhbmQgc2VydmljZS5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nTWV0YWRhdGFcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoUGlubmluZ1BvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nRGVwZW5kZW5jeVJlc29sdmVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaFBpbm5pbmdTZXJ2aWNlXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7Ozs7R0FJRztBQUNILDREQUEwQztBQUMxQywwREFBd0M7QUFDeEMsc0VBQW9EO0FBQ3BELDJEQUF5QztBQUN6QyxzekJBQXN6QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvcGlubmluZ1xuICogQHN1bW1hcnkgR3JhcGggcGlubmluZyBzdWJzeXN0ZW0uXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgcGlubmluZyBtZXRhZGF0YSwgcG9saWN5LCBkZXBlbmRlbmN5IHJlc29sdmVyLCBhbmQgc2VydmljZS5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nTWV0YWRhdGEuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoUGlubmluZ1BvbGljeS5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQaW5uaW5nRGVwZW5kZW5jeVJlc29sdmVyLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaFBpbm5pbmdTZXJ2aWNlLmpzXCI7XG4vLyMgc291cmNlTWFwcGluZ1VSTD1kYXRhOmFwcGxpY2F0aW9uL2pzb247YmFzZTY0LGV5SjJaWEp6YVc5dUlqb3pMQ0ptYVd4bElqb2lhVzVrWlhndWFuTWlMQ0p6YjNWeVkyVlNiMjkwSWpvaUlpd2ljMjkxY21ObGN5STZXeUl1TGk4dUxpOHVMaTh1TGk4dUxpOXpjbU12WjNKaGNHZ3ZaVzVuYVc1bEwzQnBibTVwYm1jdmFXNWtaWGd1ZEhNaVhTd2libUZ0WlhNaU9sdGRMQ0p0WVhCd2FXNW5jeUk2SWtGQlFVRTdPenM3UjBGSlJ6dEJRVU5JTERCRFFVRjFRenRCUVVOMlF5eDNRMEZCY1VNN1FVRkRja01zYjBSQlFXbEVPMEZCUTJwRUxIbERRVUZ6UXlJc0luTnZkWEpqWlhORGIyNTBaVzUwSWpwYklpOHFLbHh1SUNvZ1FHMXZaSFZzWlNCcGJuUmxaM0poZEdsdmJuTXZaM0poY0dndmNHbHVibWx1WjF4dUlDb2dRSE4xYlcxaGNua2dSM0poY0dnZ2NHbHVibWx1WnlCemRXSnplWE4wWlcwdVhHNGdLaUJBWkdWelkzSnBjSFJwYjI0Z1VtVXRaWGh3YjNKMGN5QjBhR1VnY0dsdWJtbHVaeUJ0WlhSaFpHRjBZU3dnY0c5c2FXTjVMQ0JrWlhCbGJtUmxibU41SUhKbGMyOXNkbVZ5TENCaGJtUWdjMlZ5ZG1salpTNWNiaUFxTDF4dVpYaHdiM0owSUNvZ1puSnZiU0JjSWk0dlIzSmhjR2hRYVc1dWFXNW5UV1YwWVdSaGRHRmNJanRjYm1WNGNHOXlkQ0FxSUdaeWIyMGdYQ0l1TDBkeVlYQm9VR2x1Ym1sdVoxQnZiR2xqZVZ3aU8xeHVaWGh3YjNKMElDb2dabkp2YlNCY0lpNHZSM0poY0doUWFXNXVhVzVuUkdWd1pXNWtaVzVqZVZKbGMyOXNkbVZ5WENJN1hHNWxlSEJ2Y25RZ0tpQm1jbTl0SUZ3aUxpOUhjbUZ3YUZCcGJtNXBibWRUWlhKMmFXTmxYQ0k3WEc0aVhYMD0iXX0=

package/lib/cjs/graph/engine/planning/GraphExecutionPlan.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2dyYXBoL2VuZ2luZS9wbGFubmluZy9HcmFwaEV4ZWN1dGlvblBsYW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvcGxhbm5pbmcvR3JhcGhFeGVjdXRpb25QbGFuXG4gKiBAc3VtbWFyeSBUaGUgY29tcGxldGUgZXhlY3V0aW9uIHBsYW4gZm9yIGEgd29ya2Zsb3cuXG4gKiBAZGVzY3JpcHRpb24gQ29udGFpbnMgcmVzb2x2ZWQgbm9kZXMsIGVkZ2VzLCB0b3BvbG9naWNhbCBsYXllcnMsIGFuZCBpbmNvbWluZy9vdXRnb2luZyBtYXBzLlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoV29ya2Zsb3dEZWZpbml0aW9uIH0gZnJvbSBcIkBkZWNhZi10cy91aS1kZWNvcmF0b3JzL2dyYXBoXCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uUGxhbk5vZGUgfSBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblBsYW5Ob2RlXCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uUGxhbkVkZ2UgfSBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblBsYW5FZGdlXCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uUGxhbkxheWVyIH0gZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25QbGFuTGF5ZXJcIjtcblxuLyoqXG4gKiBUaGUgcmVzb2x2ZWQgZXhlY3V0aW9uIHBsYW4gZm9yIGEgc2luZ2xlIHdvcmtmbG93LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEdyYXBoRXhlY3V0aW9uUGxhbiB7XG4gIHdvcmtmbG93OiBHcmFwaFdvcmtmbG93RGVmaW5pdGlvbjtcbiAgd29ya2Zsb3dJZDogc3RyaW5nO1xuICBub2RlczogR3JhcGhFeGVjdXRpb25QbGFuTm9kZVtdO1xuICBlZGdlczogR3JhcGhFeGVjdXRpb25QbGFuRWRnZVtdO1xuICBsYXllcnM6IEdyYXBoRXhlY3V0aW9uUGxhbkxheWVyW107XG4gIGluY29taW5nQnlOb2RlOiBNYXA8c3RyaW5nLCBHcmFwaEV4ZWN1dGlvblBsYW5FZGdlW10+O1xuICBvdXRnb2luZ0J5Tm9kZTogTWFwPHN0cmluZywgR3JhcGhFeGVjdXRpb25QbGFuRWRnZVtdPjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/engine/planning/GraphExecutionPlanEdge.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuRWRnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvcGxhbm5pbmcvR3JhcGhFeGVjdXRpb25QbGFuRWRnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9wbGFubmluZy9HcmFwaEV4ZWN1dGlvblBsYW5FZGdlXG4gKiBAc3VtbWFyeSBQbGFuIGVkZ2UgdHlwZSBmb3IgdGhlIGV4ZWN1dGlvbiBwbGFuLlxuICogQGRlc2NyaXB0aW9uIFJlcHJlc2VudHMgYSBkaXJlY3RlZCB2YWx1ZSByb3V0ZSBiZXR3ZWVuIHR3byBlbmRwb2ludHMgKG5vZGUtdG8tbm9kZSBvciBub2RlLXRvLXdvcmtmbG93LWJvdW5kYXJ5KS5cbiAqL1xuXG4vKipcbiAqIEFuIGVkZ2UgaW4gdGhlIGV4ZWN1dGlvbiBwbGFuIHJlcHJlc2VudGluZyBhIHZhbHVlIHJvdXRlIGZyb20gYSBzb3VyY2VcbiAqIHBvcnQgdG8gYSB0YXJnZXQgcG9ydC5cbiAqXG4gKiBgc291cmNlTm9kZUlkYCBvciBgdGFyZ2V0Tm9kZUlkYCBtYXkgYmUge0BsaW5rIEdSQVBIX1dPUktGTE9XX0JPVU5EQVJZfSB3aGVuXG4gKiB0aGUgZWRnZSBjb25uZWN0cyB0byB0aGUgd29ya2Zsb3cgYm91bmRhcnkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR3JhcGhFeGVjdXRpb25QbGFuRWRnZSB7XG4gIGlkOiBzdHJpbmc7XG4gIHNvdXJjZU5vZGVJZDogc3RyaW5nO1xuICBzb3VyY2VQb3J0OiBzdHJpbmc7XG4gIHRhcmdldE5vZGVJZDogc3RyaW5nO1xuICB0YXJnZXRQb3J0OiBzdHJpbmc7XG4gIGxhYmVsPzogc3RyaW5nO1xuICBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/engine/planning/GraphExecutionPlanLayer.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuTGF5ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3BsYW5uaW5nL0dyYXBoRXhlY3V0aW9uUGxhbkxheWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL3BsYW5uaW5nL0dyYXBoRXhlY3V0aW9uUGxhbkxheWVyXG4gKiBAc3VtbWFyeSBBIGxheWVyIG9mIG5vZGVzIHRoYXQgY2FuIGV4ZWN1dGUgaW4gcGFyYWxsZWwuXG4gKiBAZGVzY3JpcHRpb24gUHJvZHVjZWQgYnkgdGhlIHRvcG9sb2dpY2FsIHBsYW5uZXI7IGFsbCBub2RlcyBpbiBhIGxheWVyIGhhdmUgbm8gZGVwZW5kZW5jaWVzIG9uIGVhY2ggb3RoZXIuXG4gKi9cbmltcG9ydCB0eXBlIHsgR3JhcGhFeGVjdXRpb25QbGFuTm9kZSB9IGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uUGxhbk5vZGVcIjtcblxuLyoqXG4gKiBBIHRvcG9sb2dpY2FsIGxheWVyIG9mIG5vZGVzIHRoYXQgbWF5IGV4ZWN1dGUgaW4gcGFyYWxsZWwuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR3JhcGhFeGVjdXRpb25QbGFuTGF5ZXIge1xuICBpbmRleDogbnVtYmVyO1xuICBub2RlczogR3JhcGhFeGVjdXRpb25QbGFuTm9kZVtdO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuTGF5ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJHcmFwaEV4ZWN1dGlvblBsYW5MYXllci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUNBLDA4QkFBMDhCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHt9O1xuLy8jIHNvdXJjZU1hcHBpbmdVUkw9ZGF0YTphcHBsaWNhdGlvbi9qc29uO2Jhc2U2NCxleUoyWlhKemFXOXVJam96TENKbWFXeGxJam9pUjNKaGNHaEZlR1ZqZFhScGIyNVFiR0Z1VEdGNVpYSXVhbk1pTENKemIzVnlZMlZTYjI5MElqb2lJaXdpYzI5MWNtTmxjeUk2V3lJdUxpOHVMaTh1TGk4dUxpOHVMaTl6Y21NdlozSmhjR2d2Wlc1bmFXNWxMM0JzWVc1dWFXNW5MMGR5WVhCb1JYaGxZM1YwYVc5dVVHeGhia3hoZVdWeUxuUnpJbDBzSW01aGJXVnpJanBiWFN3aWJXRndjR2x1WjNNaU9pSWlMQ0p6YjNWeVkyVnpRMjl1ZEdWdWRDSTZXeUl2S2lwY2JpQXFJRUJ0YjJSMWJHVWdhVzUwWldkeVlYUnBiMjV6TDJkeVlYQm9MM0JzWVc1dWFXNW5MMGR5WVhCb1JYaGxZM1YwYVc5dVVHeGhia3hoZVdWeVhHNGdLaUJBYzNWdGJXRnllU0JCSUd4aGVXVnlJRzltSUc1dlpHVnpJSFJvWVhRZ1kyRnVJR1Y0WldOMWRHVWdhVzRnY0dGeVlXeHNaV3d1WEc0Z0tpQkFaR1Z6WTNKcGNIUnBiMjRnVUhKdlpIVmpaV1FnWW5rZ2RHaGxJSFJ2Y0c5c2IyZHBZMkZzSUhCc1lXNXVaWEk3SUdGc2JDQnViMlJsY3lCcGJpQmhJR3hoZVdWeUlHaGhkbVVnYm04Z1pHVndaVzVrWlc1amFXVnpJRzl1SUdWaFkyZ2diM1JvWlhJdVhHNGdLaTljYm1sdGNHOXlkQ0IwZVhCbElIc2dSM0poY0doRmVHVmpkWFJwYjI1UWJHRnVUbTlrWlNCOUlHWnliMjBnWENJdUwwZHlZWEJvUlhobFkzVjBhVzl1VUd4aGJrNXZaR1ZjSWp0Y2JseHVMeW9xWEc0Z0tpQkJJSFJ2Y0c5c2IyZHBZMkZzSUd4aGVXVnlJRzltSUc1dlpHVnpJSFJvWVhRZ2JXRjVJR1Y0WldOMWRHVWdhVzRnY0dGeVlXeHNaV3d1WEc0Z0tpOWNibVY0Y0c5eWRDQnBiblJsY21aaFkyVWdSM0poY0doRmVHVmpkWFJwYjI1UWJHRnVUR0Y1WlhJZ2UxeHVJQ0JwYm1SbGVEb2diblZ0WW1WeU8xeHVJQ0J1YjJSbGN6b2dSM0poY0doRmVHVmpkWFJwYjI1UWJHRnVUbTlrWlZ0ZE8xeHVmVnh1SWwxOSJdfQ==

package/lib/cjs/graph/engine/planning/GraphExecutionPlanNode.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvcGxhbm5pbmcvR3JhcGhFeGVjdXRpb25QbGFuTm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9wbGFubmluZy9HcmFwaEV4ZWN1dGlvblBsYW5Ob2RlXG4gKiBAc3VtbWFyeSBQbGFuIG5vZGUgdHlwZSBmb3IgdGhlIGV4ZWN1dGlvbiBwbGFuLlxuICogQGRlc2NyaXB0aW9uIFJlcHJlc2VudHMgYSBzaW5nbGUgbm9kZSByZXNvbHZlZCBmcm9tIGEgd29ya2Zsb3cgZGVmaW5pdGlvbiwgcmVhZHkgZm9yIGV4ZWN1dGlvbi5cbiAqL1xuaW1wb3J0IHR5cGUge1xuICBHcmFwaE5vZGVEZWZpbml0aW9uLFxuICBHcmFwaFdvcmtmbG93Tm9kZU1ldGFkYXRhLFxufSBmcm9tIFwiQGRlY2FmLXRzL3VpLWRlY29yYXRvcnMvZ3JhcGhcIjtcblxuLyoqXG4gKiBBIG5vZGUgaW4gdGhlIGV4ZWN1dGlvbiBwbGFuLCBkZXJpdmVkIGZyb20gYSB3b3JrZmxvdydzIG5vZGUgbWV0YWRhdGEgYW5kXG4gKiBpdHMgcmVzb2x2ZWQgZ3JhcGggZGVmaW5pdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBHcmFwaEV4ZWN1dGlvblBsYW5Ob2RlIHtcbiAgaWQ6IHN0cmluZztcbiAga2luZDogc3RyaW5nO1xuICBsYWJlbD86IHN0cmluZztcbiAgc291cmNlOiBHcmFwaFdvcmtmbG93Tm9kZU1ldGFkYXRhO1xuICBkZWZpbml0aW9uOiBHcmFwaE5vZGVEZWZpbml0aW9uO1xuICBpbnB1dFBvcnRzOiBzdHJpbmdbXTtcbiAgb3V0cHV0UG9ydHM6IHN0cmluZ1tdO1xuICBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFeGVjdXRpb25QbGFuTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIkdyYXBoRXhlY3V0aW9uUGxhbk5vZGUuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFDQSxzdkNBQXN2QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7fTtcbi8vIyBzb3VyY2VNYXBwaW5nVVJMPWRhdGE6YXBwbGljYXRpb24vanNvbjtiYXNlNjQsZXlKMlpYSnphVzl1SWpvekxDSm1hV3hsSWpvaVIzSmhjR2hGZUdWamRYUnBiMjVRYkdGdVRtOWtaUzVxY3lJc0luTnZkWEpqWlZKdmIzUWlPaUlpTENKemIzVnlZMlZ6SWpwYklpNHVMeTR1THk0dUx5NHVMeTR1TDNOeVl5OW5jbUZ3YUM5bGJtZHBibVV2Y0d4aGJtNXBibWN2UjNKaGNHaEZlR1ZqZFhScGIyNVFiR0Z1VG05a1pTNTBjeUpkTENKdVlXMWxjeUk2VzEwc0ltMWhjSEJwYm1keklqb2lJaXdpYzI5MWNtTmxjME52Ym5SbGJuUWlPbHNpTHlvcVhHNGdLaUJBYlc5a2RXeGxJR2x1ZEdWbmNtRjBhVzl1Y3k5bmNtRndhQzl3YkdGdWJtbHVaeTlIY21Gd2FFVjRaV04xZEdsdmJsQnNZVzVPYjJSbFhHNGdLaUJBYzNWdGJXRnllU0JRYkdGdUlHNXZaR1VnZEhsd1pTQm1iM0lnZEdobElHVjRaV04xZEdsdmJpQndiR0Z1TGx4dUlDb2dRR1JsYzJOeWFYQjBhVzl1SUZKbGNISmxjMlZ1ZEhNZ1lTQnphVzVuYkdVZ2JtOWtaU0J5WlhOdmJIWmxaQ0JtY205dElHRWdkMjl5YTJac2IzY2daR1ZtYVc1cGRHbHZiaXdnY21WaFpIa2dabTl5SUdWNFpXTjFkR2x2Ymk1Y2JpQXFMMXh1YVcxd2IzSjBJSFI1Y0dVZ2UxeHVJQ0JIY21Gd2FFNXZaR1ZFWldacGJtbDBhVzl1TEZ4dUlDQkhjbUZ3YUZkdmNtdG1iRzkzVG05a1pVMWxkR0ZrWVhSaExGeHVmU0JtY205dElGd2lRR1JsWTJGbUxYUnpMM1ZwTFdSbFkyOXlZWFJ2Y25NdlozSmhjR2hjSWp0Y2JseHVMeW9xWEc0Z0tpQkJJRzV2WkdVZ2FXNGdkR2hsSUdWNFpXTjFkR2x2YmlCd2JHRnVMQ0JrWlhKcGRtVmtJR1p5YjIwZ1lTQjNiM0pyWm14dmR5ZHpJRzV2WkdVZ2JXVjBZV1JoZEdFZ1lXNWtYRzRnS2lCcGRITWdjbVZ6YjJ4MlpXUWdaM0poY0dnZ1pHVm1hVzVwZEdsdmJpNWNiaUFxTDF4dVpYaHdiM0owSUdsdWRHVnlabUZqWlNCSGNtRndhRVY0WldOMWRHbHZibEJzWVc1T2IyUmxJSHRjYmlBZ2FXUTZJSE4wY21sdVp6dGNiaUFnYTJsdVpEb2djM1J5YVc1bk8xeHVJQ0JzWVdKbGJEODZJSE4wY21sdVp6dGNiaUFnYzI5MWNtTmxPaUJIY21Gd2FGZHZjbXRtYkc5M1RtOWtaVTFsZEdGa1lYUmhPMXh1SUNCa1pXWnBibWwwYVc5dU9pQkhjbUZ3YUU1dlpHVkVaV1pwYm1sMGFXOXVPMXh1SUNCcGJuQjFkRkJ2Y25Sek9pQnpkSEpwYm1kYlhUdGNiaUFnYjNWMGNIVjBVRzl5ZEhNNklITjBjbWx1WjF0ZE8xeHVJQ0J0WlhSaFpHRjBZVDg2SUZKbFkyOXlaRHh6ZEhKcGJtY3NJSFZ1YTI1dmQyNCtPMXh1ZlZ4dUlsMTkiXX0=