@obenor/mcp 0.2.0 → 0.4.0

package/bundle/runner.js

@@ -0,0 +1,181 @@
+// ../script/src/runner.ts
+import { parentPort } from "node:worker_threads";
+
+// ../script/src/protocol.ts
+var SCRIPT_CALLS = [
+  "add",
+  "update",
+  "remove",
+  "suppress",
+  "parameter",
+  "parameters",
+  "features",
+  "feature",
+  "bodies",
+  "measure",
+  "build",
+  "id",
+  "material",
+  "raycast",
+  "topology"
+];
+var SCRIPT_LIMITS = {
+  /** Wall clock. Long enough to build a real model, short enough to notice. */
+  deadlineMs: 3e4,
+  /** Document calls. A script that needs more than this is a program. */
+  maxCalls: 5e3,
+  /** Characters of source. */
+  maxSource: 2e5,
+  /** Characters of printed output kept. The rest is counted and dropped. */
+  maxPrint: 2e4,
+  /**
+   * Rays in one `raycast`. The one limit a batch verb needs of its own.
+   *
+   * `maxCalls` counts CALLS, and it is the only thing standing between a script
+   * and unbounded kernel work - which a verb that takes an array quietly walks
+   * around, because a million rays in one call is one call. So the array is
+   * capped too, at the same order as the whole call budget: a script may ask
+   * for as much geometry in one batch as it was ever allowed to ask for in
+   * total, and no more.
+   *
+   * RAYS AND NOT KERNEL CALLS, which is the honest reading of it. The work a
+   * batch does is rays x distinct PLACEMENTS - an assembly of forty occurrences
+   * turns five thousand rays into two hundred thousand traversals - so this
+   * bounds the argument rather than the cost. That is deliberate and not an
+   * oversight: the cost is already bounded by the DEADLINE, which is the limit
+   * that actually protects a caller from a slow answer, and a cap that varied
+   * with the model would refuse a sampling pass on a big assembly that a small
+   * one allows, which is the kind of limit nobody can plan around.
+   */
+  maxRays: 5e3,
+  /**
+   * Faces or edges one `topology` call may answer with, per kind.
+   *
+   * A ceiling on the ANSWER and not a refusal of the question: a body with
+   * three thousand faces is a real body, and a script that asks about it should
+   * get the first `limit` of them and be told how many it did not get, rather
+   * than an error it can do nothing about. The default `limit` is far below
+   * this, because the common case is a panel with six faces and the uncommon
+   * one is an import - and a script that means it says so.
+   */
+  maxTopologyRows: 2e4
+};
+
+// ../script/src/runtime.ts
+var PREAMBLE_LINES = 3;
+var WRAPPER = "obenorScript";
+function lineOf(error) {
+  const stack = error instanceof Error ? error.stack : null;
+  if (typeof stack !== "string") return null;
+  for (const frame of stack.split("\n")) {
+    if (!frame.includes(WRAPPER)) continue;
+    const at = /:(\d+):\d+\)?\s*$/u.exec(frame.trim());
+    if (at === null) continue;
+    const line = Number(at[1]) - PREAMBLE_LINES;
+    return line > 0 ? line : null;
+  }
+  return null;
+}
+function format(value) {
+  if (value === void 0) return "undefined";
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(value, (_key, held) => {
+      if (typeof held !== "object" || held === null) return held;
+      if (seen.has(held)) return "[circular]";
+      seen.add(held);
+      return held;
+    }) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function transportable(value) {
+  try {
+    structuredClone(value);
+    return value;
+  } catch {
+    return format(value);
+  }
+}
+function compile(source) {
+  const AsyncFunction = Object.getPrototypeOf(async () => {
+  }).constructor;
+  return new AsyncFunction(
+    "api",
+    "print",
+    `return (async function ${WRAPPER}() {
+${source}
+})();`
+  );
+}
+function startRunner(port2) {
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let calls = 0;
+  let maxCalls = SCRIPT_LIMITS.maxCalls;
+  const ask = (call, args) => {
+    calls += 1;
+    if (calls > maxCalls) {
+      return Promise.reject(new Error(
+        `this script has made ${calls} document calls, which is past the limit of ${maxCalls}. Something is looping.`
+      ));
+    }
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      port2.post({ kind: "call", id, call, args });
+    });
+  };
+  const api = {};
+  for (const call of SCRIPT_CALLS) {
+    api[call] = (...args) => ask(call, args);
+  }
+  const print = (...parts) => {
+    port2.post({
+      kind: "print",
+      text: parts.map((part) => typeof part === "string" ? part : format(part)).join(" ")
+    });
+  };
+  const run = async (source) => {
+    let done;
+    try {
+      const value = await compile(source)(api, print);
+      done = { kind: "done", ok: true, value: transportable(value), line: null };
+    } catch (error) {
+      done = {
+        kind: "done",
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+        line: lineOf(error)
+      };
+    }
+    port2.post(done);
+  };
+  port2.listen((message) => {
+    if (message.kind === "start") {
+      maxCalls = message.maxCalls;
+      void run(message.source);
+      return;
+    }
+    const held = pending.get(message.id);
+    if (held === void 0) return;
+    pending.delete(message.id);
+    if (message.ok) held.resolve(message.value);
+    else held.reject(new Error(message.error ?? "the document refused, without saying why"));
+  });
+}
+
+// ../script/src/runner.ts
+var port = parentPort;
+if (port === null) throw new Error("the script runner must be started as a worker");
+startRunner({
+  post: (message) => {
+    port.postMessage(message);
+  },
+  listen: (handler) => {
+    port.on("message", (message) => {
+      handler(message);
+    });
+  }
+});