@bushscad/cli 0.0.0-stage → 0.3.0

package/dist/occt-cancellation-probe.js

@@ -0,0 +1,107 @@
+// scripts/parallel-compilation/occt-cancellation-probe.ts
+import { fork } from "node:child_process";
+import { resolve } from "node:path";
+
+// scripts/parallel-compilation/report-output.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function writeJsonReport(outPath, report, stdoutReport = report) {
+  await mkdir(dirname(outPath), { recursive: true });
+  await writeFile(outPath, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  process.stdout.write(`${JSON.stringify(stdoutReport, null, 2)}
+`);
+}
+
+// scripts/parallel-compilation/occt-cancellation-probe.ts
+async function run() {
+  const workerPath = resolve(
+    readArg("--worker", "packages/cli/dist/occt-probe-worker.js")
+  );
+  const outPath = resolve(
+    readArg(
+      "--out",
+      ".bushscad-analysis/parallel-compilation/p0-process-cancellation.json"
+    )
+  );
+  const startedAt = performance.now();
+  const cancelled = launch(workerPath, 1);
+  await new Promise((resolvePromise) => setTimeout(resolvePromise, 1e3));
+  const cancelStartedAt = performance.now();
+  cancelled.kill();
+  const cancelledExit = await waitForExit(cancelled);
+  const cancelLatencyMs = performance.now() - cancelStartedAt;
+  const replacement = launch(workerPath, 2);
+  const ready = await waitUntilReady(replacement);
+  const shutdownResult = await requestShutdown(replacement);
+  const replacementExit = await waitForExit(replacement);
+  const report = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cancelledExit,
+    cancelLatencyMs,
+    replacementReadyMs: ready.initializationMs,
+    replacementRssBytes: ready.rssBytes,
+    shutdownElapsedMs: shutdownResult.elapsedMs,
+    replacementExit,
+    totalWallMs: performance.now() - startedAt,
+    coordinatorSurvived: true
+  };
+  await writeJsonReport(outPath, report);
+}
+function launch(workerPath, workerId) {
+  return fork(workerPath, [], {
+    env: { ...process.env, BUSHSCAD_PROBE_WORKER_ID: String(workerId) },
+    serialization: "advanced",
+    stdio: ["ignore", "inherit", "inherit", "ipc"]
+  });
+}
+function waitUntilReady(child) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const timer = setTimeout(
+      () => rejectPromise(new Error("Replacement worker readiness timed out.")),
+      12e4
+    );
+    child.on("message", (raw) => {
+      const message = raw;
+      if (message.kind === "ready") {
+        clearTimeout(timer);
+        resolvePromise(message);
+      } else if (message.kind === "error") {
+        clearTimeout(timer);
+        rejectPromise(new Error(message.message));
+      }
+    });
+  });
+}
+function requestShutdown(child) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const requestId = 1;
+    child.on("message", (raw) => {
+      const message = raw;
+      if (message.kind === "result" && message.requestId === requestId)
+        resolvePromise(message);
+      else if (message.kind === "error")
+        rejectPromise(new Error(message.message));
+    });
+    const command = { kind: "shutdown", requestId };
+    child.send(command);
+  });
+}
+function waitForExit(child) {
+  if (child.exitCode !== null)
+    return Promise.resolve({ code: child.exitCode, signal: child.signalCode });
+  return new Promise(
+    (resolvePromise) => child.once("exit", (code, signal) => resolvePromise({ code, signal }))
+  );
+}
+function readArg(name, fallback) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] ?? fallback : fallback;
+}
+void run().catch((error) => {
+  process.stderr.write(
+    `${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+  );
+  process.exitCode = 1;
+});

package/dist/occt-probe-runner.js

@@ -0,0 +1,232 @@
+// scripts/parallel-compilation/occt-probe-runner.ts
+import { fork } from "node:child_process";
+import { resolve } from "node:path";
+import { Worker } from "node:worker_threads";
+
+// scripts/parallel-compilation/report-output.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function writeJsonReport(outPath, report, stdoutReport = report) {
+  await mkdir(dirname(outPath), { recursive: true });
+  await writeFile(outPath, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  process.stdout.write(`${JSON.stringify(stdoutReport, null, 2)}
+`);
+}
+
+// scripts/parallel-compilation/occt-probe-runner.ts
+async function run() {
+  const args = parseArgs(process.argv.slice(2));
+  const launchedAt = performance.now();
+  const workers = Array.from(
+    { length: args.workerCount },
+    (_, index) => createWorker(args.mode, index + 1, args.workerPath)
+  );
+  const ready = await Promise.all(workers.map(waitUntilReady));
+  const wallInitializationMs = performance.now() - launchedAt;
+  const clients = workers.map(createClient);
+  try {
+    const firstBuilds = await Promise.all(
+      clients.map((client) => client.request("build-cuboid"))
+    );
+    const warmBuilds = await Promise.all(
+      clients.map((client) => client.request("build-cuboid"))
+    );
+    const beforeIdle = await Promise.all(
+      clients.map((client) => client.request("memory"))
+    );
+    await new Promise(
+      (resolvePromise) => setTimeout(resolvePromise, args.idleMs)
+    );
+    const afterIdle = await Promise.all(
+      clients.map((client) => client.request("memory"))
+    );
+    const exporter = clients[0];
+    const importer = clients[1] ?? clients[0];
+    if (!exporter || !importer)
+      throw new Error("At least one worker is required.");
+    const exportResult = await exporter.request("export-cuboid");
+    if (!exportResult.dataBase64)
+      throw new Error("Transfer export returned no STEP payload.");
+    const importResult = await importer.request(
+      "import-step",
+      exportResult.dataBase64
+    );
+    const brepExportResult = await exporter.request("export-brep");
+    if (!brepExportResult.dataBase64)
+      throw new Error("Native transfer export returned no BRep payload.");
+    const brepImportResult = await importer.request(
+      "import-brep",
+      brepExportResult.dataBase64
+    );
+    const report = {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: args.mode,
+      workerCount: args.workerCount,
+      idleMs: args.idleMs,
+      wallInitializationMs,
+      ready,
+      firstBuilds,
+      warmBuilds,
+      beforeIdle,
+      afterIdle,
+      transfer: {
+        exportResult,
+        importResult,
+        stepBytes: Buffer.byteLength(exportResult.dataBase64, "base64")
+      },
+      nativeBrepTransfer: {
+        exportResult: brepExportResult,
+        importResult: brepImportResult,
+        brepBytes: Buffer.byteLength(brepExportResult.dataBase64, "base64")
+      }
+    };
+    await writeJsonReport(args.outPath, report, reportSummary(report));
+  } finally {
+    await Promise.all(clients.map((client) => client.shutdown()));
+  }
+}
+function createClient(handle) {
+  let nextRequestId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  handle.onMessage((message) => {
+    if (message.kind === "ready") return;
+    if (message.kind === "error") {
+      if (message.requestId !== void 0) {
+        const request3 = pending.get(message.requestId);
+        pending.delete(message.requestId);
+        request3?.reject(new Error(message.message));
+      }
+      return;
+    }
+    const request2 = pending.get(message.requestId);
+    pending.delete(message.requestId);
+    request2?.resolve(message);
+  });
+  const request = (kind, dataBase64) => {
+    const requestId = nextRequestId++;
+    const command = kind === "import-step" || kind === "import-brep" ? { kind, requestId, dataBase64: dataBase64 ?? "" } : { kind, requestId };
+    return new Promise((resolvePromise, rejectPromise) => {
+      pending.set(requestId, {
+        resolve: resolvePromise,
+        reject: rejectPromise
+      });
+      handle.send(command);
+    });
+  };
+  return {
+    request,
+    shutdown: async () => {
+      const requestId = nextRequestId++;
+      await new Promise((resolvePromise, rejectPromise) => {
+        pending.set(requestId, {
+          resolve: () => resolvePromise(),
+          reject: rejectPromise
+        });
+        handle.send({ kind: "shutdown", requestId });
+      });
+      await handle.terminate();
+    }
+  };
+}
+function reportSummary(report) {
+  return {
+    ...report,
+    transfer: {
+      ...report.transfer,
+      exportResult: {
+        ...report.transfer.exportResult,
+        dataBase64: report.transfer.exportResult.dataBase64 ? `(omitted ${report.transfer.stepBytes} bytes)` : void 0
+      }
+    },
+    nativeBrepTransfer: {
+      ...report.nativeBrepTransfer,
+      exportResult: {
+        ...report.nativeBrepTransfer.exportResult,
+        dataBase64: report.nativeBrepTransfer.exportResult.dataBase64 ? `(omitted ${report.nativeBrepTransfer.brepBytes} bytes)` : void 0
+      }
+    }
+  };
+}
+function waitUntilReady(handle) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const timer = setTimeout(
+      () => rejectPromise(new Error("OCCT probe worker readiness timed out.")),
+      12e4
+    );
+    handle.onMessage((message) => {
+      if (message.kind === "error" && message.requestId === void 0) {
+        clearTimeout(timer);
+        rejectPromise(new Error(message.message));
+      } else if (message.kind === "ready") {
+        clearTimeout(timer);
+        resolvePromise(message);
+      }
+    });
+  });
+}
+function createWorker(mode, workerId, workerPath) {
+  if (mode === "thread")
+    return threadHandle(new Worker(workerPath, { workerData: { workerId } }));
+  return processHandle(
+    fork(workerPath, [], {
+      env: { ...process.env, BUSHSCAD_PROBE_WORKER_ID: String(workerId) },
+      serialization: "advanced",
+      stdio: ["ignore", "inherit", "inherit", "ipc"]
+    })
+  );
+}
+function threadHandle(worker) {
+  return {
+    send: (command) => worker.postMessage(command),
+    onMessage: (listener) => worker.on("message", listener),
+    terminate: async () => void await worker.terminate()
+  };
+}
+function processHandle(child) {
+  return {
+    send: (command) => child.send?.(command),
+    onMessage: (listener) => child.on("message", (message) => listener(message)),
+    terminate: async () => {
+      if (child.exitCode !== null) return;
+      await new Promise((resolvePromise) => {
+        child.once("exit", () => resolvePromise());
+        setTimeout(() => {
+          if (child.exitCode === null) child.kill();
+        }, 2e3);
+      });
+    }
+  };
+}
+function parseArgs(args) {
+  const read = (name, fallback) => {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] ?? fallback : fallback;
+  };
+  const mode = read("--mode", "process");
+  if (mode !== "thread" && mode !== "process")
+    throw new Error(`Unsupported mode '${mode}'.`);
+  const workerCount = Math.max(1, Number(read("--workers", "1")));
+  const idleMs = Math.max(0, Number(read("--idle-ms", "10000")));
+  return {
+    mode,
+    workerCount,
+    idleMs,
+    outPath: resolve(
+      read(
+        "--out",
+        `.bushscad-analysis/parallel-compilation/p0-${mode}-${workerCount}.json`
+      )
+    ),
+    workerPath: resolve(
+      read("--worker", "packages/cli/dist/occt-probe-worker.js")
+    )
+  };
+}
+void run().catch((error) => {
+  process.stderr.write(
+    `${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+  );
+  process.exitCode = 1;
+});