@darkiceinteractive/mcp-conductor 1.1.0 → 3.0.0-beta.1

package/dist/runtime/helpers/worker-preload.js

@@ -0,0 +1,223 @@
+/**
+ * Worker preload — inline sandbox helper source
+ *
+ * Generates the JavaScript source string that is written to a temp file
+ * and passed via WorkerOptions.preloadHelpers[] so the Deno worker evaluates
+ * it before any user code runs.  Injects compact/summarize/delta/budget/findTool
+ * onto the mcp global.
+ *
+ * @module runtime/helpers/worker-preload
+ */
+/**
+ * Build a self-contained JS source string for the Deno worker preload.
+ * The string is plain JavaScript — no TypeScript-only syntax — because
+ * it runs inside the Deno subprocess at runtime.
+ */
+export function buildHelperPreloadSource(options = {}) {
+    const toolsJson = JSON.stringify(options.tools ?? []);
+    const compactSrc = `
+(function injectCompact() {
+  function buildSelectorTree(fields) {
+    var tree = {};
+    for (var i = 0; i < fields.length; i++) {
+      var parts = fields[i].split('.');
+      var node = tree;
+      for (var j = 0; j < parts.length; j++) {
+        if (j === parts.length - 1) { node[parts[j]] = true; }
+        else { if (typeof node[parts[j]] !== 'object') node[parts[j]] = {}; node = node[parts[j]]; }
+      }
+    }
+    return tree;
+  }
+  function trimValue(value, selector, opts, depth) {
+    var maxDepth = opts.maxDepth !== undefined ? opts.maxDepth : Infinity;
+    if (depth > maxDepth) return (typeof value === 'object' && value !== null) ? '[truncated]' : value;
+    if (typeof value === 'string') {
+      var max = opts.maxStringLength;
+      return (max !== undefined && value.length > max) ? value.slice(0, max) + '…' : value;
+    }
+    if (Array.isArray(value)) {
+      var arr = opts.maxItems !== undefined ? value.slice(0, opts.maxItems) : value;
+      return arr.map(function(item) { return trimValue(item, selector, opts, depth + 1); });
+    }
+    if (typeof value === 'object' && value !== null) {
+      var result = {};
+      if (selector && Object.keys(selector).length > 0) {
+        var keys = Object.keys(selector);
+        for (var k = 0; k < keys.length; k++) {
+          var key = keys[k];
+          if (Object.prototype.hasOwnProperty.call(value, key)) {
+            var cs = selector[key];
+            result[key] = trimValue(value[key], cs === true ? null : cs, opts, depth + 1);
+          }
+        }
+      } else {
+        var objKeys = Object.keys(value);
+        for (var ok = 0; ok < objKeys.length; ok++) result[objKeys[ok]] = trimValue(value[objKeys[ok]], null, opts, depth + 1);
+      }
+      return result;
+    }
+    return value;
+  }
+  globalThis.__mcp_compact = function compact(data, options) {
+    options = options || {};
+    var selector = (options.fields && options.fields.length > 0) ? buildSelectorTree(options.fields) : null;
+    return trimValue(data, selector, options, 0);
+  };
+})();
+`;
+    const summarizeSrc = `
+(function injectSummarize() {
+  var CPT = 4;
+  function clip(text, max) { return text.length <= max ? text : text.slice(0, Math.max(0, max - 1)) + '…'; }
+  globalThis.__mcp_summarize = function summarize(data, options) {
+    var maxChars = options.maxTokens * CPT;
+    var style = options.style || 'list';
+    if (style === 'json') { try { return clip(JSON.stringify(data, null, 2), maxChars); } catch(e) { return clip(String(data), maxChars); } }
+    if (style === 'paragraph') {
+      var text;
+      if (typeof data === 'string') { text = data; }
+      else if (Array.isArray(data)) {
+        var prev = data.slice(0,3).map(function(x){return typeof x==='object'?JSON.stringify(x).slice(0,60):String(x).slice(0,60);}).join(', ');
+        text = data.length + ' item' + (data.length!==1?'s':'') + ': ' + prev + (data.length>3?'...':'');
+      } else if (typeof data === 'object' && data !== null) {
+        var kk = Object.keys(data);
+        text = 'Object with ' + kk.length + ' field' + (kk.length!==1?'s':'') + ': ' + kk.slice(0,5).map(function(k){return k+': '+JSON.stringify(data[k]).slice(0,30);}).join('; ');
+      } else { text = String(data); }
+      return clip(text, maxChars);
+    }
+    var lines = [];
+    if (Array.isArray(data)) {
+      for (var i = 0; i < data.length; i++) {
+        var item = data[i];
+        if (typeof item === 'object' && item !== null) {
+          lines.push('• ' + Object.entries(item).slice(0,4).map(function(e){return e[0]+'='+JSON.stringify(e[1]);}).join(', '));
+        } else { lines.push('• ' + String(item)); }
+      }
+    } else if (typeof data === 'object' && data !== null) {
+      Object.entries(data).forEach(function(e){lines.push(e[0]+': '+(typeof e[1]==='object'?JSON.stringify(e[1]):String(e[1])));});
+    } else { lines.push(String(data)); }
+    var result = '';
+    for (var li = 0; li < lines.length; li++) {
+      var candidate = result ? result + '\n' + lines[li] : lines[li];
+      if (candidate.length > maxChars) { var rem = maxChars - result.length - 1; if (rem > 4) result += (result?'\n':'')+clip(lines[li],rem); break; }
+      result = candidate;
+    }
+    return result || clip(String(data), maxChars);
+  };
+})();
+`;
+    const deltaSrc = `
+(function injectDelta() {
+  var __snapshots = new Map();
+  globalThis.__mcp_delta = async function delta(server, tool, args, current) {
+    var key = server + '::' + tool + '::' + JSON.stringify(args);
+    var previous = __snapshots.get(key);
+    __snapshots.set(key, current);
+    if (previous === undefined) return { changed: true, delta: current };
+    if (Array.isArray(current) && Array.isArray(previous)) {
+      var changed = JSON.stringify(previous) !== JSON.stringify(current);
+      return { changed: changed, delta: changed ? current : [], added: Math.max(0,current.length-previous.length), removed: Math.max(0,previous.length-current.length) };
+    }
+    if (typeof current === 'object' && current !== null && !Array.isArray(current)) {
+      var d = {}; var ck = [];
+      var allKeys = new Set(Object.keys(previous||{}).concat(Object.keys(current)));
+      allKeys.forEach(function(k){ if(JSON.stringify((previous||{})[k])!==JSON.stringify(current[k])){ d[k]=current[k]; ck.push(k); } });
+      return { changed: ck.length > 0, delta: ck.length > 0 ? d : {}, changedKeys: ck };
+    }
+    var prim_changed = JSON.stringify(previous) !== JSON.stringify(current);
+    return { changed: prim_changed, delta: prim_changed ? current : undefined };
+  };
+})();
+`;
+    const budgetSrc = `
+(function injectBudget() {
+  var CPT = 4;
+  function est(data) { try { return Math.ceil((JSON.stringify(data)||String(data)).length/CPT); } catch(e) { return Math.ceil(String(data).length/CPT); } }
+  function BudgetExceededError(estimated, max) {
+    this.name = 'BudgetExceededError';
+    this.message = 'Result exceeds token budget: '+estimated+' > '+max;
+    this.estimatedTokens = estimated;
+    this.maxTokens = max;
+  }
+  BudgetExceededError.prototype = Object.create(Error.prototype);
+  function tryTrim(data, maxTokens) {
+    if (Array.isArray(data)) {
+      var mxList = [100, 50, 20, 10, 5, 1];
+      for (var mi = 0; mi < mxList.length; mi++) {
+        var t = globalThis.__mcp_compact(data, {maxItems: mxList[mi], maxStringLength: 200});
+        if (est(t) <= maxTokens) return t;
+      }
+    }
+    if (typeof data === 'object' && data !== null) {
+      var mdList = [5, 3, 2, 1];
+      for (var md = 0; md < mdList.length; md++) {
+        var td = globalThis.__mcp_compact(data, {maxDepth: mdList[md], maxItems: 20, maxStringLength: 200});
+        if (est(td) <= maxTokens) return td;
+      }
+    }
+    var ls = globalThis.__mcp_summarize(data, {maxTokens: maxTokens, style: 'list'});
+    if (est(ls) <= maxTokens) return ls;
+    var ps = globalThis.__mcp_summarize(data, {maxTokens: maxTokens, style: 'paragraph'});
+    if (est(ps) <= maxTokens) return ps;
+    var raw = typeof data === 'string' ? data : JSON.stringify(data) || String(data);
+    var cl = raw.slice(0, maxTokens * CPT - 1) + '…';
+    if (est(cl) <= maxTokens) return cl;
+    throw new BudgetExceededError(est(data), maxTokens);
+  }
+  globalThis.__mcp_budget = async function budget(maxTokens, fn) {
+    var result = await fn();
+    return est(result) <= maxTokens ? result : tryTrim(result, maxTokens);
+  };
+  globalThis.BudgetExceededError = BudgetExceededError;
+})();
+`;
+    const findToolSrc = `
+(function injectFindTool() {
+  var EMBED_DIM = 256;
+  function tokenise(text) { return text.toLowerCase().replace(/[^a-z0-9_.-]/g,' ').split(/\\s+/).filter(Boolean); }
+  function hashBucket(s) { var h=5381; for(var i=0;i<s.length;i++){h=((h<<5)+h)^s.charCodeAt(i);h=h>>>0;} return h%EMBED_DIM; }
+  function embed(text) {
+    var vec = new Float32Array(EMBED_DIM);
+    var tokens = tokenise(text);
+    if (!tokens.length) return vec;
+    for (var i=0;i<tokens.length;i++) vec[hashBucket(tokens[i])]+=1;
+    for (var j=0;j<tokens.length-1;j++) vec[hashBucket(tokens[j]+'_'+tokens[j+1])]+=0.5;
+    var norm=0; for(var k=0;k<EMBED_DIM;k++) norm+=vec[k]*vec[k]; norm=Math.sqrt(norm);
+    if(norm>0) for(var n=0;n<EMBED_DIM;n++) vec[n]/=norm;
+    return vec;
+  }
+  function cosine(a,b) { var d=0; for(var i=0;i<a.length;i++) d+=a[i]*b[i]; return d; }
+  var __toolEntries = ${toolsJson}.map(function(e){return{server:e.server,tool:e.tool,description:e.description,vector:embed(e.tool+'\\n'+e.description)};});
+  globalThis.__mcp_findTool = async function findTool(query, options) {
+    options = options || {};
+    var qv = embed(query);
+    var topK = options.topK || 5;
+    var filter = options.serverFilter;
+    var candidates = filter ? __toolEntries.filter(function(e){return filter.includes(e.server);}) : __toolEntries;
+    var scored = candidates.map(function(e){return{server:e.server,tool:e.tool,description:e.description,score:cosine(qv,e.vector)};});
+    scored.sort(function(a,b){return b.score-a.score;});
+    return scored.slice(0,topK);
+  };
+})();
+`;
+    const extendMcpSrc = `
+if (typeof mcp !== 'undefined') {
+  Object.defineProperty(mcp, 'compact',   { value: globalThis.__mcp_compact,   writable: false, configurable: true });
+  Object.defineProperty(mcp, 'summarize', { value: globalThis.__mcp_summarize, writable: false, configurable: true });
+  Object.defineProperty(mcp, 'delta',     { value: globalThis.__mcp_delta,     writable: false, configurable: true });
+  Object.defineProperty(mcp, 'budget',    { value: globalThis.__mcp_budget,    writable: false, configurable: true });
+  Object.defineProperty(mcp, 'findTool',  { value: globalThis.__mcp_findTool,  writable: false, configurable: true });
+}
+`;
+    return [
+        '// Phase 5 Sandbox Helpers — auto-injected into Deno worker via preloadHelpers[]',
+        compactSrc,
+        summarizeSrc,
+        deltaSrc,
+        budgetSrc,
+        findToolSrc,
+        extendMcpSrc,
+    ].join('\n');
+}
+//# sourceMappingURL=worker-preload.js.map

package/dist/runtime/helpers/worker-preload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-preload.js","sourceRoot":"","sources":["../../../src/runtime/helpers/worker-preload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,UAA0B,EAAE;IACnE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IAEtD,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDpB,CAAC;IAEA,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCtB,CAAC;IAEA,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;CAsBlB,CAAC;IAEA,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCnB,CAAC;IAEA,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;wBAgBE,SAAS;;;;;;;;;;;;CAYhC,CAAC;IAEA,MAAM,YAAY,GAAG;;;;;;;;CAQtB,CAAC;IAEA,OAAO;QACL,kFAAkF;QAClF,UAAU;QACV,YAAY;QACZ,QAAQ;QACR,SAAS;QACT,WAAW;QACX,YAAY;KACb,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/runtime/index.d.ts

@@ -4,4 +4,5 @@
  * @module runtime
  */
 export * from './executor.js';
+export * from './pool/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/runtime/index.js

@@ -4,4 +4,5 @@
  * @module runtime
  */
 export * from './executor.js';
+export * from './pool/index.js';
 //# sourceMappingURL=index.js.map

package/dist/runtime/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/runtime/pool/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Runtime pool — warm Deno worker pool for low-latency code execution.
+ * @module runtime/pool
+ */
+export { WorkerPool } from './worker-pool.js';
+export type { WorkerPoolOptions, PoolExecuteOptions } from './worker-pool.js';
+export { PooledWorker } from './worker.js';
+export type { WorkerOptions, WorkerJob, WorkerResult, WorkerState } from './worker.js';
+export { evaluateRecycle, isEligible } from './recycle.js';
+export type { RecycleCandidate, RecycleDecision } from './recycle.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/pool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/pool/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE9E,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEvF,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/runtime/pool/index.js

@@ -0,0 +1,8 @@
+/**
+ * Runtime pool — warm Deno worker pool for low-latency code execution.
+ * @module runtime/pool
+ */
+export { WorkerPool } from './worker-pool.js';
+export { PooledWorker } from './worker.js';
+export { evaluateRecycle, isEligible } from './recycle.js';
+//# sourceMappingURL=index.js.map

package/dist/runtime/pool/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/pool/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/runtime/pool/recycle.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Worker Recycle Policy
+ *
+ * Determines when a warm Deno worker should be replaced. Three eviction
+ * triggers are evaluated in order:
+ *   1. Error state — worker crashed or entered an unrecoverable error
+ *   2. Age — worker has been alive longer than `maxAgeMs`
+ *   3. Job count — worker has processed more than `maxJobsPerWorker` jobs
+ *
+ * Recycle is designed to be async-safe: the pool spawns a replacement
+ * *before* terminating the old worker, ensuring capacity is never reduced
+ * during normal operation.
+ *
+ * @module runtime/pool/recycle
+ */
+import type { WorkerPoolOptions } from './worker-pool.js';
+export interface RecycleCandidate {
+    /** Worker unique identifier */
+    id: string;
+    /** Current state of the worker */
+    state: 'idle' | 'busy' | 'recycling' | 'dead';
+    /** Epoch ms when the worker was created */
+    createdAt: number;
+    /** Total jobs run since creation */
+    jobsRun: number;
+}
+export interface RecycleDecision {
+    shouldRecycle: boolean;
+    reason?: 'error' | 'age' | 'job-count';
+}
+/**
+ * Evaluate whether a worker should be recycled based on the pool policy.
+ *
+ * Called by the pool after every job completion and after any error event.
+ * When `shouldRecycle` is true, the pool spawns a replacement then calls
+ * `worker.shutdown(drainFirst=false)` on the old worker.
+ */
+export declare function evaluateRecycle(candidate: RecycleCandidate, opts: Pick<WorkerPoolOptions, 'maxJobsPerWorker' | 'maxAgeMs'>): RecycleDecision;
+/**
+ * Return true if a worker is eligible to receive new jobs
+ * (idle and not scheduled for recycle).
+ */
+export declare function isEligible(candidate: RecycleCandidate, opts: Pick<WorkerPoolOptions, 'maxJobsPerWorker' | 'maxAgeMs'>): boolean;
+//# sourceMappingURL=recycle.d.ts.map

package/dist/runtime/pool/recycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recycle.d.ts","sourceRoot":"","sources":["../../../src/runtime/pool/recycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,kCAAkC;IAClC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC9C,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,WAAW,CAAC;CACxC;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,gBAAgB,EAC3B,IAAI,EAAE,IAAI,CAAC,iBAAiB,EAAE,kBAAkB,GAAG,UAAU,CAAC,GAC7D,eAAe,CAoBjB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,gBAAgB,EAC3B,IAAI,EAAE,IAAI,CAAC,iBAAiB,EAAE,kBAAkB,GAAG,UAAU,CAAC,GAC7D,OAAO,CAIT"}

package/dist/runtime/pool/recycle.js

@@ -0,0 +1,50 @@
+/**
+ * Worker Recycle Policy
+ *
+ * Determines when a warm Deno worker should be replaced. Three eviction
+ * triggers are evaluated in order:
+ *   1. Error state — worker crashed or entered an unrecoverable error
+ *   2. Age — worker has been alive longer than `maxAgeMs`
+ *   3. Job count — worker has processed more than `maxJobsPerWorker` jobs
+ *
+ * Recycle is designed to be async-safe: the pool spawns a replacement
+ * *before* terminating the old worker, ensuring capacity is never reduced
+ * during normal operation.
+ *
+ * @module runtime/pool/recycle
+ */
+/**
+ * Evaluate whether a worker should be recycled based on the pool policy.
+ *
+ * Called by the pool after every job completion and after any error event.
+ * When `shouldRecycle` is true, the pool spawns a replacement then calls
+ * `worker.shutdown(drainFirst=false)` on the old worker.
+ */
+export function evaluateRecycle(candidate, opts) {
+    // Error state always recycles
+    if (candidate.state === 'dead' || candidate.state === 'recycling') {
+        return { shouldRecycle: true, reason: 'error' };
+    }
+    const now = Date.now();
+    const ageMs = now - candidate.createdAt;
+    const maxAge = opts.maxAgeMs ?? 600_000;
+    const maxJobs = opts.maxJobsPerWorker ?? 100;
+    if (ageMs >= maxAge) {
+        return { shouldRecycle: true, reason: 'age' };
+    }
+    if (candidate.jobsRun >= maxJobs) {
+        return { shouldRecycle: true, reason: 'job-count' };
+    }
+    return { shouldRecycle: false };
+}
+/**
+ * Return true if a worker is eligible to receive new jobs
+ * (idle and not scheduled for recycle).
+ */
+export function isEligible(candidate, opts) {
+    if (candidate.state !== 'idle')
+        return false;
+    const { shouldRecycle } = evaluateRecycle(candidate, opts);
+    return !shouldRecycle;
+}
+//# sourceMappingURL=recycle.js.map

package/dist/runtime/pool/recycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recycle.js","sourceRoot":"","sources":["../../../src/runtime/pool/recycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAoBH;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,SAA2B,EAC3B,IAA8D;IAE9D,8BAA8B;IAC9B,IAAI,SAAS,CAAC,KAAK,KAAK,MAAM,IAAI,SAAS,CAAC,KAAK,KAAK,WAAW,EAAE,CAAC;QAClE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAClD,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,MAAM,KAAK,GAAG,GAAG,GAAG,SAAS,CAAC,SAAS,CAAC;IACxC,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC;IACxC,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,IAAI,GAAG,CAAC;IAE7C,IAAI,KAAK,IAAI,MAAM,EAAE,CAAC;QACpB,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAChD,CAAC;IAED,IAAI,SAAS,CAAC,OAAO,IAAI,OAAO,EAAE,CAAC;QACjC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;IACtD,CAAC;IAED,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;AAClC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CACxB,SAA2B,EAC3B,IAA8D;IAE9D,IAAI,SAAS,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC;IAC7C,MAAM,EAAE,aAAa,EAAE,GAAG,eAAe,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC3D,OAAO,CAAC,aAAa,CAAC;AACxB,CAAC"}

package/dist/runtime/pool/worker-pool.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Warm Deno Worker Pool
+ *
+ * Maintains a fixed pool of pre-warmed Deno workers so that the first
+ * execute_code call after startup hits an already-running sandbox.
+ *
+ * Lifecycle:
+ *   1. `new WorkerPool(opts)` — configure
+ *   2. `await pool.warmUp()` — spawn `size` workers concurrently
+ *   3. `await pool.execute(job)` — pick idle worker, run, release
+ *   4. `await pool.shutdown()` — drain in-flight jobs, terminate all workers
+ *
+ * Recycle policy (see recycle.ts):
+ *   - After `maxJobsPerWorker` jobs the worker is replaced before termination
+ *   - After `maxAgeMs` age the worker is replaced after its current job finishes
+ *   - After any uncaught error the worker is replaced immediately
+ *
+ * Phase 5 plug-in: pass `preloadHelpers` to `WorkerPoolOptions` and the
+ * bootstrap script inside `worker.ts` will `await import()` each path before
+ * entering the job loop.
+ *
+ * @module runtime/pool/worker-pool
+ */
+import type { WorkerJob } from './worker.js';
+export interface WorkerPoolOptions {
+    /** Number of warm workers to maintain (default: 4) */
+    size?: number;
+    /** Recycle a worker after this many jobs (default: 100) */
+    maxJobsPerWorker?: number;
+    /** Recycle a worker after this age in ms (default: 600000 = 10 min) */
+    maxAgeMs?: number;
+    /** Directory of generated .d.ts files from the registry (Agent A output) */
+    preloadTypesDir: string;
+    /**
+     * Additional helper scripts to preload in each worker.
+     * Phase 5 (Agent E) passes compact/summarize/delta helpers here.
+     * Default: [] (no additional preloads).
+     */
+    preloadHelpers?: string[];
+    /** Max Deno memory per worker in MB (default: 128) */
+    maxMemoryMb?: number;
+    /** Bridge URL injected into the sandbox (default: http://127.0.0.1:9847) */
+    bridgeUrl?: string;
+}
+export interface PoolExecuteOptions {
+    signal?: AbortSignal;
+    /** Timeout in ms for waiting to acquire an idle worker (default: 5000) */
+    acquireTimeoutMs?: number;
+}
+export declare class WorkerPool {
+    private readonly opts;
+    private workers;
+    private queue;
+    private isShuttingDown;
+    private isWarmedUp;
+    constructor(options: WorkerPoolOptions);
+    /** Pre-spawn all workers. Must be called before `execute()`. */
+    warmUp(): Promise<void>;
+    /**
+     * Execute a job on an idle worker.
+     *
+     * If no idle worker is available, the job is queued until one becomes
+     * free or the acquire timeout elapses.
+     */
+    execute<T = unknown>(job: Omit<WorkerJob, 'signal'>, execOpts?: PoolExecuteOptions): Promise<T>;
+    size(): number;
+    busyCount(): number;
+    idleCount(): number;
+    /** Gracefully drain all in-flight jobs then terminate all workers. */
+    shutdown(): Promise<void>;
+    private _findIdle;
+    private _runOnWorker;
+    private _maybeRecycle;
+    private _removeWorker;
+    private _drainQueue;
+}
+//# sourceMappingURL=worker-pool.d.ts.map

package/dist/runtime/pool/worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-pool.d.ts","sourceRoot":"","sources":["../../../src/runtime/pool/worker-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,OAAO,KAAK,EAAE,SAAS,EAA+B,MAAM,aAAa,CAAC;AAM1E,MAAM,WAAW,iBAAiB;IAChC,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAkBD,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA8B;IACnD,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,EAAE,iBAAiB;IAYtC,gEAAgE;IAC1D,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB7B;;;;;OAKG;IACG,OAAO,CAAC,CAAC,GAAG,OAAO,EACvB,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,EAC9B,QAAQ,GAAE,kBAAuB,GAChC,OAAO,CAAC,CAAC,CAAC;IAkCb,IAAI,IAAI,MAAM;IAId,SAAS,IAAI,MAAM;IAInB,SAAS,IAAI,MAAM;IAInB,sEAAsE;IAChE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB/B,OAAO,CAAC,SAAS;YAIH,YAAY;YAuBZ,aAAa;IAkD3B,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,WAAW;CAapB"}