cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/workers/post-result.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postResultCloneSafe = postResultCloneSafe;
+/**
+ * Worker → main result delivery with clone-safety (#2112).
+ *
+ * Extracted from `parse-worker.ts` into its own side-effect-free module so it
+ * can be imported and exercised directly (the parse worker is an entry module:
+ * importing it would construct the parser, post `ready`, and attach the real
+ * message handler). The integration test imports `postResultCloneSafe` from
+ * here to cover the production wiring end to end rather than re-implementing it.
+ */
+const node_worker_threads_1 = require("node:worker_threads");
+const clone_safety_js_1 = require("./clone-safety.js");
+/**
+ * Strict mode (opt-in via `CGRAPH_STRICT_CLONE=1`, inherited by workers). When
+ * on, a clone failure THROWS with the offending key path instead of silently
+ * sanitizing + delivering — so a leak introduced by a future provider/extractor
+ * change fails LOUDLY (in CI / dev) at its origin rather than being quietly
+ * stripped in production. The silent-recovery behavior is exactly what hid the
+ * original #2112 leak; strict mode removes the silence where we want loudness.
+ * Off in production, where the net's job is to keep the run alive.
+ */
+const STRICT_CLONE = process.env.CGRAPH_STRICT_CLONE === '1';
+/**
+ * Deliver the accumulated result to the pool, surviving a non-cloneable value
+ * (#2112). Fast path: post as-is — on a healthy result this is the only thing
+ * that runs, so clone-safety adds zero overhead to normal runs. If structured
+ * clone rejects the payload (a function/symbol leaked into an extraction
+ * record — the reporter's case was a node `properties` value pointing at a
+ * native `toString`), rewrite the boundary-crossing arrays so the result is
+ * cloneable, record the affected paths on `result.skippedPaths`, warn the
+ * operator naming the offending field + file (so the still-unpinned leak is
+ * diagnosable from logs and fixable at source), and re-post.
+ *
+ * Recovery is attempted for ANY first-post failure, not only a `DataCloneError`.
+ * structuredClone invokes getters, and a getter that THROWS surfaces its own
+ * error (a `RangeError`, etc.) — NOT a `DataCloneError` (confirmed against a
+ * real MessageChannel). Gating recovery on `DataCloneError` let such a throw
+ * re-throw past the sanitizer and re-arm, under `POOL_SIZE=1`, the worker-death
+ * cascade this net prevents. The recovery path is wrapped in its own try/catch
+ * so a still-uncloneable re-post fails closed to a primitive-only
+ * `{type:'error'}` DELIBERATELY rather than escaping the worker.
+ */
+function postResultCloneSafe(result) {
+    try {
+        node_worker_threads_1.parentPort.postMessage({ type: 'result', data: result });
+        return;
+    }
+    catch {
+        // Fall through to recovery on ANY failure (DataCloneError OR a throwing
+        // getter's own error). A healthy post returned above and never reaches here.
+    }
+    try {
+        // `as unknown as Record<string, unknown>` is the standard widening for a
+        // no-index-signature interface (TS rejects a single-step `as`). The field
+        // sets are typed to `keyof ParseWorkerResult` so renaming a field is a
+        // compile error here, not a silent loss of the drop-whole / skip protection.
+        const { skipped } = (0, clone_safety_js_1.makeWorkerResultCloneSafe)(result, {
+            dropWholeElement: new Set(['parsedFiles']),
+            skipFields: new Set(['skippedPaths']),
+        });
+        if (skipped.length > 0) {
+            if (STRICT_CLONE) {
+                // Surface the leak loudly with its exact key path(s) instead of
+                // delivering a sanitized result. Routes to the catch below → a
+                // primitive-only {type:'error'} the pool reports, failing CI.
+                const detail = skipped.map((s) => `${s.path}: ${s.reason}`).join('; ');
+                throw new Error(`CGRAPH_STRICT_CLONE: worker result was not structured-cloneable — ${detail}`);
+            }
+            result.skippedPaths = [...(result.skippedPaths ?? []), ...skipped];
+            const sample = skipped
+                .slice(0, 5)
+                .map((s) => `${s.path} (${s.reason})`)
+                .join('; ');
+            const more = skipped.length > 5 ? ` …and ${skipped.length - 5} more` : '';
+            if (node_worker_threads_1.parentPort) {
+                node_worker_threads_1.parentPort.postMessage({
+                    type: 'warning',
+                    message: `Sanitized ${skipped.length} file(s) with non-serializable parse output before delivery: ${sample}${more}`,
+                });
+            }
+        }
+        node_worker_threads_1.parentPort.postMessage({ type: 'result', data: result });
+    }
+    catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        node_worker_threads_1.parentPort.postMessage({ type: 'error', error: e.message, errorStack: e.stack });
+    }
+}

package/dist/core/code/engine/core/ingestion/workers/quarantine.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Quarantine layer (Layer 3 of the worker-pool resilience model).
+ *
+ * Tracks paths that caused a worker death this pool lifetime and must
+ * not be re-dispatched to a worker. Session-scoped — created once per
+ * `createWorkerPool` invocation and discarded with the pool.
+ *
+ * This module is the first piece of the U13 layer-extraction work. The
+ * doc-review's A10 finding flagged the full 5-module split as
+ * abstraction-without-multi-consumer-demand, so the rest of the
+ * extraction is deferred until a real second consumer emerges (e.g., a
+ * non-parse worker pool that reuses the same resilience layers).
+ * Extracting the smallest self-contained layer first validates the
+ * factory + interface pattern with minimal risk: behavior is unchanged,
+ * the worker-pool.ts public API is unchanged, and existing tests act as
+ * the regression net.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQuarantine = createQuarantine;
+/**
+ * Construct a fresh quarantine. Each `createWorkerPool` invocation gets
+ * its own instance — quarantines never outlive the pool that created
+ * them. The implementation is a thin wrapper around `Set<string>`; the
+ * named interface exists to make the resilience layer addressable as a
+ * unit (named module, dedicated tests) instead of an inline Set field
+ * tangled into 1100+ LOC of pool plumbing.
+ */
+function createQuarantine() {
+    const paths = new Set();
+    return {
+        add: (path) => {
+            paths.add(path);
+        },
+        has: (path) => paths.has(path),
+        snapshot: () => Array.from(paths),
+        get size() {
+            return paths.size;
+        },
+    };
+}

package/dist/core/code/engine/core/ingestion/workers/result-merge.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeResult = void 0;
+// Use a loop instead of push(...spread) to avoid hitting V8's argument limit
+// when merging large result sets (push(...arr) calls apply() under the hood
+// and blows the stack when arr has >~65k elements).
+const appendAll = (target, src) => {
+    for (let i = 0; i < src.length; i++)
+        target.push(src[i]);
+};
+/**
+ * Merge `src` into `target` in place: append every boundary-crossing array,
+ * sum the per-language skip counts, union the clone-safety `skippedPaths`, and
+ * add the file count.
+ */
+const mergeResult = (target, src) => {
+    appendAll(target.nodes, src.nodes);
+    appendAll(target.relationships, src.relationships);
+    appendAll(target.symbols, src.symbols);
+    appendAll(target.calls, src.calls);
+    appendAll(target.assignments, src.assignments);
+    appendAll(target.routes, src.routes);
+    appendAll(target.fetchCalls, src.fetchCalls);
+    appendAll(target.fetchWrapperDefs, src.fetchWrapperDefs);
+    appendAll(target.decoratorRoutes, src.decoratorRoutes);
+    if (src.routerIncludes)
+        appendAll(target.routerIncludes, src.routerIncludes);
+    if (src.routerImports)
+        appendAll(target.routerImports, src.routerImports);
+    if (src.routerConstructorPrefixes) {
+        target.routerConstructorPrefixes ??= [];
+        appendAll(target.routerConstructorPrefixes, src.routerConstructorPrefixes);
+    }
+    if (src.routerModuleAliases) {
+        target.routerModuleAliases ??= [];
+        appendAll(target.routerModuleAliases, src.routerModuleAliases);
+    }
+    if (src.moduleConstants) {
+        target.moduleConstants ??= [];
+        appendAll(target.moduleConstants, src.moduleConstants);
+    }
+    if (src.springTypes) {
+        target.springTypes ??= [];
+        appendAll(target.springTypes, src.springTypes);
+    }
+    appendAll(target.toolDefs, src.toolDefs);
+    appendAll(target.ormQueries, src.ormQueries);
+    appendAll(target.constructorBindings, src.constructorBindings);
+    appendAll(target.fileScopeBindings, src.fileScopeBindings);
+    appendAll(target.parsedFiles, src.parsedFiles);
+    for (const [lang, count] of Object.entries(src.skippedLanguages)) {
+        target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
+    }
+    if (src.skippedPaths && src.skippedPaths.length > 0) {
+        (target.skippedPaths ??= []).push(...src.skippedPaths);
+    }
+    target.fileCount += src.fileCount;
+};
+exports.mergeResult = mergeResult;