@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/semantic/semantic-worker-manager.js

@@ -0,0 +1,460 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticWorkerTimeoutError = exports.SemanticWorkerManager = void 0;
+exports.readSemanticWorkerSessionMode = readSemanticWorkerSessionMode;
+exports.readSemanticWorkerDeadlineMs = readSemanticWorkerDeadlineMs;
+exports.normalizeShadowValue = normalizeShadowValue;
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const agent_text_1 = require("../shared/agent-text");
+const env_vars_1 = require("../config/env-vars");
+class SemanticWorkerManager {
+    executionMode;
+    deadlineMs;
+    readyTimeoutMs;
+    shutdownTimeoutMs;
+    maxPendingJobs;
+    maxObservations;
+    childModulePath;
+    childEnv;
+    onObservation;
+    queue = [];
+    dirtyJournal = [];
+    observations = [];
+    child = null;
+    childReady = null;
+    activeResponse = null;
+    draining = false;
+    disposed = false;
+    nextId = 1;
+    restartCount = 0;
+    constructor(options = {}) {
+        this.executionMode = options.executionMode ?? "shadow";
+        this.deadlineMs = Math.max(1, options.deadlineMs ?? 180_000);
+        this.readyTimeoutMs = Math.max(1, options.readyTimeoutMs ?? 5_000);
+        this.shutdownTimeoutMs = Math.max(1, options.shutdownTimeoutMs ?? 1_000);
+        this.maxPendingJobs = Math.max(0, Math.floor(options.maxPendingJobs ?? 1));
+        this.maxObservations = Math.max(1, Math.floor(options.maxObservations ?? 20));
+        this.childModulePath = options.childModulePath ?? path.join(__dirname, "semantic-worker-child.js");
+        this.childEnv = {
+            ...process.env,
+            [env_vars_1.CLI_ENV.disableWatchers]: "1",
+            ...options.childEnv
+        };
+        this.onObservation = options.onObservation;
+    }
+    get state() {
+        return {
+            childPid: this.child?.pid ?? null,
+            active: this.activeResponse !== null,
+            queued: this.queue.length,
+            restartCount: this.restartCount,
+            dirtyJournal: this.dirtyJournal.length,
+            observations: this.observations.map((item) => ({ ...item }))
+        };
+    }
+    compareInspectBoundaries(workspaceRoot, restArgs, authoritative) {
+        if (this.disposed)
+            return Promise.resolve(this.observe({ status: "shutdown", mode: "shadow", workspaceRoot }));
+        if (this.draining && this.queue.length >= this.maxPendingJobs) {
+            return Promise.resolve(this.observe({ status: "backpressure", mode: "shadow", workspaceRoot }));
+        }
+        return new Promise((resolveObservation, reject) => {
+            this.queue.push({
+                mode: "shadow",
+                workspaceRoot,
+                restArgs: [...restArgs],
+                authoritative,
+                inProcess: () => authoritative,
+                resolve: () => { },
+                resolveObservation,
+                reject
+            });
+            void this.drain();
+        });
+    }
+    executeInspectBoundaries(workspaceRoot, restArgs, inProcess) {
+        if (this.executionMode === "shadow") {
+            const authoritative = inProcess();
+            return this.compareInspectBoundaries(workspaceRoot, restArgs, authoritative).then(() => authoritative);
+        }
+        if (this.disposed) {
+            return Promise.resolve(this.runImmediateFallback("shutdown", workspaceRoot, inProcess));
+        }
+        if (this.draining && this.queue.length >= this.maxPendingJobs) {
+            return Promise.resolve(this.runImmediateFallback("backpressure", workspaceRoot, inProcess));
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                mode: "authoritative",
+                workspaceRoot,
+                restArgs: [...restArgs],
+                inProcess,
+                resolve,
+                reject
+            });
+            void this.drain();
+        });
+    }
+    invalidateWorkspace(workspaceRoot, change) {
+        if (this.disposed)
+            return;
+        if (!this.child || !this.child.connected) {
+            this.dirtyJournal.push({ workspaceRoot, change });
+            if (this.dirtyJournal.length > 100)
+                this.dirtyJournal.shift();
+            return;
+        }
+        if (!this.send({ type: "invalidate", id: this.id("invalidate"), workspaceRoot, change })) {
+            this.dirtyJournal.push({ workspaceRoot, change });
+            if (this.dirtyJournal.length > 100)
+                this.dirtyJournal.shift();
+        }
+    }
+    async shutdown() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const item of this.queue.splice(0)) {
+            const observation = this.observe({
+                status: "shutdown",
+                mode: item.mode,
+                workspaceRoot: item.workspaceRoot,
+                fallback: item.mode === "authoritative"
+            });
+            item.resolveObservation?.(observation);
+            if (item.mode === "authoritative") {
+                try {
+                    item.resolve(item.inProcess());
+                }
+                catch (error) {
+                    item.reject(error);
+                }
+            }
+        }
+        const child = this.child;
+        if (!child)
+            return;
+        const exit = onceExit(child);
+        if (child.connected)
+            this.send({ type: "shutdown", id: this.id("shutdown") });
+        await Promise.race([exit, delay(this.shutdownTimeoutMs)]);
+        if (this.child === child)
+            await this.terminateChild(new Error("Semantic worker shutdown."));
+    }
+    async drain() {
+        if (this.draining || this.disposed)
+            return;
+        this.draining = true;
+        try {
+            while (!this.disposed && this.queue.length > 0) {
+                const item = this.queue.shift();
+                await this.runItem(item);
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+    async runItem(item) {
+        if (item.mode === "shadow") {
+            item.resolveObservation?.(await this.runComparison(item));
+            return;
+        }
+        const startedAt = node_perf_hooks_1.performance.now();
+        let startupMs = 0;
+        try {
+            const execution = await this.executeWorkerJob(item);
+            startupMs = execution.startupMs;
+            const response = execution.response;
+            this.observe({
+                status: "authoritative",
+                mode: "authoritative",
+                workspaceRoot: item.workspaceRoot,
+                elapsedMs: node_perf_hooks_1.performance.now() - startedAt,
+                startupMs,
+                metrics: response.metrics
+            });
+            item.resolve(response.result);
+        }
+        catch (error) {
+            const timeout = error instanceof SemanticWorkerTimeoutError;
+            if (!timeout)
+                await this.terminateChild(error instanceof Error ? error : new Error(String(error)));
+            const fallbackStartedAt = node_perf_hooks_1.performance.now();
+            try {
+                const result = item.inProcess();
+                this.observe({
+                    status: timeout ? "timeout" : "error",
+                    mode: "authoritative",
+                    workspaceRoot: item.workspaceRoot,
+                    fallback: true,
+                    elapsedMs: node_perf_hooks_1.performance.now() - startedAt,
+                    fallbackMs: node_perf_hooks_1.performance.now() - fallbackStartedAt,
+                    startupMs,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                item.resolve(result);
+            }
+            catch (fallbackError) {
+                item.reject(fallbackError);
+            }
+        }
+    }
+    async runComparison(item) {
+        const startedAt = node_perf_hooks_1.performance.now();
+        let startupMs = 0;
+        try {
+            const execution = await this.executeWorkerJob(item);
+            startupMs = execution.startupMs;
+            const response = execution.response;
+            const authoritative = item.authoritative;
+            const authoritativeText = JSON.stringify(normalizeShadowValue(authoritative));
+            const shadowText = JSON.stringify(normalizeShadowValue(response.result));
+            return this.observe({
+                status: authoritativeText === shadowText ? "parity" : "mismatch",
+                mode: "shadow",
+                workspaceRoot: item.workspaceRoot,
+                structuredEqual: authoritativeText === shadowText,
+                agentTextEqual: authoritative[agent_text_1.AGENT_TEXT_FIELD] === response.result[agent_text_1.AGENT_TEXT_FIELD],
+                authoritativeDigest: digest(authoritativeText),
+                shadowDigest: digest(shadowText),
+                elapsedMs: node_perf_hooks_1.performance.now() - startedAt,
+                startupMs,
+                metrics: response.metrics
+            });
+        }
+        catch (error) {
+            const timeout = error instanceof SemanticWorkerTimeoutError;
+            return this.observe({
+                status: timeout ? "timeout" : "error",
+                mode: "shadow",
+                workspaceRoot: item.workspaceRoot,
+                elapsedMs: node_perf_hooks_1.performance.now() - startedAt,
+                startupMs,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    runWorkerJob(item) {
+        return this.request({
+            type: "job",
+            id: this.id("job"),
+            kind: "inspect-boundaries-owner-only",
+            workspaceRoot: item.workspaceRoot,
+            restArgs: item.restArgs
+        });
+    }
+    async executeWorkerJob(item) {
+        const readyStartedAt = node_perf_hooks_1.performance.now();
+        await this.ensureChild();
+        const startupMs = node_perf_hooks_1.performance.now() - readyStartedAt;
+        return { response: await this.runWorkerJob(item), startupMs };
+    }
+    async ensureChild() {
+        if (this.child && this.childReady) {
+            await this.childReady;
+            return;
+        }
+        const startedAt = node_perf_hooks_1.performance.now();
+        const child = (0, node_child_process_1.fork)(this.childModulePath, [], {
+            env: this.childEnv,
+            serialization: "advanced",
+            stdio: ["ignore", "ignore", "ignore", "ipc"]
+        });
+        this.child = child;
+        this.childReady = withTimeout(new Promise((resolve, reject) => {
+            const onMessage = (message) => {
+                if (message.type === "ready")
+                    resolve(node_perf_hooks_1.performance.now() - startedAt);
+            };
+            child.on("message", onMessage);
+            child.once("error", reject);
+            child.once("exit", (code) => reject(new Error(`Semantic worker exited before ready (${code ?? "signal"}).`)));
+        }), this.readyTimeoutMs, () => new SemanticWorkerTimeoutError("Semantic worker ready deadline exceeded."));
+        child.on("message", (message) => this.handleMessage(message));
+        child.on("exit", (code, signal) => this.handleExit(child, code, signal));
+        try {
+            await this.childReady;
+            for (const item of this.dirtyJournal.splice(0))
+                this.invalidateWorkspace(item.workspaceRoot, item.change);
+        }
+        catch (error) {
+            await this.terminateChild(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    async request(message) {
+        if (!this.child || !this.child.connected)
+            return Promise.reject(new Error("Semantic worker is not connected."));
+        const response = new Promise((resolve, reject) => {
+            this.activeResponse = { id: message.id, resolve, reject };
+            if (!this.send(message)) {
+                this.activeResponse = null;
+                reject(new Error("Semantic worker IPC channel is not available."));
+            }
+        });
+        try {
+            return await withTimeout(response, this.deadlineMs, () => new SemanticWorkerTimeoutError("Semantic worker job deadline exceeded."));
+        }
+        catch (error) {
+            if (error instanceof SemanticWorkerTimeoutError)
+                await this.terminateChild(error);
+            throw error;
+        }
+    }
+    handleMessage(message) {
+        if (message.type === "error" && this.activeResponse?.id === message.id) {
+            const active = this.activeResponse;
+            this.activeResponse = null;
+            active.reject(new Error(message.error.message));
+            return;
+        }
+        if (message.type === "result" && this.activeResponse?.id === message.id) {
+            const active = this.activeResponse;
+            this.activeResponse = null;
+            active.resolve(message);
+        }
+    }
+    handleExit(child, code, signal) {
+        if (this.child !== child)
+            return;
+        this.child = null;
+        this.childReady = null;
+        this.restartCount += 1;
+        const active = this.activeResponse;
+        this.activeResponse = null;
+        active?.reject(new Error(`Semantic worker exited (${code ?? signal ?? "unknown"}).`));
+    }
+    async terminateChild(reason) {
+        const child = this.child;
+        if (!child)
+            return;
+        const active = this.activeResponse;
+        this.activeResponse = null;
+        active?.reject(reason);
+        const exit = onceExit(child);
+        child.kill();
+        await Promise.race([exit, delay(this.shutdownTimeoutMs)]);
+        if (this.child === child) {
+            this.child = null;
+            this.childReady = null;
+            this.restartCount += 1;
+        }
+    }
+    send(message) {
+        if (!this.child?.connected)
+            return false;
+        try {
+            return this.child.send(message);
+        }
+        catch {
+            return false;
+        }
+    }
+    id(prefix) {
+        return `${prefix}_${this.nextId++}`;
+    }
+    runImmediateFallback(status, workspaceRoot, inProcess) {
+        const startedAt = node_perf_hooks_1.performance.now();
+        const result = inProcess();
+        const elapsedMs = node_perf_hooks_1.performance.now() - startedAt;
+        this.observe({
+            status,
+            mode: "authoritative",
+            workspaceRoot,
+            fallback: true,
+            elapsedMs,
+            fallbackMs: elapsedMs
+        });
+        return result;
+    }
+    observe(input) {
+        const observation = { ...input, restartCount: this.restartCount };
+        this.observations.push(observation);
+        if (this.observations.length > this.maxObservations)
+            this.observations.shift();
+        this.onObservation?.(observation);
+        return observation;
+    }
+}
+exports.SemanticWorkerManager = SemanticWorkerManager;
+function readSemanticWorkerSessionMode(env = process.env) {
+    const raw = env[env_vars_1.CLI_ENV.semanticWorkerMode]?.trim().toLowerCase();
+    if (raw === "shadow" || raw === "authoritative")
+        return raw;
+    if (env[env_vars_1.CLI_ENV.semanticWorkerShadow] === "1")
+        return "shadow";
+    return "off";
+}
+function readSemanticWorkerDeadlineMs(env = process.env) {
+    const raw = env[env_vars_1.CLI_ENV.semanticWorkerDeadlineMs] ?? env[env_vars_1.CLI_ENV.semanticWorkerShadowDeadlineMs];
+    const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 180_000;
+}
+class SemanticWorkerTimeoutError extends Error {
+    code = "SEMANTIC_WORKER_DEADLINE";
+}
+exports.SemanticWorkerTimeoutError = SemanticWorkerTimeoutError;
+function normalizeShadowValue(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeShadowValue);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => key !== "builtAt" && key !== "cache" && !key.endsWith("Ms"))
+        .map(([key, item]) => [key, normalizeShadowValue(item)]));
+}
+function digest(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value).digest("hex");
+}
+function withTimeout(promise, timeoutMs, error) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(error()), timeoutMs);
+        timer.unref();
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (reason) => { clearTimeout(timer); reject(reason); });
+    });
+}
+function onceExit(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve();
+    return new Promise((resolve) => child.once("exit", () => resolve()));
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/semantic/semantic-worker-protocol.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/semantic/semantic-worker-runtime.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticWorkerRuntime = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const node_v8_1 = __importDefault(require("node:v8"));
+const inspect_topology_1 = require("../commands/inspect-topology");
+const workspace_semantic_context_pools_1 = require("./workspace-semantic-context-pools");
+class SemanticWorkerRuntime {
+    pools = new workspace_semantic_context_pools_1.WorkspaceSemanticContextPools();
+    run(message) {
+        const startedAt = node_perf_hooks_1.performance.now();
+        const result = (0, inspect_topology_1.runInspectTopology)(message.workspaceRoot, message.restArgs, this.pools.forWorkspace(message.workspaceRoot));
+        const jobMs = node_perf_hooks_1.performance.now() - startedAt;
+        const serializeStartedAt = node_perf_hooks_1.performance.now();
+        const serializedBytes = node_v8_1.default.serialize(result).byteLength;
+        const serializeMs = node_perf_hooks_1.performance.now() - serializeStartedAt;
+        return {
+            result,
+            metrics: {
+                jobMs,
+                serializedBytes,
+                serializeMs,
+                memory: process.memoryUsage(),
+                poolRegistry: this.pools.state
+            }
+        };
+    }
+    invalidate(workspaceRoot, change) {
+        this.pools.invalidateWorkspace(workspaceRoot, change);
+    }
+    dispose() {
+        this.pools.dispose();
+    }
+}
+exports.SemanticWorkerRuntime = SemanticWorkerRuntime;

package/dist/semantic/workspace-semantic-context-pools.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceSemanticContextPools = void 0;
+const path = __importStar(require("node:path"));
+const semantic_context_pool_1 = require("./semantic-context-pool");
+const semantic_context_provider_1 = require("./semantic-context-provider");
+const semantic_resident_admission_1 = require("./semantic-resident-admission");
+/** Long-lived CLI-session owner for strictly workspace-local semantic pools. */
+class WorkspaceSemanticContextPools {
+    entries = new Map();
+    maxWorkspaces;
+    workspaceIdleTtlMs;
+    poolOptions;
+    now;
+    residentAdmissionCoordinator;
+    disposed = false;
+    constructor(options = {}) {
+        this.maxWorkspaces = Math.max(1, Math.floor(options.maxWorkspaces ?? 2));
+        this.workspaceIdleTtlMs = Math.max(0, options.workspaceIdleTtlMs ?? 5 * 60_000);
+        this.poolOptions = options.poolOptions ?? {};
+        this.residentAdmissionCoordinator = this.poolOptions.residentAdmissionCoordinator ?? new semantic_resident_admission_1.SemanticResidentAdmissionCoordinator();
+        this.now = options.now ?? Date.now;
+    }
+    get state() {
+        return {
+            disposed: this.disposed,
+            residentAdmission: this.residentAdmissionCoordinator.state,
+            workspaces: [...this.entries.values()].map((entry) => ({
+                root: entry.root,
+                lastUsedAt: entry.lastUsedAt,
+                pool: entry.pool.state
+            }))
+        };
+    }
+    forWorkspace(workspaceRoot) {
+        this.assertActive();
+        this.sweepExpired();
+        const root = path.resolve(workspaceRoot);
+        const key = (0, semantic_context_provider_1.canonicalSemanticFileKey)(root);
+        const existing = this.entries.get(key);
+        if (existing) {
+            existing.lastUsedAt = this.now();
+            this.touch(existing);
+            return existing.pool;
+        }
+        this.makeCapacity();
+        const entry = {
+            key,
+            root,
+            pool: new semantic_context_pool_1.SemanticContextPool(root, {
+                ...this.poolOptions,
+                residentAdmissionCoordinator: this.residentAdmissionCoordinator
+            }),
+            lastUsedAt: this.now()
+        };
+        this.entries.set(key, entry);
+        return entry.pool;
+    }
+    invalidateWorkspace(workspaceRoot, change) {
+        this.assertActive();
+        const entry = this.entries.get((0, semantic_context_provider_1.canonicalSemanticFileKey)(path.resolve(workspaceRoot)));
+        entry?.pool.invalidate(change);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        for (const entry of this.entries.values())
+            entry.pool.dispose();
+        this.entries.clear();
+        this.disposed = true;
+    }
+    sweepExpired() {
+        const cutoff = this.now() - this.workspaceIdleTtlMs;
+        for (const entry of [...this.entries.values()]) {
+            entry.pool.sweepIdle();
+            if (entry.lastUsedAt <= cutoff && entry.pool.state.activeLeases === 0) {
+                this.remove(entry);
+            }
+        }
+    }
+    makeCapacity() {
+        while (this.entries.size >= this.maxWorkspaces) {
+            const candidate = [...this.entries.values()].find((entry) => entry.pool.state.activeLeases === 0);
+            if (!candidate) {
+                throw new Error("All workspace semantic pools have active leases; cannot evict one safely.");
+            }
+            this.remove(candidate);
+        }
+    }
+    touch(entry) {
+        this.entries.delete(entry.key);
+        this.entries.set(entry.key, entry);
+    }
+    remove(entry) {
+        this.entries.delete(entry.key);
+        entry.pool.dispose();
+    }
+    assertActive() {
+        if (this.disposed)
+            throw new Error("WorkspaceSemanticContextPools is disposed.");
+    }
+}
+exports.WorkspaceSemanticContextPools = WorkspaceSemanticContextPools;