Browser and worker deployment

import { createEvaluator, design, mm, vec3 } from "invariantcad";

const cad = design("browser-part");
const body = cad.box("body", {
  size: vec3(mm(20), mm(10), mm(4)),
});
cad.output("body", body);

const evaluator = await createEvaluator();
const result = await evaluator.evaluate(cad.build());

const evaluator = await createEvaluator({
  manifold: {
    wasmUrl: new URL("/wasm/manifold.wasm", window.location.origin).href,
  },
});

import { createOcctKernel } from "invariantcad/kernels/occt";

const kernel = await createOcctKernel({
  wasm: new URL("/wasm/occt-wasm.wasm", window.location.origin),
});

import { createOcctKernel } from "invariantcad/kernels/occt";
import {
  INVARIANTCAD_OCCT_FACADE_0_9_0_RELEASE_MANIFEST_SHA256,
  loadAttestedOcctRuntime,
} from "invariantcad/kernels/occt/browser";

const attestedRuntime = await loadAttestedOcctRuntime({
  releaseManifest,
  expectedReleaseManifestSha256:
    INVARIANTCAD_OCCT_FACADE_0_9_0_RELEASE_MANIFEST_SHA256,
  javascript,
  webassembly,
});
const kernel = await createOcctKernel({ attestedRuntime });

// geometry.worker.ts
import { createEvaluator, parseDocumentValue } from "invariantcad";

const evaluatorPromise = createEvaluator();

self.onmessage = async (event) => {
  const parsed = parseDocumentValue(event.data.document);
  if (!parsed.ok) {
    self.postMessage({ ok: false, diagnostics: parsed.diagnostics });
    return;
  }

  const evaluator = await evaluatorPromise;
  const result = await evaluator.evaluate(parsed.value, event.data.options);
  if (!result.ok) {
    self.postMessage({ ok: false, diagnostics: result.diagnostics });
    return;
  }

  try {
    const stl = result.value.output(event.data.output).export("stl");
    self.postMessage({ ok: true, stl }, { transfer: [stl.buffer] });
  } finally {
    result.value.dispose();
  }
};

let controller: AbortController | undefined;

self.onmessage = async (event) => {
  if (event.data.type === "cancel") {
    controller?.abort();
    return;
  }
  const parsed = parseDocumentValue(event.data.document);
  if (!parsed.ok) {
    self.postMessage({ ok: false, diagnostics: parsed.diagnostics });
    return;
  }
  controller = new AbortController();
  const evaluator = await evaluatorPromise;
  const result = await evaluator.evaluate(parsed.value, {
    ...event.data.options,
    signal: controller.signal,
  });
  // An aborted run resolves with EVALUATION_ABORTED and has already released
  // every shape it created; handle a successful result as shown above.
};

Content-Security-Policy: script-src 'self' blob: 'wasm-unsafe-eval' 'unsafe-eval'