geometryview 0.0.0-stage → 0.1.0

package/src/tools.mjs

@@ -0,0 +1,265 @@
+// The tools an AI app can call: open a model, read its parts, picture it, and show it to the user.
+
+import { basename } from "node:path";
+import { importModel, nativeAvailable, openInViewer, readStats, readTree, render,
+         viewerApplication } from "./native.mjs";
+import { linkToPage, openInPage, pageRender, pageTree, showInPage, viewerServer } from "./page.mjs";
+
+export const instructions =
+  "GeometryView views 3D CAD models (STEP .step/.stp and STL .stl files) on this computer. Use it " +
+  "whenever the user wants to see, inspect or picture a CAD model, part or assembly, rather " +
+  "than opening a web viewer. Call open_model with the file's absolute path first. " +
+  "get_structure lists the assemblies and parts; render_view returns a picture you can look " +
+  "at, in any view and drawing style (illustration, metal, clay, blueprint, technical, " +
+  "studio). To study a part, pass names from get_structure as isolate, and use section to cut " +
+  "through the model. open_in_viewer shows the model to the user, live: in the GeometryView app, " +
+  "in their browser, or, when they want to see it inside this chat app, as a link to open in " +
+  "the app's own browser (where: link). Where this computer has no native engine, the viewer " +
+  "opens in the user's browser and the pictures come from it, so the user sees what you look at.";
+
+const STYLES = ["illustration", "metal", "clay", "blueprint", "technical", "studio"];
+const COLOURS = ["material", "parts", "mono", "file"];
+// Where the camera looks from, as azimuth and elevation in degrees, with Z up.
+const VIEWS = {
+  iso: [35, 25], front: [0, 0], back: [180, 0], left: [-90, 0], right: [90, 0],
+  top: [0, 89.9], bottom: [0, -89.9],
+};
+
+const path = { type: "string", description: "Absolute path to a .step, .stp or .stl file." };
+
+// ---- The tree as an outline ---------------------------------------------------------------------
+
+function annotate(nodes) {
+  const children = nodes.map(() => []);
+  const parts = nodes.map((node) => (node.kind === "part" ? 1 : 0));
+  nodes.forEach((node, index) => node.parent >= 0 && children[node.parent].push(index));
+  for (let index = nodes.length - 1; index >= 0; --index) {
+    if (nodes[index].parent >= 0) {
+      parts[nodes[index].parent] += parts[index];
+    }
+  }
+  return { children, parts };
+}
+
+function describe(node, index, parts) {
+  const name = node.name || `(unnamed ${node.kind})`;
+  const bodies = node.bodies[1] - node.bodies[0];
+  if (node.kind === "assembly") {
+    return `${name} — assembly, ${parts[index]} part${parts[index] === 1 ? "" : "s"}`;
+  }
+  return bodies > 1 ? `${name} — part, ${bodies} bodies` : `${name} — part`;
+}
+
+/// An indented outline of the tree. Bodies are counted on their parts rather than listed. With a
+/// filter, only nodes whose names contain it, and their ancestors, are shown.
+function outline(nodes, { maxDepth = Infinity, maxLines = 400, filter = "" } = {}) {
+  const { children, parts } = annotate(nodes);
+  const wanted = new Uint8Array(nodes.length);
+  const needle = filter.toLowerCase();
+  for (let index = 0; index < nodes.length; ++index) {
+    if (!needle || nodes[index].name.toLowerCase().includes(needle)) {
+      for (let at = index; at >= 0 && !wanted[at]; at = nodes[at].parent) {
+        wanted[at] = 1;
+      }
+    }
+  }
+  const lines = [];
+  let omitted = 0;
+  const walk = (index, depth) => {
+    if (!wanted[index] || nodes[index].kind === "body") {
+      return;
+    }
+    if (lines.length >= maxLines || depth > maxDepth) {
+      omitted += 1;
+      return;
+    }
+    lines.push(`${"  ".repeat(depth)}${describe(nodes[index], index, parts)}`);
+    children[index].forEach((child) => walk(child, depth + 1));
+  };
+  nodes.forEach((node, index) => node.parent < 0 && walk(index, 0));
+  if (omitted > 0) {
+    lines.push(`… ${omitted} more not shown; narrow with filter or raise max_lines.`);
+  }
+  return lines.join("\n");
+}
+
+function counts(nodes) {
+  const kinds = { assembly: 0, part: 0, body: 0 };
+  nodes.forEach((node) => (kinds[node.kind] += 1));
+  const bodies = Math.max(0, ...nodes.filter((n) => n.parent < 0).map((n) => n.bodies[1]));
+  return { assemblies: kinds.assembly, parts: kinds.part, bodies };
+}
+
+const round = (value) => +value.toPrecision(4);
+
+// ---- Tools -------------------------------------------------------------------------------------
+
+export const tools = [
+  {
+    name: "open_model",
+    description: "Opens a 3D CAD model, a STEP (.step, .stp) or STL (.stl) file on this " +
+                 "computer, and summarises it: size, counts and top-level assemblies and parts. " +
+                 "Call this before the other GeometryView tools.",
+    inputSchema: { type: "object", properties: { path }, required: ["path"] },
+    async call({ path: file }) {
+      const started = performance.now();
+      let nodes, stats, how;
+      if (nativeAvailable()) {
+        const { blob, fromCache } = await importModel(file);
+        [nodes, stats] = await Promise.all([readTree(blob), readStats(blob)]);
+        how = fromCache ? "from cache" : "imported";
+      } else {
+        stats = await openInPage(file);
+        nodes = await pageTree(file);
+        how = "in the browser's viewer";
+      }
+      const { assemblies, parts, bodies } = counts(nodes);
+      const size = stats.max.map((high, axis) => round(high - stats.min[axis]));
+      const seconds = ((performance.now() - started) / 1000).toFixed(2);
+      return [{
+        type: "text",
+        text: [
+          `Opened ${basename(file)} (${how}, ${seconds} s).`,
+          `${assemblies} assemblies, ${parts} parts, ${bodies} bodies; ` +
+            `${stats.faces} faces, ${stats.triangles} triangles.`,
+          `Bounding box ${size.join(" × ")} (model units), from [${stats.min.map(round)}] to ` +
+            `[${stats.max.map(round)}].`,
+          "",
+          outline(nodes, { maxDepth: 2, maxLines: 60 }),
+        ].join("\n"),
+      }];
+    },
+  },
+  {
+    name: "get_structure",
+    description: "Lists a CAD model's assemblies and parts as an indented outline, with " +
+                 "counts, to find the names of parts to show alone.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path,
+        filter: { type: "string", description: "Only parts whose names contain this." },
+        max_lines: { type: "integer", minimum: 1, maximum: 5000, default: 400 },
+      },
+      required: ["path"],
+    },
+    async call({ path: file, filter = "", max_lines: maxLines = 400 }) {
+      const nodes = nativeAvailable() ? await readTree((await importModel(file)).blob)
+                                      : await pageTree(file);
+      const text = outline(nodes, { filter, maxLines });
+      return [{ type: "text", text: text || `No part's name contains "${filter}".` }];
+    },
+  },
+  {
+    name: "render_view",
+    description: "Renders a picture of a 3D CAD model (STEP or STL) for you to look at: a " +
+                 "standard view or any angle, a drawing style (illustration, metal, clay, " +
+                 "blueprint, technical, or studio: polished metal on a dark backdrop), named parts " +
+                 "shown alone, and section cuts through it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path,
+        view: { type: "string", enum: Object.keys(VIEWS), default: "iso" },
+        azimuth: { type: "number", description: "Degrees around Z, overriding view." },
+        elevation: { type: "number", description: "Degrees above the XY plane, overriding view." },
+        style: { type: "string", enum: STYLES, default: "illustration" },
+        colour: { type: "string", enum: COLOURS, default: "parts" },
+        isolate: { type: "array", items: { type: "string" },
+                   description: "Show only parts whose names contain one of these." },
+        section: {
+          type: "array",
+          description: "Planes cutting through the model.",
+          items: {
+            type: "object",
+            properties: {
+              axis: { type: "string", enum: ["x", "y", "z"] },
+              at: { type: "number", minimum: 0, maximum: 1,
+                    description: "Where along the axis, from 0 to 1 across the model." },
+              flip: { type: "boolean", description: "Keep the other side.", default: false },
+            },
+            required: ["axis", "at"],
+          },
+        },
+        width: { type: "integer", minimum: 64, maximum: 4096, default: 1200 },
+        height: { type: "integer", minimum: 64, maximum: 4096, default: 800 },
+        perspective: { type: "boolean", default: false },
+      },
+      required: ["path"],
+    },
+    async call(args) {
+      const source = args.path;
+      const [azimuth, elevation] = VIEWS[args.view ?? "iso"] ?? VIEWS.iso;
+      const view = {
+        width: args.width ?? 1200,
+        height: args.height ?? 800,
+        azimuth: args.azimuth ?? azimuth,
+        elevation: args.elevation ?? elevation,
+        perspective: args.perspective ?? false,
+        style: Math.max(0, STYLES.indexOf(args.style ?? "illustration")),
+        colour: Math.max(0, COLOURS.indexOf(args.colour ?? "parts")),
+        section: (args.section ?? [])
+          .map(({ axis, at, flip }) => `${axis}${flip ? "-" : ""}${at}`)
+          .join(","),
+        isolate: args.isolate ?? [],
+        overlay: true,
+      };
+      const png = nativeAvailable()
+        ? await render((await importModel(args.path)).blob, view)
+        : await pageRender(args.path, { ...view, section: args.section ?? [] });
+      const shown = view.isolate.length ? ` showing only ${view.isolate.join(", ")}` : "";
+      return [
+        { type: "image", data: png.toString("base64"), mimeType: "image/png" },
+        { type: "text", text: `${basename(source)}${shown}, ${args.style ?? "illustration"} ` +
+                              `style, from azimuth ${view.azimuth}°, elevation ${view.elevation}°.` },
+      ];
+    },
+  },
+  {
+    name: "open_in_viewer",
+    description: "Shows a STEP or STL model to the user, live, where they can turn it, select " +
+                 "parts and cut sections: in the GeometryView app on a Mac that has it (where: " +
+                 "app), in their web browser (where: browser), or as a link for this chat app to " +
+                 "open in its own browser (where: link; open the returned address there, and the " +
+                 "model appears once the page loads). It can show only some parts, in a chosen " +
+                 "style and colours.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path,
+        where: { type: "string", enum: ["app", "browser", "link"],
+                 description: "Where to show it. By default the app where it is installed, else " +
+                              "the browser." },
+        isolate: { type: "array", items: { type: "string" },
+                   description: "Show only parts whose names contain one of these." },
+        style: { type: "string", enum: STYLES },
+        colour: { type: "string", enum: COLOURS },
+      },
+      required: ["path"],
+    },
+    async call({ path: file, where, isolate = [], style, colour }) {
+      const application = process.platform === "darwin" ? viewerApplication() : null;
+      where ??= application ? "app" : "browser";
+      const name = basename(file);
+      const shown = (isolate.length ? `, showing only ${isolate.join(", ")}` : "") +
+                    (style ? `, in ${style} style` : "") + (colour ? `, coloured by ${colour}` : "");
+      if (where === "app") {
+        if (!application) throw new Error("The GeometryView app is not installed here: use where browser or link.");
+        await openInViewer(file, { isolate, style, colour });
+        return [{ type: "text", text: `Opened ${name} in GeometryView${shown}.` }];
+      }
+      const show = { isolate };
+      if (style) show.style = STYLES.indexOf(style);
+      if (colour) show.colour = COLOURS.indexOf(colour);
+      if (where === "link") {
+        const { url, shown: now } = await linkToPage(file, show);
+        return [{ type: "text", text: now
+          ? `Showing ${name}${shown} in the viewer page already open at ${url}.`
+          : `Open ${url} in this app's browser to see ${name}${shown}; it appears once the page loads.` }];
+      }
+      await showInPage(file, show);
+      const { address } = await viewerServer();
+      return [{ type: "text", text: `Opened ${name}${shown} in the viewer in the browser (${address}).` }];
+    },
+  },
+];

package/src/web.mjs

@@ -0,0 +1,173 @@
+// The viewer, served to this machine only: the page and its engine with cross-origin isolation, the
+// model files the AI app asked to show, and the bridge to the page.
+//
+// Every request must name this server by its loopback address, which shuts out DNS rebinding;
+// model files and the bridge need the token this run made, and the bridge the page's own origin,
+// so another site in the same browser can neither read a file nor drive the viewer.
+
+import { randomBytes } from "node:crypto";
+import { createReadStream, existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { basename, dirname, extname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Bridge } from "./bridge.mjs";
+import { acceptWebSocket } from "./websocket.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+const kTypes = {
+  ".html": "text/html; charset=utf-8", ".js": "text/javascript", ".mjs": "text/javascript",
+  ".css": "text/css", ".wasm": "application/wasm", ".json": "application/json",
+  ".ttf": "font/ttf", ".svg": "image/svg+xml", ".png": "image/png", ".ico": "image/x-icon",
+  ".webmanifest": "application/manifest+json",
+};
+
+/// The port the viewer prefers: always the same, so the page's origin, and with it the library
+/// and look the browser keeps for it, are the same from one run to the next.
+export const kDefaultPort = 47700;
+
+/// What the identity route answers, so a second launcher can tell this one holds the port.
+const kIdentity = JSON.stringify({ name: "geometryview" });
+
+/// Whether a GeometryView viewer already answers on `port`.
+export async function viewerAt(port) {
+  try {
+    const answer = await fetch(`http://127.0.0.1:${port}/geometryview.json`,
+                               { signal: AbortSignal.timeout(1000) });
+    return answer.ok && (await answer.json()).name === "geometryview";
+  } catch {
+    return false;
+  }
+}
+
+/// Where the viewer's files are, as URL prefixes and folders: GEOMETRYVIEW_WEB_DIR; else, in the
+/// repository, its sources and builds, so an edit shows at once; else the copy packed beside this
+/// package.
+export function viewerMounts() {
+  const root = join(here, "../..");
+  const packed = [process.env.GEOMETRYVIEW_WEB_DIR,
+                  existsSync(join(root, "Web/viewer/index.html")) ? null : join(here, "../web")];
+  for (const directory of packed.filter(Boolean)) {
+    if (existsSync(join(directory, "index.html"))) return [["/", directory]];
+  }
+  return [
+    ["/build/", join(root, "build/wasm-webgpu/Engine")],
+    ["/fonts/", join(root, "ThirdParty/ibm-plex-mono")],
+    ["/occt/", join(root, "build/wasm-release/Import")],
+    ["/occt-threads/", join(root, "build/wasm-threads/Import")],
+    ["/", join(root, "Web/viewer")],
+  ];
+}
+
+/// Starts the server on 127.0.0.1. Returns { url, port, token, bridge, grant(path), close() }.
+export async function startViewer({ port = 0 } = {}) {
+  const token = randomBytes(16).toString("hex");
+  const mounts = viewerMounts();
+  const grants = new Map(); // id to an absolute path the AI app asked to show
+  const bridge = new Bridge();
+  const headers = {
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Cross-Origin-Embedder-Policy": "require-corp",
+    "Cross-Origin-Resource-Policy": "same-origin",
+    "X-Content-Type-Options": "nosniff",
+    "Cache-Control": "no-cache",
+  };
+  let address = "";
+  // Bodies go chunked, with their size apart. Safari, like any WebKit, holds back a body whose
+  // length it knows and hands it to the page some 80 ms at a time, so a cache file meant to stream
+  // into GPU buffers arrived in pieces of up to its whole size, late. A HEAD answer has no body to
+  // hold back.
+  const sized = (request, size) =>
+    request.method === "HEAD" ? { "Content-Length": size } : { "GeometryView-Size": size };
+  const ours = (request) => {
+    const host = request.headers.host ?? "";
+    return host === `127.0.0.1:${server.address().port}` || host === `localhost:${server.address().port}`;
+  };
+
+  const server = createServer(async (request, response) => {
+    if (!ours(request)) {
+      response.writeHead(421).end();
+      return;
+    }
+    const url = new URL(request.url, address);
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      response.writeHead(405, headers).end();
+      return;
+    }
+    if (url.pathname === "/geometryview.json") {
+      response.writeHead(200, { ...headers, "Content-Type": "application/json" }).end(kIdentity);
+      return;
+    }
+    // A model file the AI app asked to show.
+    if (url.pathname.startsWith("/file/")) {
+      const path = grants.get(url.pathname.slice("/file/".length));
+      if (url.searchParams.get("token") !== token || !path) {
+        response.writeHead(403, headers).end();
+        return;
+      }
+      try {
+        const info = await stat(path);
+        response.writeHead(200, { ...headers, ...sized(request, info.size),
+                                  "Content-Type": "application/octet-stream",
+                                  "Last-Modified": info.mtime.toUTCString() });
+        if (request.method === "HEAD") response.end();
+        else createReadStream(path).pipe(response);
+      } catch {
+        response.writeHead(404, headers).end();
+      }
+      return;
+    }
+    const path = url.pathname === "/" ? "/index.html" : url.pathname;
+    const [prefix, directory] = mounts.find(([p]) => path.startsWith(p));
+    const file = resolve(directory, decodeURIComponent(path.slice(prefix.length)));
+    if (!file.startsWith(resolve(directory) + sep)) {
+      response.writeHead(400, headers).end();
+      return;
+    }
+    try {
+      const info = await stat(file);
+      if (!info.isFile()) throw new Error("not a file");
+      response.writeHead(200, { ...headers, ...sized(request, info.size),
+                                "Content-Type": kTypes[extname(file)] ?? "application/octet-stream" });
+      if (request.method === "HEAD") response.end();
+      else createReadStream(file).pipe(response);
+    } catch {
+      response.writeHead(404, headers).end();
+    }
+  });
+
+  server.on("upgrade", (request, socket) => {
+    const url = new URL(request.url, address || "http://127.0.0.1");
+    if (!ours(request) || url.pathname !== "/bridge" || url.searchParams.get("token") !== token ||
+        request.headers.origin !== address) {
+      socket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
+      return;
+    }
+    const connection = acceptWebSocket(request, socket);
+    if (connection) bridge.attach(connection);
+  });
+
+  await new Promise((done, fail) => {
+    server.once("error", fail);
+    server.listen(port, "127.0.0.1", done);
+  });
+  address = `http://127.0.0.1:${server.address().port}`;
+  return {
+    url: `${address}/?token=${token}`,
+    address,
+    port: server.address().port,
+    token,
+    bridge,
+    /// Lets the page fetch `path`, and returns where: a URL on this server.
+    grant(path) {
+      const id = `${randomBytes(8).toString("hex")}/${encodeURIComponent(basename(path))}`;
+      grants.set(id, resolve(path));
+      return `/file/${id}?token=${token}`;
+    },
+    close() {
+      bridge.close();
+      return new Promise((done) => server.close(done));
+    },
+  };
+}

package/src/websocket.mjs

@@ -0,0 +1,104 @@
+// The server side of WebSocket (RFC 6455), for the bridge between the launcher and the viewer's
+// page: the handshake, text frames in both directions, ping and close. No dependencies; frames from
+// the page are masked, as the protocol requires, and frames to it are not.
+
+import { createHash } from "node:crypto";
+
+const kGuid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+const kMaxMessage = 64 << 20; // a rendered picture, base64, with room to spare
+
+/// Completes an upgrade request and returns the connection: { send(text), close(), onmessage,
+/// onclose }. Answers 400 and returns null if the request is not a WebSocket handshake.
+export function acceptWebSocket(request, socket) {
+  const key = request.headers["sec-websocket-key"];
+  if (request.headers.upgrade?.toLowerCase() !== "websocket" || !key) {
+    socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    return null;
+  }
+  const accept = createHash("sha1").update(key + kGuid).digest("base64");
+  socket.write("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" +
+               `Sec-WebSocket-Accept: ${accept}\r\n\r\n`);
+  socket.setNoDelay(true);
+
+  const connection = { onmessage: null, onclose: null, open: true };
+  let buffered = Buffer.alloc(0);
+  let fragments = [];
+
+  const frame = (opcode, payload) => {
+    const length = payload.length;
+    const header = length < 126 ? Buffer.from([0x80 | opcode, length])
+                 : length < 65536 ? Buffer.from([0x80 | opcode, 126, length >> 8, length & 255])
+                 : (() => {
+                     const h = Buffer.alloc(10);
+                     h[0] = 0x80 | opcode;
+                     h[1] = 127;
+                     h.writeBigUInt64BE(BigInt(length), 2);
+                     return h;
+                   })();
+    socket.write(Buffer.concat([header, payload]));
+  };
+
+  const finish = () => {
+    if (!connection.open) return;
+    connection.open = false;
+    connection.onclose?.();
+  };
+
+  connection.send = (text) => {
+    if (connection.open) frame(0x1, Buffer.from(text, "utf8"));
+  };
+  connection.close = () => {
+    if (connection.open) frame(0x8, Buffer.alloc(0));
+    socket.end();
+    finish();
+  };
+
+  socket.on("data", (chunk) => {
+    buffered = Buffer.concat([buffered, chunk]);
+    for (;;) {
+      if (buffered.length < 2) return;
+      const fin = (buffered[0] & 0x80) !== 0;
+      const opcode = buffered[0] & 0x0f;
+      const masked = (buffered[1] & 0x80) !== 0;
+      let length = buffered[1] & 0x7f;
+      let at = 2;
+      if (length === 126) {
+        if (buffered.length < 4) return;
+        length = buffered.readUInt16BE(2);
+        at = 4;
+      } else if (length === 127) {
+        if (buffered.length < 10) return;
+        length = Number(buffered.readBigUInt64BE(2));
+        at = 10;
+      }
+      if (!masked || length > kMaxMessage) {
+        connection.close(); // a client must mask; and nothing this large is expected
+        return;
+      }
+      if (buffered.length < at + 4 + length) return;
+      const mask = buffered.subarray(at, at + 4);
+      const payload = Buffer.from(buffered.subarray(at + 4, at + 4 + length));
+      for (let i = 0; i < payload.length; ++i) payload[i] ^= mask[i & 3];
+      buffered = buffered.subarray(at + 4 + length);
+      if (opcode === 0x8) {
+        connection.close();
+        return;
+      }
+      if (opcode === 0x9) {
+        frame(0xA, payload);
+        continue;
+      }
+      if (opcode === 0x1 || opcode === 0x0) {
+        fragments.push(payload);
+        if (fin) {
+          const text = Buffer.concat(fragments).toString("utf8");
+          fragments = [];
+          connection.onmessage?.(text);
+        }
+      }
+    }
+  });
+  socket.on("close", finish);
+  socket.on("error", finish);
+  return connection;
+}

package/web/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atharva Aalok
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/web/NOTICES.md

@@ -0,0 +1,49 @@
+# Third-party notices
+
+GeometryView is MIT licensed (see [LICENSE](LICENSE)). It builds on the work below, each under its
+own license. Versions are pinned in [ThirdParty/manifest.toml](ThirdParty/manifest.toml).
+
+## Shipped in the app, the browser viewer and the launcher
+
+| Project | License | How it is used |
+|---|---|---|
+| [Open CASCADE Technology](https://github.com/Open-Cascade-SAS/OCCT) (OCCT) 8.0.1 | LGPL-2.1 with the OCCT exception 1.0 | Reads and meshes STEP files: in the Mac app's import helper and in the browser viewer's importers. It is not changed. `ThirdParty/build_occt.sh` and `ThirdParty/build_occt_wasm.sh` rebuild it from its source, so you can relink GeometryView with your own build of it. |
+| [meshoptimizer](https://github.com/zeux/meshoptimizer) 1.3 | MIT | Meshlets and their bounds. Vendored, with its [license](ThirdParty/meshoptimizer/LICENSE.md). |
+| [xxHash](https://github.com/Cyan4973/xxHash) 0.8.3 | BSD-2-Clause | Content hashes, to tell files and repeated shapes apart. Vendored, with its [license](ThirdParty/xxhash/LICENSE). |
+| [IBM Plex Mono](https://github.com/IBM/plex) 2.5.0 | SIL Open Font License 1.1 | The interface's typeface. Vendored, with its [license](ThirdParty/ibm-plex-mono/LICENSE.txt). |
+| [Dawn](https://dawn.googlesource.com/dawn)'s emdawnwebgpu | BSD-3-Clause | The WebGPU bindings compiled into the browser viewer's engine. |
+| [Emscripten](https://emscripten.org) runtime and libraries | MIT / University of Illinois NCSA; libc++ under Apache-2.0 with LLVM exceptions; musl under MIT | Compiled into the browser viewer's WebAssembly. |
+
+The figure palette and the see-through look follow [Colorfigures](https://april-zhu.com/colorfigures)
+by April Zhu, under the MIT license:
+
+```
+Copyright (c) 2026 April Zhu (Colorfigures: colour, hand-drawn style, 3D props, template, examples)
+Copyright (c) 2026 April Zhu (iso-glow, on which Colorfigures is based)
+Copyright (c) 2026 Tolga Cohce (iso-figure, on which iso-glow is based)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Used to build and test only
+
+| Project | License |
+|---|---|
+| [doctest](https://github.com/doctest/doctest) 2.4.12 | MIT; vendored with its [license](ThirdParty/doctest/LICENSE.txt) |
+| [Dawn](https://dawn.googlesource.com/dawn) (native) | BSD-3-Clause; the WebGPU test harness on the Mac |

package/web/bridge.js

@@ -0,0 +1,29 @@
+// The page's side of the launcher's bridge: when the launcher opened this page, it passes a token,
+// and the page takes requests from the AI app's tools over a WebSocket to the launcher, and
+// answers them. See Launcher/src/bridge.mjs.
+
+export function connectBridge(token, handlers) {
+  const connect = () => {
+    const socket = new WebSocket(`${location.protocol === "https:" ? "wss" : "ws"}://${location.host}` +
+                                 `/bridge?token=${encodeURIComponent(token)}`);
+    socket.onmessage = async (event) => {
+      let message;
+      try {
+        message = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+      const { id, method, params } = message;
+      try {
+        const handler = handlers[method];
+        if (!handler) throw new Error(`The viewer does not know ${method}.`);
+        socket.send(JSON.stringify({ id, result: await handler(params ?? {}) }));
+      } catch (error) {
+        socket.send(JSON.stringify({ id, error: String(error?.message ?? error) }));
+      }
+    };
+    // The launcher may restart: keep trying, quietly.
+    socket.onclose = () => setTimeout(connect, 2000);
+  };
+  connect();
+}