@faicad/faijs-viewer 0.29.3

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/faijs-viewer/README.md
+README.md: 3ccc96a92a8c48c3d9fabc6e709166dcada26b73
+README.zh.md: d35e4fd11c3776230282e2e3900e1a56ba923b18

package/README.md

@@ -0,0 +1,102 @@
+# @faicad/faijs-viewer
+
+English | [中文](README.zh.md)
+
+The reference way for **any third-party host** to open and render a project `.fai.zip` 3D document. The viewer reads the container, executes the active (or requested) model through `@faicad/faijs`, and returns host-agnostic tessellated mesh data — no THREE, no DOM, and no GL library required on the return value.
+
+This package does **not** depend on `sheetmetal` or `cq-compat`. Its preset libraries — `@faicad/faijs`, `@faicad/faijs-sketch` and `@faicad/faijs-extra` — are family peers the host provides, and third-party faijs libraries (e.g. `@faicad/faijs-gears`) are loaded on demand at execution time (see [Dynamic library loading](#dynamic-library-loading)). It is the reference SDK for "a third party needs only one **viewer** package to view a `.fai.zip`".
+
+## v1 API
+
+```ts ignore-check
+import { openFaiZip } from '@faicad/faijs-viewer'
+
+const result = await openFaiZip(bytes, {
+  wasm: {
+    occtUrl: 'https://your-cdn/occt-wasm.wasm',          // BREP-chain engine
+    manifoldUrl: 'https://your-cdn/manifold.wasm',        // mesh / CSG engine
+    brepkitUrl: 'https://your-cdn/brepkit_wasm_bg.wasm',  // secondary BREP engine
+  },
+  // modelId?: string                      // pick a model; default is manifest.active, else models[0]
+  // mode?: 'auto' | 'brep' | 'mesh'       // default 'auto' (static BREP/mesh dispatch)
+  // sketch?: { planegcsUrl: '...' }       // browser-only: constraint-solver wasm URL (see below)
+  // libs?: { allow: ['@faicad/faijs-gears'], versions: { '@faicad/faijs-gears': '0.29.2' } }
+  //                                       // dynamic third-party libraries (see below)
+})
+
+// result.meshes — structured mesh data; the host does the actual rendering.
+for (const mesh of result.meshes) {
+  // mesh.name       display label
+  // mesh.positions  Float32Array, interleaved x/y/z triangle vertices
+  // mesh.indices    Uint32Array, groups of 3 triangle indices
+}
+```
+
+Three outcomes:
+
+| case | form |
+|---|---|
+| `wasm` missing or any of the three urls empty | **throws** (`E_WASM_URL`; a caller contract violation, never returned as `error`) |
+| invalid bytes / execution failure / no visible geometry | returns `result.error`, `code ∈ { E_CONTAINER, E_EXECUTION, E_NO_GEOMETRY }` |
+| success | returns structured `meshes` |
+
+Real FreeCAD-converted containers call `cad.sketch` and the editor-extension ops (`cad.fai_*`, `cad.group`, `cad.text`, …); the viewer merges the sketch + faijs-extra namespaces into the default `cad` binding and backs sketch with a constraint solver (see below). `@faicad/faijs-draw` is deprecated and deliberately not merged — a `cad.draw` call fails as an unknown callee.
+
+## `cad.sketch` and the constraint solver
+
+`cad.sketch` (from `@faicad/faijs-sketch`) requires a separate **planegcs** constraint-solver wasm. How it is sourced differs by runner:
+
+- **Node / worker** — the solver auto-loads from the installed `@salusoft89/planegcs` package; no `sketch` option is needed.
+- **Browser** — self-host `planegcs.wasm` and pass its URL: `openFaiZip(bytes, { wasm, sketch: { planegcsUrl: 'https://your-cdn/planegcs.wasm' } })`. Without a URL the solver is not installed; a `cad.sketch` op fails with `E_SKETCHC_NO_SOLVER`, reported through `result.error`.
+
+Note: the converted sketch input must follow the sketch op's contract (`shapes` or `geoms`). A converter that emits `cad.sketch({ contours: [...] })` is not currently accepted and fails with `E_SKETCHC_NO_GEOMS` — tracked in the faijs family, not this viewer package.
+
+## Dynamic library loading
+
+A `.fai.zip` model may `import` any third-party faijs library — the set cannot be known in advance. The engine already loads namespace imports lazily at execute time (`autoLoadLibsFromImports` → `HostPorts.libLoader`), and this viewer builds that loader for you:
+
+- **browser host** — dynamic `import()` from the jsDelivr CDN (version-pinned `+esm` direct links when `libs.versions` is provided);
+- **Node host** — `import(pkg)` from installed packages, defaulting to `@faicad/`-scoped libraries unless `libs.allow` is given.
+
+Configure it through `OpenFaiZipOptions.libs`:
+
+```ts ignore-check
+const result = await openFaiZip(bytes, {
+  wasm,
+  libs: {
+    allow: ['@faicad/faijs-gears'],                        // whitelist (a .fai.zip is untrusted input — production hosts should set this)
+    versions: { '@faicad/faijs-gears': '0.29.2' },          // pin to the host engine's version line
+    // aliases?: { gears: '@faicad/faijs-gears' },          // script specifier → npm package name
+    // cdnBase?: 'https://cdn.jsdelivr.net/npm/',            // browser CDN base
+    // enabled?: true,                                      // false disables dynamic loading entirely
+  },
+})
+```
+
+Preset libraries (core, sketch, faijs-extra — merged into `cad`) never pass through the loader. Loading or version-verification failures surface as structured `E_EXECUTION` on `result.error`, never a throw. A library whose `contractVersion` does not match the host engine is rejected loudly — keep `libs.versions` pinned to the same version line as `@faicad/faijs` the host runs.
+
+## All three wasm urls are required, and they must be self-hosted
+
+A `.fai.zip` has **no baked mesh** — models execute at runtime, which requires the engine wasm. v1 does not bundle them; the host provides and self-hosts:
+
+- **occt-wasm** — BREP-chain engine (default-required).
+- **manifold** — mesh/CSG engine (also used for the tessellation of BREP output).
+- **brepkit** — secondary BREP engine (v1 accepts + validates it; reserved).
+
+Self-host the three files (do not rely on an upstream CDN's uptime) and pass their urls to `openFaiZip`:
+
+1. Copy `dist/occt-wasm.wasm` from the `occt-wasm` npm package into your static directory.
+2. Copy `manifold.wasm` (package root) from `manifold-3d` into your static directory.
+3. Copy `lib/brepkit_wasm_bg.wasm` from `brepkit-wasm` into your static directory.
+
+For a concrete browser binding, see `packages/demo/main.ts#initOcct`, which registers `OcctKernel.init({ wasm: occtUrl })` on core's `setOcctWasmInitFn`; this viewer package installs the three urls into core's `setOcctWasmInitFn` / `setManifoldWasmUrl` hooks for you in a browser.
+
+## Node / tests
+
+In a Node/worker runner the three urls are still validated (v1 contract), but the engine falls back to core's locally-bundled occt/manifold auto-load — no network fetch. So a host without public internet can still fully run `openFaiZip` in a test process.
+
+## Dependencies
+
+- preset peers `@faicad/faijs`, `@faicad/faijs-sketch`, `@faicad/faijs-extra` — merged into the default `cad` binding (a host provides all three family packages).
+- peer `three` — carried by faijs-extra's B-group ops (`cad.text` / `cad.svgExtrude` mesh path); not touched by the return value.
+- peer `occt-wasm` — lazily imported only by the browser path (`bindBrowserWasm`); never loaded in Node tests.

package/README.zh.md

@@ -0,0 +1,102 @@
+# @faicad/faijs-viewer
+
+[English](README.md) | 中文
+
+任何第三方宿主打开并渲染 `.fai.zip` 三维文档的参考方式。viewer 读取容器，通过 `@faicad/faijs` 执行 active（或指定的）model，返回与宿主无关的三角化 mesh 数据——返回值不依赖 THREE、DOM 或任何 GL 库。
+
+本包**不**依赖 `sheetmetal` 或 `cq-compat`。预置库——`@faicad/faijs`、`@faicad/faijs-sketch` 和 `@faicad/faijs-extra`——是家族 peer 包，由宿主提供；第三方 faijs 库（如 `@faicad/faijs-gears`）在执行期按需装载（见 [动态库加载](#dynamic-library-loading)）。它就是"第三方只需要一个 **viewer** 包就能查看 `.fai.zip`"的参考 SDK。
+
+## v1 API
+
+```ts ignore-check
+import { openFaiZip } from '@faicad/faijs-viewer'
+
+const result = await openFaiZip(bytes, {
+  wasm: {
+    occtUrl: 'https://your-cdn/occt-wasm.wasm',          // BREP-chain engine
+    manifoldUrl: 'https://your-cdn/manifold.wasm',        // mesh / CSG engine
+    brepkitUrl: 'https://your-cdn/brepkit_wasm_bg.wasm',  // secondary BREP engine
+  },
+  // modelId?: string                      // pick a model; default is manifest.active, else models[0]
+  // mode?: 'auto' | 'brep' | 'mesh'       // default 'auto' (static BREP/mesh dispatch)
+  // sketch?: { planegcsUrl: '...' }       // browser-only: constraint-solver wasm URL (see below)
+  // libs?: { allow: ['@faicad/faijs-gears'], versions: { '@faicad/faijs-gears': '0.29.2' } }
+  //                                       // dynamic third-party libraries (see below)
+})
+
+// result.meshes — structured mesh data; the host does the actual rendering.
+for (const mesh of result.meshes) {
+  // mesh.name       display label
+  // mesh.positions  Float32Array, interleaved x/y/z triangle vertices
+  // mesh.indices    Uint32Array, groups of 3 triangle indices
+}
+```
+
+三种结果：
+
+| 情形 | 形式 |
+|---|---|
+| `wasm` 缺失或三个 url 任一为空 | **抛异常**（`E_WASM_URL`；调用方契约违规，绝不作为 `error` 返回） |
+| 字节无效 / 执行失败 / 无可见几何 | 返回 `result.error`，`code ∈ { E_CONTAINER, E_EXECUTION, E_NO_GEOMETRY }` |
+| 成功 | 返回结构化 `meshes` |
+
+真实 FreeCAD 转换产物会调用 `cad.sketch` 和编辑器扩展 op（`cad.fai_*`、`cad.group`、`cad.text`、…）；viewer 把 sketch + faijs-extra 命名空间合入默认 `cad` binding，并由约束求解器支撑 sketch（见下）。`@faicad/faijs-draw` 已弃用且刻意不合并——`cad.draw` 调用按未知 callee 失败。
+
+## `cad.sketch` 与约束求解器
+
+`cad.sketch`（来自 `@faicad/faijs-sketch`）需要单独的 **planegcs** 约束求解器 wasm。获取方式因运行环境而异：
+
+- **Node / worker** — 求解器自动从已安装的 `@salusoft89/planegcs` 包加载；不需要 `sketch` 选项。
+- **浏览器** — 自托管 `planegcs.wasm` 并传入 URL：`openFaiZip(bytes, { wasm, sketch: { planegcsUrl: 'https://your-cdn/planegcs.wasm' } })`。不给 URL 则不安装求解器；`cad.sketch` op 以 `E_SKETCHC_NO_SOLVER` 失败，经 `result.error` 上报。
+
+注意：转换产物的 sketch 输入必须符合 sketch op 的契约（`shapes` 或 `geoms`）。产出 `cad.sketch({ contours: [...] })` 的转换器当前不被接受，会以 `E_SKETCHC_NO_GEOMS` 失败——该问题在 faijs 家族跟踪，不属本 viewer 包。
+
+## <a id="dynamic-library-loading"></a>动态库加载
+
+`.fai.zip` 的 model 可能 `import` 任意第三方 faijs 库——这个集合无法预先知道。引擎本来就在执行期按需装载命名空间 import（`autoLoadLibsFromImports` → `HostPorts.libLoader`），本 viewer 替你构建这个 loader：
+
+- **浏览器宿主** — 从 jsDelivr CDN 动态 `import()`（给了 `libs.versions` 则走版本 pin 的 `+esm` 直链）；
+- **Node 宿主** — 从已安装包 `import(pkg)`，默认限 `@faicad/` scoped 库，除非给了 `libs.allow`。
+
+通过 `OpenFaiZipOptions.libs` 配置：
+
+```ts ignore-check
+const result = await openFaiZip(bytes, {
+  wasm,
+  libs: {
+    allow: ['@faicad/faijs-gears'],                        // whitelist (a .fai.zip is untrusted input — production hosts should set this)
+    versions: { '@faicad/faijs-gears': '0.29.2' },          // pin to the host engine's version line
+    // aliases?: { gears: '@faicad/faijs-gears' },          // script specifier → npm package name
+    // cdnBase?: 'https://cdn.jsdelivr.net/npm/',            // browser CDN base
+    // enabled?: true,                                      // false disables dynamic loading entirely
+  },
+})
+```
+
+预置库（core、sketch、faijs-extra——合入 `cad`）从不经过 loader。装载或版本校验失败统一结构化返回 `E_EXECUTION` 到 `result.error`，绝不抛穿。`contractVersion` 与宿主引擎不匹配的库会被显式拒绝——请把 `libs.versions` pin 到与宿主运行的 `@faicad/faijs` 相同版本线。
+
+## 三个 wasm url 全部必填，且必须自托管
+
+`.fai.zip` **不内嵌 mesh** —— model 在运行时执行，这需要引擎 wasm。v1 不打包它们；由宿主提供并自托管：
+
+- **occt-wasm** — BREP 链引擎（默认必选）。
+- **manifold** — mesh/CSG 引擎（也用于 BREP 输出的三角化）。
+- **brepkit** — 次级 BREP 引擎（v1 接受并校验；预留）。
+
+自托管这三个文件（不要依赖上游 CDN 的可用性），并把 url 传给 `openFaiZip`：
+
+1. 把 `occt-wasm` npm 包里的 `dist/occt-wasm.wasm` 拷进你的静态目录。
+2. 把 `manifold-3d` 包根的 `manifold.wasm` 拷进你的静态目录。
+3. 把 `brepkit-wasm` 的 `lib/brepkit_wasm_bg.wasm` 拷进你的静态目录。
+
+具体浏览器绑定的示例见 `packages/demo/main.ts#initOcct`——它把 `OcctKernel.init({ wasm: occtUrl })` 注册到 core 的 `setOcctWasmInitFn`；浏览器环境下本 viewer 包会替你把三个 url 装进 core 的 `setOcctWasmInitFn` / `setManifoldWasmUrl` 钩子。
+
+## Node / 测试
+
+在 Node/worker 环境里，三个 url 仍会被校验（v1 契约），但引擎回退到 core 本地打包的 occt/manifold 自动加载——不发起网络请求。所以无公网的宿主也能在测试进程中完整运行 `openFaiZip`。
+
+## 依赖
+
+- 预置 peer `@faicad/faijs`、`@faicad/faijs-sketch`、`@faicad/faijs-extra` —— 合入默认 `cad` binding（三个家族包都由宿主提供）。
+- peer `three` —— 由 faijs-extra 的 B 组 op（`cad.text` / `cad.svgExtrude` mesh 路径）携带；返回值不触碰它。
+- peer `occt-wasm` —— 仅浏览器路径（`bindBrowserWasm`）懒加载；Node 测试从不加载。

package/dist/engine.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Engine (kernel) wiring for the viewer.
+ *
+ * `@faicad/faijs` executes a `.fai.zip` model through environment-level kernel
+ * singletons: the OCCT kernel (BREP chain), the manifold mesh engine, and the
+ * secondary brepkit engine. Those singletons are configured through the
+ * `setOcctWasmInitFn` / `setManifoldWasmUrl` / `setBrepkitWasmInitFn` hooks
+ * exported by core. This module maps the three wasm URLs from the v1 contract
+ * onto those hooks.
+ *
+ * Environment handling:
+ * - In a real browser the three URLs are authoritative: each kernel loads its
+ *   wasm from the given URL.
+ * - In a Node.ts test / local runner the same three URLs are validated (v1
+ *   requires them) but the engine falls back to core's node_modules auto-load,
+ *   so tests run against real, local wasm without a network fetch.
+ *
+ * Dual-OCCT-copy note: `occt-wasm`'s opaque instance type is nominal per
+ * package install (a `#private` member), so a pristine cross-copy type cannot
+ * be expressed. The demo uses `OcctKernel.init({ wasm })` plus a cast to the
+ * faijs-expected return shape; the viewer mirrors that established pattern.
+ */
+/** A wasm URL triplet (same shape as the v1 contract). */
+export interface ViewerWasmUrls {
+    occtUrl: string;
+    manifoldUrl: string;
+    brepkitUrl: string;
+}
+/** A code-pinned capability error surfaced by the viewer. */
+export interface EngineError {
+    code: 'E_WASM_URL';
+    message: string;
+}
+/**
+ * Validate the three v1 wasm urls. Throws a code-bearing `E_WASM_URL` error
+ * when any is missing or empty, as required by the v1 contract.
+ * @param wasm - The three v1 wasm asset URLs ({ occtUrl, manifoldUrl, brepkitUrl }) to validate. type:ViewerWasmUrls required:true
+ */
+export declare function assertWasmUrls(wasm: Readonly<ViewerWasmUrls> | undefined): void;
+/**
+ * Install the engine kernels for an `openFaiZip` view. Safe to call
+ * repeatedly — core's kernel singletons are environment-wide and
+ * instance-neutral.
+ *
+ * In a browser the three URLs are registered; in a Node/worker runner the URLs
+ * are still validated and the Node engine auto-loads its own local wasm.
+ * @param wasm - The three v1 wasm asset URLs; validated here, registered in browsers. type:ViewerWasmUrls required:true
+ */
+export declare function installEngine(wasm: Readonly<ViewerWasmUrls>): Promise<void>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,YAAY,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;CAChB;AAQD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,SAAS,GAAG,IAAI,CAS/E;AAuBD;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAKjF"}

package/dist/engine.js

@@ -0,0 +1,78 @@
+/**
+ * Engine (kernel) wiring for the viewer.
+ *
+ * `@faicad/faijs` executes a `.fai.zip` model through environment-level kernel
+ * singletons: the OCCT kernel (BREP chain), the manifold mesh engine, and the
+ * secondary brepkit engine. Those singletons are configured through the
+ * `setOcctWasmInitFn` / `setManifoldWasmUrl` / `setBrepkitWasmInitFn` hooks
+ * exported by core. This module maps the three wasm URLs from the v1 contract
+ * onto those hooks.
+ *
+ * Environment handling:
+ * - In a real browser the three URLs are authoritative: each kernel loads its
+ *   wasm from the given URL.
+ * - In a Node.ts test / local runner the same three URLs are validated (v1
+ *   requires them) but the engine falls back to core's node_modules auto-load,
+ *   so tests run against real, local wasm without a network fetch.
+ *
+ * Dual-OCCT-copy note: `occt-wasm`'s opaque instance type is nominal per
+ * package install (a `#private` member), so a pristine cross-copy type cannot
+ * be expressed. The demo uses `OcctKernel.init({ wasm })` plus a cast to the
+ * faijs-expected return shape; the viewer mirrors that established pattern.
+ */
+import { setOcctWasmInitFn, setManifoldWasmUrl } from '@faicad/faijs/browser';
+function throwEngine(message) {
+    const err = new Error(message);
+    err.code = 'E_WASM_URL';
+    throw err;
+}
+/**
+ * Validate the three v1 wasm urls. Throws a code-bearing `E_WASM_URL` error
+ * when any is missing or empty, as required by the v1 contract.
+ * @param wasm - The three v1 wasm asset URLs ({ occtUrl, manifoldUrl, brepkitUrl }) to validate. type:ViewerWasmUrls required:true
+ */
+export function assertWasmUrls(wasm) {
+    if (!wasm) {
+        throwEngine('openFaiZip requires `wasm` — supply { occtUrl, manifoldUrl, brepkitUrl }.');
+    }
+    for (const key of ['occtUrl', 'manifoldUrl', 'brepkitUrl']) {
+        if (typeof wasm[key] !== 'string' || wasm[key].length === 0) {
+            throwEngine(`openFaiZip wasm.${key} must be a non-empty string.`);
+        }
+    }
+}
+function hasBrowserWindow() {
+    return typeof window !== 'undefined' && typeof window.addEventListener === 'function';
+}
+/**
+ * Bind the engine kernels for a real browser, installing the occt and manifold
+ * init hooks from the configured URLs. `occt-wasm` is loaded lazily so this
+ * path only exists in the browser (never forces the dependency at load time in
+ * Node tests). brepkit is a secondary engine whose mesh boolean is not yet
+ * wired (v1, plan §1.8), so its URL is accepted but not depended on at
+ * execution time.
+ */
+async function bindBrowserWasm(wasm) {
+    const { OcctKernel } = await import('occt-wasm');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setOcctWasmInitFn((() => OcctKernel.init({ wasm: wasm.occtUrl })));
+    setManifoldWasmUrl(wasm.manifoldUrl);
+    // brepkit: accepted, not consumed in v1.
+    void wasm.brepkitUrl;
+}
+/**
+ * Install the engine kernels for an `openFaiZip` view. Safe to call
+ * repeatedly — core's kernel singletons are environment-wide and
+ * instance-neutral.
+ *
+ * In a browser the three URLs are registered; in a Node/worker runner the URLs
+ * are still validated and the Node engine auto-loads its own local wasm.
+ * @param wasm - The three v1 wasm asset URLs; validated here, registered in browsers. type:ViewerWasmUrls required:true
+ */
+export async function installEngine(wasm) {
+    assertWasmUrls(wasm);
+    if (hasBrowserWindow()) {
+        await bindBrowserWasm(wasm);
+    }
+}
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAe7E,SAAS,WAAW,CAAC,OAAe;IAClC,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAC7B;IAAC,GAAgC,CAAC,IAAI,GAAG,YAAY,CAAA;IACtD,MAAM,GAAG,CAAA;AACX,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAA0C;IACvE,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,WAAW,CAAC,2EAA2E,CAAC,CAAA;IAC1F,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,aAAa,EAAE,YAAY,CAAU,EAAE,CAAC;QACpE,IAAI,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,QAAQ,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5D,WAAW,CAAC,mBAAmB,GAAG,8BAA8B,CAAC,CAAA;QACnE,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,gBAAgB;IACvB,OAAO,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,gBAAgB,KAAK,UAAU,CAAA;AACvF,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,eAAe,CAAC,IAA8B;IAC3D,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,CAAA;IAChD,8DAA8D;IAC9D,iBAAiB,CAAC,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAQ,CAAC,CAAA;IACzE,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;IACpC,yCAAyC;IACzC,KAAK,IAAI,CAAC,UAAU,CAAA;AACtB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAA8B;IAChE,cAAc,CAAC,IAAI,CAAC,CAAA;IACpB,IAAI,gBAAgB,EAAE,EAAE,CAAC;QACvB,MAAM,eAAe,CAAC,IAAI,CAAC,CAAA;IAC7B,CAAC;AACH,CAAC","sourcesContent":["/**\n * Engine (kernel) wiring for the viewer.\n *\n * `@faicad/faijs` executes a `.fai.zip` model through environment-level kernel\n * singletons: the OCCT kernel (BREP chain), the manifold mesh engine, and the\n * secondary brepkit engine. Those singletons are configured through the\n * `setOcctWasmInitFn` / `setManifoldWasmUrl` / `setBrepkitWasmInitFn` hooks\n * exported by core. This module maps the three wasm URLs from the v1 contract\n * onto those hooks.\n *\n * Environment handling:\n * - In a real browser the three URLs are authoritative: each kernel loads its\n *   wasm from the given URL.\n * - In a Node.ts test / local runner the same three URLs are validated (v1\n *   requires them) but the engine falls back to core's node_modules auto-load,\n *   so tests run against real, local wasm without a network fetch.\n *\n * Dual-OCCT-copy note: `occt-wasm`'s opaque instance type is nominal per\n * package install (a `#private` member), so a pristine cross-copy type cannot\n * be expressed. The demo uses `OcctKernel.init({ wasm })` plus a cast to the\n * faijs-expected return shape; the viewer mirrors that established pattern.\n */\n\nimport { setOcctWasmInitFn, setManifoldWasmUrl } from '@faicad/faijs/browser'\n\n/** A wasm URL triplet (same shape as the v1 contract). */\nexport interface ViewerWasmUrls {\n  occtUrl: string\n  manifoldUrl: string\n  brepkitUrl: string\n}\n\n/** A code-pinned capability error surfaced by the viewer. */\nexport interface EngineError {\n  code: 'E_WASM_URL'\n  message: string\n}\n\nfunction throwEngine(message: string): never {\n  const err = new Error(message)\n  ;(err as Error & { code: string }).code = 'E_WASM_URL'\n  throw err\n}\n\n/**\n * Validate the three v1 wasm urls. Throws a code-bearing `E_WASM_URL` error\n * when any is missing or empty, as required by the v1 contract.\n * @param wasm - The three v1 wasm asset URLs ({ occtUrl, manifoldUrl, brepkitUrl }) to validate. type:ViewerWasmUrls required:true\n */\nexport function assertWasmUrls(wasm: Readonly<ViewerWasmUrls> | undefined): void {\n  if (!wasm) {\n    throwEngine('openFaiZip requires `wasm` — supply { occtUrl, manifoldUrl, brepkitUrl }.')\n  }\n  for (const key of ['occtUrl', 'manifoldUrl', 'brepkitUrl'] as const) {\n    if (typeof wasm[key] !== 'string' || wasm[key].length === 0) {\n      throwEngine(`openFaiZip wasm.${key} must be a non-empty string.`)\n    }\n  }\n}\n\nfunction hasBrowserWindow(): boolean {\n  return typeof window !== 'undefined' && typeof window.addEventListener === 'function'\n}\n\n/**\n * Bind the engine kernels for a real browser, installing the occt and manifold\n * init hooks from the configured URLs. `occt-wasm` is loaded lazily so this\n * path only exists in the browser (never forces the dependency at load time in\n * Node tests). brepkit is a secondary engine whose mesh boolean is not yet\n * wired (v1, plan §1.8), so its URL is accepted but not depended on at\n * execution time.\n */\nasync function bindBrowserWasm(wasm: Readonly<ViewerWasmUrls>): Promise<void> {\n  const { OcctKernel } = await import('occt-wasm')\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  setOcctWasmInitFn((() => OcctKernel.init({ wasm: wasm.occtUrl })) as any)\n  setManifoldWasmUrl(wasm.manifoldUrl)\n  // brepkit: accepted, not consumed in v1.\n  void wasm.brepkitUrl\n}\n\n/**\n * Install the engine kernels for an `openFaiZip` view. Safe to call\n * repeatedly — core's kernel singletons are environment-wide and\n * instance-neutral.\n *\n * In a browser the three URLs are registered; in a Node/worker runner the URLs\n * are still validated and the Node engine auto-loads its own local wasm.\n * @param wasm - The three v1 wasm asset URLs; validated here, registered in browsers. type:ViewerWasmUrls required:true\n */\nexport async function installEngine(wasm: Readonly<ViewerWasmUrls>): Promise<void> {\n  assertWasmUrls(wasm)\n  if (hasBrowserWindow()) {\n    await bindBrowserWasm(wasm)\n  }\n}"]}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `@faicad/faijs-viewer` — the reference way for any third-party host to
+ * open and tessellate a project `.fai.zip` document.
+ *
+ * v1 API:
+ * ```
+ * import { openFaiZip } from '@faicad/faijs-viewer'
+ * const result = await openFaiZip(bytes, {
+ *   wasm: { occtUrl, manifoldUrl, brepkitUrl },
+ * })
+ * // result.meshes === [{ name, positions: Float32Array, indices: Uint32Array }]
+ * ```
+ *
+ * The three wasm URLs are all mandatory: the engine's BREP chain depends on
+ * OCCT, its mesh/CSG path depends on manifold, and brepkit is part of the
+ * reserved engine surface. In a browser each kernel loads its wasm from the
+ * given URL; in a Node/worker runner the same URLs are validated and the local
+ * engines auto-load their bundled wasm.
+ */
+export { openFaiZip } from './open-fai-zip.js';
+export type { OpenFaiZipOptions, FaiViewerMesh, FaiViewerError, FaiZipViewerErrorCode, OpenFaiResult, FaiZipViewerWasmOptions, } from './types.js';
+export { assertWasmUrls, installEngine } from './engine.js';
+export type { ViewerWasmUrls } from './engine.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,uBAAuB,GACxB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxD,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1,22 @@
+/**
+ * `@faicad/faijs-viewer` — the reference way for any third-party host to
+ * open and tessellate a project `.fai.zip` document.
+ *
+ * v1 API:
+ * ```
+ * import { openFaiZip } from '@faicad/faijs-viewer'
+ * const result = await openFaiZip(bytes, {
+ *   wasm: { occtUrl, manifoldUrl, brepkitUrl },
+ * })
+ * // result.meshes === [{ name, positions: Float32Array, indices: Uint32Array }]
+ * ```
+ *
+ * The three wasm URLs are all mandatory: the engine's BREP chain depends on
+ * OCCT, its mesh/CSG path depends on manifold, and brepkit is part of the
+ * reserved engine surface. In a browser each kernel loads its wasm from the
+ * given URL; in a Node/worker runner the same URLs are validated and the local
+ * engines auto-load their bundled wasm.
+ */
+export { openFaiZip } from './open-fai-zip.js';
+export { assertWasmUrls, installEngine } from './engine.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAS3C,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA","sourcesContent":["/**\n * `@faicad/faijs-viewer` — the reference way for any third-party host to\n * open and tessellate a project `.fai.zip` document.\n *\n * v1 API:\n * ```\n * import { openFaiZip } from '@faicad/faijs-viewer'\n * const result = await openFaiZip(bytes, {\n *   wasm: { occtUrl, manifoldUrl, brepkitUrl },\n * })\n * // result.meshes === [{ name, positions: Float32Array, indices: Uint32Array }]\n * ```\n *\n * The three wasm URLs are all mandatory: the engine's BREP chain depends on\n * OCCT, its mesh/CSG path depends on manifold, and brepkit is part of the\n * reserved engine surface. In a browser each kernel loads its wasm from the\n * given URL; in a Node/worker runner the same URLs are validated and the local\n * engines auto-load their bundled wasm.\n */\n\nexport { openFaiZip } from './open-fai-zip'\nexport type {\n  OpenFaiZipOptions,\n  FaiViewerMesh,\n  FaiViewerError,\n  FaiZipViewerErrorCode,\n  OpenFaiResult,\n  FaiZipViewerWasmOptions,\n} from './types'\nexport { assertWasmUrls, installEngine } from './engine'\nexport type { ViewerWasmUrls } from './engine'"]}

package/dist/libs.d.ts

@@ -0,0 +1,42 @@
+/**
+ * libs — the viewer's third-party library loader (the dynamic side of
+ * `openFaiZip`).
+ *
+ * The engine loads a model's namespace imports lazily at execute time
+ * (`autoLoadLibsFromImports` → `HostPorts.libLoader.loadLib`). This module
+ * builds that loader for the viewer. Preset libraries (core, sketch,
+ * faijs-extra — merged into the default `cad` namespace) never pass through it;
+ * it serves scripts like `import * as gears from "@faicad/faijs-gears"` only.
+ *
+ * Dispatch follows the environment:
+ * - a browser host gets `createBrowserLibLoader` (jsDelivr CDN dynamic
+ *   `import()`, version-pinned `+esm` links when `versions` is provided);
+ * - a Node host gets an internal whitelisted `import(pkg)` loader mirroring
+ *   core's CLI loader semantics: per-library `faijs.autoLift` from each
+ *   package's own `package.json`, plus `loadSource` for determinism scanning.
+ *
+ * **Access policy (user-decided, 2026-10-04):** every `@faicad/*` package is
+ * allowed by default — no whitelist is required. Non-`@faicad/*` packages are
+ * rejected (defence against look-alike stranger packages from an untrusted
+ * `.fai.zip`). The Node branch enforces the scoped prefix directly; the
+ * browser branch wraps core's loader (whose `libs` option, when omitted,
+ * would otherwise allow everything) with the same check.
+ *
+ * The Node branches touch `node:` builtins, so they are reached only through
+ * dynamic `import(/* @vite-ignore *​/)` calls behind an `inNodeEnv()` guard —
+ * the same pattern `ensureSketchSolver` uses in `open-fai-zip.ts`. A browser
+ * bundler never bundles the `node:` branch into a shipped chunk.
+ */
+import type { LibLoader } from '@faicad/faijs';
+import type { FaiViewerLibsOptions } from './types.js';
+/**
+ * Build the viewer's library loader for `openFaiZip`.
+ *
+ * @param opts - the `libs` config from `OpenFaiZipOptions`; `undefined` means
+ *   dynamic loading is enabled with the loader defaults.
+ * @returns the loader, or `undefined` when dynamic loading is disabled
+ *   (`libs.enabled === false`) — unregistered library imports then fail as
+ *   unbound namespaces at execution.
+ */
+export declare function createViewerLibLoader(opts: FaiViewerLibsOptions | undefined): Promise<LibLoader | undefined>;
+//# sourceMappingURL=libs.d.ts.map

package/dist/libs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libs.d.ts","sourceRoot":"","sources":["../src/libs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAuInD;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAsBlH"}

package/dist/libs.js

@@ -0,0 +1,192 @@
+/**
+ * libs — the viewer's third-party library loader (the dynamic side of
+ * `openFaiZip`).
+ *
+ * The engine loads a model's namespace imports lazily at execute time
+ * (`autoLoadLibsFromImports` → `HostPorts.libLoader.loadLib`). This module
+ * builds that loader for the viewer. Preset libraries (core, sketch,
+ * faijs-extra — merged into the default `cad` namespace) never pass through it;
+ * it serves scripts like `import * as gears from "@faicad/faijs-gears"` only.
+ *
+ * Dispatch follows the environment:
+ * - a browser host gets `createBrowserLibLoader` (jsDelivr CDN dynamic
+ *   `import()`, version-pinned `+esm` links when `versions` is provided);
+ * - a Node host gets an internal whitelisted `import(pkg)` loader mirroring
+ *   core's CLI loader semantics: per-library `faijs.autoLift` from each
+ *   package's own `package.json`, plus `loadSource` for determinism scanning.
+ *
+ * **Access policy (user-decided, 2026-10-04):** every `@faicad/*` package is
+ * allowed by default — no whitelist is required. Non-`@faicad/*` packages are
+ * rejected (defence against look-alike stranger packages from an untrusted
+ * `.fai.zip`). The Node branch enforces the scoped prefix directly; the
+ * browser branch wraps core's loader (whose `libs` option, when omitted,
+ * would otherwise allow everything) with the same check.
+ *
+ * The Node branches touch `node:` builtins, so they are reached only through
+ * dynamic `import(/* @vite-ignore *​/)` calls behind an `inNodeEnv()` guard —
+ * the same pattern `ensureSketchSolver` uses in `open-fai-zip.ts`. A browser
+ * bundler never bundles the `node:` branch into a shipped chunk.
+ */
+import { createBrowserLibLoader } from '@faicad/faijs/browser';
+/** Node runner detection (mirrors core's `hasBrowserWindow`). */
+function inNodeEnv() {
+    return typeof window === 'undefined' || typeof window.addEventListener !== 'function';
+}
+/** Allowed scoped prefix: every `@faicad/` package loads without a whitelist. */
+const SCOPED_PREFIX = '@faicad/';
+/**
+ * Access policy shared by both branches: every `@faicad/*` package is allowed
+ * by default; anything else is rejected. (User-decided 2026-10-04: no
+ * whitelist parameter — all `@faicad` packages load without configuration.)
+ */
+function assertScoped(pkg, name) {
+    if (!pkg.startsWith(SCOPED_PREFIX)) {
+        throw new Error(`package "${name}" is not a scoped @faicad/ library`);
+    }
+}
+/**
+ * Build the Node library loader.
+ *
+ * `import(pkg)` resolves through the host's module graph: the package must be
+ * installed (or reachable) from the consumer. An unresolved package throws
+ * `ERR_MODULE_NOT_FOUND`, which the runtime surfaces as a structured load
+ * failure at the import statement — never a viewer throw.
+ */
+async function createNodeLibLoader(opts) {
+    // node:* builtins are imported dynamically behind the Node guard so a
+    // browser-targeted bundler never sees them statically.
+    const { createRequire } = await import(/* @vite-ignore */ 'node:module');
+    const { readFileSync, existsSync } = await import(/* @vite-ignore */ 'node:fs');
+    const { dirname, join } = await import(/* @vite-ignore */ 'node:path');
+    const requireNode = createRequire(import.meta.url);
+    const aliases = { ...(opts.aliases ?? {}) };
+    /** specifier → npm package name. */
+    const pkgOf = (name) => aliases[name] ?? name;
+    /**
+     * Locate a package's root directory without tripping on its `exports` map.
+     *
+     * `require.resolve(pkg/package.json)` fails with ERR_PACKAGE_PATH_NOT_EXPORTED
+     * for packages whose `exports` does not list the `package.json` subpath (all
+     * @faicad family packages today). Resolving the package's main entry instead
+     * (always listed in `exports`), then walking up to the first `package.json`
+     * whose `name` matches, yields the root in both symlinked-workspace and
+     * installed-from-registry layouts. GOTCHA (2026-10-04): core's own CLI loader
+     * (`cli.ts` `loadSource` / `readLibAutoLift`) uses the direct
+     * `resolve(pkg/package.json)` form and therefore silently returns `undefined`
+     * for every exported library — the viewer must not copy that behaviour.
+     */
+    function findPkgDir(pkg) {
+        try {
+            const entry = requireNode.resolve(pkg);
+            let dir = dirname(entry);
+            for (let i = 0; i < 6; i++) {
+                const pjPath = join(dir, 'package.json');
+                if (existsSync(pjPath)) {
+                    try {
+                        const pj = JSON.parse(readFileSync(pjPath, 'utf8'));
+                        if (pj.name === pkg)
+                            return dir;
+                    }
+                    catch {
+                        // Unparseable package.json: keep walking up.
+                    }
+                }
+                const parent = dirname(dir);
+                if (parent === dir)
+                    break;
+                dir = parent;
+            }
+        }
+        catch {
+            // Unresolvable package: caller handles `undefined`.
+        }
+        return undefined;
+    }
+    /** Read `faijs.autoLift` from the library's own `package.json` (D3-autoLift).
+     * Absent → `undefined` (runtime falls back to its `!hasDualOp` inference). */
+    function readLibAutoLift(pkg) {
+        const pkgDir = findPkgDir(pkg);
+        if (!pkgDir)
+            return undefined;
+        try {
+            const pj = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8'));
+            const v = pj.faijs?.autoLift;
+            return typeof v === 'boolean' ? v : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return {
+        loadLib: async (name) => {
+            const pkg = pkgOf(name);
+            assertScoped(pkg, name);
+            return (await import(pkg));
+        },
+        listLibs: () => [...Object.keys(aliases), '@faicad/'],
+        loadSource: async (name) => {
+            const pkg = pkgOf(name);
+            const pkgDir = findPkgDir(pkg);
+            if (!pkgDir)
+                return undefined;
+            // Compiled JS first: the runtime's determinism scan (`scanLibrarySource`,
+            // strict mode) rejects TS sources outright ("libraries must ship compiled
+            // JS"), and it runs against every @faicad/* import before loadLib.
+            for (const p of [
+                join(pkgDir, 'dist', 'index.js'),
+                join(pkgDir, 'src', 'index.js'),
+                join(pkgDir, 'src', 'index.ts'),
+            ]) {
+                if (existsSync(p))
+                    return readFileSync(p, 'utf8');
+            }
+            return undefined;
+        },
+        options: {
+            // Lifting defaults to the runtime's `!hasDualOp(ns)` inference: bare
+            // function libraries (gears, fasteners, sheetmetal) lift to the
+            // script-facing shape automatically, dual-op libraries stay unlifted.
+            // Each library overrides through its own `faijs.autoLift` declaration
+            // (`autoLiftFor`), mirroring core's per-library D3 convention. Note this
+            // deliberately differs from core's CLI loader, which defaults
+            // `autoLift: false` and leaves undeclared bare-function libraries
+            // un-lifted — a CLI-side limitation the viewer does not copy.
+            autoLiftFor: (name) => readLibAutoLift(pkgOf(name)),
+        },
+    };
+}
+/**
+ * Build the viewer's library loader for `openFaiZip`.
+ *
+ * @param opts - the `libs` config from `OpenFaiZipOptions`; `undefined` means
+ *   dynamic loading is enabled with the loader defaults.
+ * @returns the loader, or `undefined` when dynamic loading is disabled
+ *   (`libs.enabled === false`) — unregistered library imports then fail as
+ *   unbound namespaces at execution.
+ */
+export async function createViewerLibLoader(opts) {
+    if (opts?.enabled === false)
+        return undefined;
+    if (inNodeEnv())
+        return createNodeLibLoader(opts ?? {});
+    const inner = createBrowserLibLoader({
+        cdnBase: opts?.cdnBase,
+        versions: opts?.versions,
+        aliases: opts?.aliases,
+        importModule: opts?.importModule,
+    });
+    // Wrap core's loader with the shared access policy: core's `libs` option,
+    // when omitted, allows ANY package — an untrusted `.fai.zip` must not reach
+    // that. Every `@faicad/*` package loads by default; anything else is
+    // rejected before any CDN import.
+    const { loadLib, ...rest } = inner;
+    return {
+        ...rest,
+        loadLib: async (name) => {
+            const pkg = opts?.aliases?.[name] ?? name;
+            assertScoped(pkg, name);
+            return loadLib(name);
+        },
+    };
+}
+//# sourceMappingURL=libs.js.map

package/dist/libs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"libs.js","sourceRoot":"","sources":["../src/libs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * libs — the viewer's third-party library loader (the dynamic side of\n * `openFaiZip`).\n *\n * The engine loads a model's namespace imports lazily at execute time\n * (`autoLoadLibsFromImports` → `HostPorts.libLoader.loadLib`). This module\n * builds that loader for the viewer. Preset libraries (core, sketch,\n * faijs-extra — merged into the default `cad` namespace) never pass through it;\n * it serves scripts like `import * as gears from \"@faicad/faijs-gears\"` only.\n *\n * Dispatch follows the environment:\n * - a browser host gets `createBrowserLibLoader` (jsDelivr CDN dynamic\n *   `import()`, version-pinned `+esm` links when `versions` is provided);\n * - a Node host gets an internal whitelisted `import(pkg)` loader mirroring\n *   core's CLI loader semantics: per-library `faijs.autoLift` from each\n *   package's own `package.json`, plus `loadSource` for determinism scanning.\n *\n * **Access policy (user-decided, 2026-10-04):** every `@faicad/*` package is\n * allowed by default — no whitelist is required. Non-`@faicad/*` packages are\n * rejected (defence against look-alike stranger packages from an untrusted\n * `.fai.zip`). The Node branch enforces the scoped prefix directly; the\n * browser branch wraps core's loader (whose `libs` option, when omitted,\n * would otherwise allow everything) with the same check.\n *\n * The Node branches touch `node:` builtins, so they are reached only through\n * dynamic `import(/* @vite-ignore *​/)` calls behind an `inNodeEnv()` guard —\n * the same pattern `ensureSketchSolver` uses in `open-fai-zip.ts`. A browser\n * bundler never bundles the `node:` branch into a shipped chunk.\n */\n\nimport { createBrowserLibLoader } from '@faicad/faijs/browser'\nimport type { LibLoader } from '@faicad/faijs'\nimport type { LibNamespace } from '@faicad/faijs/runtime-state'\nimport type { FaiViewerLibsOptions } from './types'\n\n/** Node runner detection (mirrors core's `hasBrowserWindow`). */\nfunction inNodeEnv(): boolean {\n  return typeof window === 'undefined' || typeof window.addEventListener !== 'function'\n}\n\n/** Allowed scoped prefix: every `@faicad/` package loads without a whitelist. */\nconst SCOPED_PREFIX = '@faicad/'\n\n/**\n * Access policy shared by both branches: every `@faicad/*` package is allowed\n * by default; anything else is rejected. (User-decided 2026-10-04: no\n * whitelist parameter — all `@faicad` packages load without configuration.)\n */\nfunction assertScoped(pkg: string, name: string): void {\n  if (!pkg.startsWith(SCOPED_PREFIX)) {\n    throw new Error(`package \"${name}\" is not a scoped @faicad/ library`)\n  }\n}\n\n/**\n * Build the Node library loader.\n *\n * `import(pkg)` resolves through the host's module graph: the package must be\n * installed (or reachable) from the consumer. An unresolved package throws\n * `ERR_MODULE_NOT_FOUND`, which the runtime surfaces as a structured load\n * failure at the import statement — never a viewer throw.\n */\nasync function createNodeLibLoader(opts: FaiViewerLibsOptions): Promise<LibLoader> {\n  // node:* builtins are imported dynamically behind the Node guard so a\n  // browser-targeted bundler never sees them statically.\n  const { createRequire } = await import(/* @vite-ignore */ 'node:module')\n  const { readFileSync, existsSync } = await import(/* @vite-ignore */ 'node:fs')\n  const { dirname, join } = await import(/* @vite-ignore */ 'node:path')\n  const requireNode = createRequire(import.meta.url)\n\n  const aliases: Record<string, string> = { ...(opts.aliases ?? {}) }\n\n  /** specifier → npm package name. */\n  const pkgOf = (name: string): string => aliases[name] ?? name\n\n  /**\n   * Locate a package's root directory without tripping on its `exports` map.\n   *\n   * `require.resolve(pkg/package.json)` fails with ERR_PACKAGE_PATH_NOT_EXPORTED\n   * for packages whose `exports` does not list the `package.json` subpath (all\n   * @faicad family packages today). Resolving the package's main entry instead\n   * (always listed in `exports`), then walking up to the first `package.json`\n   * whose `name` matches, yields the root in both symlinked-workspace and\n   * installed-from-registry layouts. GOTCHA (2026-10-04): core's own CLI loader\n   * (`cli.ts` `loadSource` / `readLibAutoLift`) uses the direct\n   * `resolve(pkg/package.json)` form and therefore silently returns `undefined`\n   * for every exported library — the viewer must not copy that behaviour.\n   */\n  function findPkgDir(pkg: string): string | undefined {\n    try {\n      const entry = requireNode.resolve(pkg)\n      let dir = dirname(entry)\n      for (let i = 0; i < 6; i++) {\n        const pjPath = join(dir, 'package.json')\n        if (existsSync(pjPath)) {\n          try {\n            const pj = JSON.parse(readFileSync(pjPath, 'utf8')) as { name?: string }\n            if (pj.name === pkg) return dir\n          } catch {\n            // Unparseable package.json: keep walking up.\n          }\n        }\n        const parent = dirname(dir)\n        if (parent === dir) break\n        dir = parent\n      }\n    } catch {\n      // Unresolvable package: caller handles `undefined`.\n    }\n    return undefined\n  }\n\n  /** Read `faijs.autoLift` from the library's own `package.json` (D3-autoLift).\n   * Absent → `undefined` (runtime falls back to its `!hasDualOp` inference). */\n  function readLibAutoLift(pkg: string): boolean | undefined {\n    const pkgDir = findPkgDir(pkg)\n    if (!pkgDir) return undefined\n    try {\n      const pj = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')) as {\n        faijs?: { autoLift?: boolean }\n      }\n      const v = pj.faijs?.autoLift\n      return typeof v === 'boolean' ? v : undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  return {\n    loadLib: async (name: string) => {\n      const pkg = pkgOf(name)\n      assertScoped(pkg, name)\n      return (await import(pkg)) as LibNamespace\n    },\n\n    listLibs: () => [...Object.keys(aliases), '@faicad/'],\n\n    loadSource: async (name: string) => {\n      const pkg = pkgOf(name)\n      const pkgDir = findPkgDir(pkg)\n      if (!pkgDir) return undefined\n      // Compiled JS first: the runtime's determinism scan (`scanLibrarySource`,\n      // strict mode) rejects TS sources outright (\"libraries must ship compiled\n      // JS\"), and it runs against every @faicad/* import before loadLib.\n      for (const p of [\n        join(pkgDir, 'dist', 'index.js'),\n        join(pkgDir, 'src', 'index.js'),\n        join(pkgDir, 'src', 'index.ts'),\n      ]) {\n        if (existsSync(p)) return readFileSync(p, 'utf8')\n      }\n      return undefined\n    },\n\n    options: {\n      // Lifting defaults to the runtime's `!hasDualOp(ns)` inference: bare\n      // function libraries (gears, fasteners, sheetmetal) lift to the\n      // script-facing shape automatically, dual-op libraries stay unlifted.\n      // Each library overrides through its own `faijs.autoLift` declaration\n      // (`autoLiftFor`), mirroring core's per-library D3 convention. Note this\n      // deliberately differs from core's CLI loader, which defaults\n      // `autoLift: false` and leaves undeclared bare-function libraries\n      // un-lifted — a CLI-side limitation the viewer does not copy.\n      autoLiftFor: (name: string) => readLibAutoLift(pkgOf(name)),\n    },\n  }\n}\n\n/**\n * Build the viewer's library loader for `openFaiZip`.\n *\n * @param opts - the `libs` config from `OpenFaiZipOptions`; `undefined` means\n *   dynamic loading is enabled with the loader defaults.\n * @returns the loader, or `undefined` when dynamic loading is disabled\n *   (`libs.enabled === false`) — unregistered library imports then fail as\n *   unbound namespaces at execution.\n */\nexport async function createViewerLibLoader(opts: FaiViewerLibsOptions | undefined): Promise<LibLoader | undefined> {\n  if (opts?.enabled === false) return undefined\n  if (inNodeEnv()) return createNodeLibLoader(opts ?? {})\n  const inner = createBrowserLibLoader({\n    cdnBase: opts?.cdnBase,\n    versions: opts?.versions,\n    aliases: opts?.aliases,\n    importModule: opts?.importModule,\n  })\n  // Wrap core's loader with the shared access policy: core's `libs` option,\n  // when omitted, allows ANY package — an untrusted `.fai.zip` must not reach\n  // that. Every `@faicad/*` package loads by default; anything else is\n  // rejected before any CDN import.\n  const { loadLib, ...rest } = inner\n  return {\n    ...rest,\n    loadLib: async (name: string) => {\n      const pkg = opts?.aliases?.[name] ?? name\n      assertScoped(pkg, name)\n      return loadLib(name)\n    },\n  }\n}\n"]}

package/dist/open-fai-zip.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `openFaiZip` — the reference API of `@faicad/faijs-viewer`.
+ *
+ * v1 contract:
+ * ```
+ * openFaiZip(bytes, { wasm: { occtUrl, manifoldUrl, brepkitUrl } })
+ * ```
+ *
+ * Given a project `.fai.zip` byte buffer and the three engine wasm URLs, this
+ * reads the container, resolves the active (or requested) model, executes it
+ * through `@faicad/faijs` (`createRuntime` over the container's own module
+ * graph), and returns structured, tessellated mesh data plus provenance.
+ *
+ * The return value is host- and rendering-agnostic: arrays of
+ * `Float32Array` / `Uint32Array` mesh data, no THREE or DOM in sight. A
+ * render-relevant failure never throws — it is surfaced on `result.error` as a
+ * structured `FaiViewerError`. Environment/setup failures (e.g. a missing or
+ * empty `wasm` URL) throw a code-bearing error from `installEngine`.
+ */
+import type { OpenFaiZipOptions, OpenFaiResult } from './types.js';
+/**
+ * Open, execute, and tessellate a project `.fai.zip`.
+ *
+ * @param bytes the container byte array.
+ * @param opts the viewer options; `opts.wasm` (three URLs) is required.
+ * @returns an `OpenFaiResult` with structured meshes, or an `error`.
+ */
+export declare function openFaiZip(bytes: Uint8Array, opts: OpenFaiZipOptions): Promise<OpenFaiResult>;
+//# sourceMappingURL=open-fai-zip.d.ts.map

package/dist/open-fai-zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-fai-zip.d.ts","sourceRoot":"","sources":["../src/open-fai-zip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAUH,OAAO,KAAK,EAAiC,iBAAiB,EAAE,aAAa,EAAyB,MAAM,SAAS,CAAA;AAoJrH;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CA6EnG"}

package/dist/open-fai-zip.js

@@ -0,0 +1,239 @@
+/**
+ * `openFaiZip` — the reference API of `@faicad/faijs-viewer`.
+ *
+ * v1 contract:
+ * ```
+ * openFaiZip(bytes, { wasm: { occtUrl, manifoldUrl, brepkitUrl } })
+ * ```
+ *
+ * Given a project `.fai.zip` byte buffer and the three engine wasm URLs, this
+ * reads the container, resolves the active (or requested) model, executes it
+ * through `@faicad/faijs` (`createRuntime` over the container's own module
+ * graph), and returns structured, tessellated mesh data plus provenance.
+ *
+ * The return value is host- and rendering-agnostic: arrays of
+ * `Float32Array` / `Uint32Array` mesh data, no THREE or DOM in sight. A
+ * render-relevant failure never throws — it is surfaced on `result.error` as a
+ * structured `FaiViewerError`. Environment/setup failures (e.g. a missing or
+ * empty `wasm` URL) throw a code-bearing error from `installEngine`.
+ */
+import { createBrowserPorts, createRuntime, isMeshShape } from '@faicad/faijs/browser';
+import { createApiNamespace } from '@faicad/faijs/api/api-namespace';
+import { mergeSketchNamespace, installSketchSolver, registerSketchSymbols } from '@faicad/faijs-sketch';
+import { mergeEditorNamespace, registerEditorSymbols } from '@faicad/faijs-extra';
+import { openContainer } from '@faicad/faijs/io/fai-zip';
+import { installEngine } from './engine.js';
+import { createViewerLibLoader } from './libs.js';
+function failure(code, message, detail) {
+    return { code, message, detail };
+}
+/**
+ * Hand the exact typed-array byte range out to the host without sharing the
+ * archive page. Mesh arrays are already `Float32Array` / `Uint32Array`; this
+ * isolates the backing buffer so the host (and potential transfer) is safe.
+ */
+function isolateArray(array) {
+    const ctor = array.constructor;
+    return new ctor(array);
+}
+/**
+ * Structure the visible terminals of an execution result into a flat mesh
+ * list. Mirrors `packages/demo/main.ts#extractShapes`: hidden terminals
+ * (boolean sources, etc.) are never counted; when no explicit terminal exists,
+ * the last statement output is used.
+ */
+function extractMeshes(result) {
+    const meshes = [];
+    const visible = result.terminals.filter((t) => !t.hidden);
+    if (visible.length > 0) {
+        for (const terminal of visible) {
+            const shape = result.outputs.get(terminal.id);
+            if (shape && isMeshShape(shape)) {
+                meshes.push({
+                    name: terminal.id,
+                    positions: isolateArray(shape.positions),
+                    indices: isolateArray(shape.indices),
+                });
+            }
+        }
+        return meshes;
+    }
+    const outputs = Array.from(result.outputs.values());
+    const last = outputs[outputs.length - 1];
+    if (last && last.positions && last.indices) {
+        meshes.push({
+            name: 'output',
+            positions: isolateArray(last.positions),
+            indices: isolateArray(last.indices),
+        });
+    }
+    return meshes;
+}
+/**
+ * Build an asset resolver over the container's `assets/` payload map, backing
+ * `cad.loadByKey` and the BREP-asset import op with the exact bytes the archive
+ * carries. A missing key throws (mirrors `FetchAssetResolver`'s hard error).
+ */
+function containerAssetResolver(assets) {
+    return {
+        async resolveByKey(key) {
+            const bytes = assets[key];
+            if (bytes === undefined) {
+                throw new Error(`[faijs-viewer] asset key "${key}" is not present in this .fai.zip`);
+            }
+            const copy = new Uint8Array(bytes);
+            return { bytes: copy.buffer, format: 'brp' };
+        },
+        async resolveFile(_path) {
+            throw new Error('[faijs-viewer] resolveFile is unavailable — a .fai.zip is self-contained; load assets by key (`cad.load`) instead.');
+        },
+        async resolveUrl(url) {
+            try {
+                const res = await fetch(url);
+                if (!res.ok)
+                    throw new Error(`[faijs-viewer] resolveUrl fetch failed: ${url} (${res.status})`);
+                return await res.arrayBuffer();
+            }
+            catch (e) {
+                throw new Error(`[faijs-viewer] resolveUrl failed for ${url}: ${String(e)}`);
+            }
+        },
+    };
+}
+/** Node runner detection (mirrors core's `hasBrowserWindow`). */
+function inNodeEnv() {
+    return typeof window === 'undefined' || typeof window.addEventListener !== 'function';
+}
+/**
+ * Make the `cad.sketch` / `cad.draw` constraint solver available to the
+ * shared, module-global sketch op.
+ *
+ * The solver lives in `@faicad/faijs-sketch` and is host-injected via
+ * `installSketchSolver`, because the planegcs wasm source differs between Node
+ * and browser hosts. Node auto-loads the solver (its wasm ships in
+ * `@salusoft89/planegcs`); a browser host self-hosts `planegcs.wasm` and passes
+ * `opts.sketch.planegcsUrl`. The `E_SKETCH_NO_SOLVER` error is surfaced through
+ * `OpenFaiResult.error`, never thrown.
+ *
+ * The Node-only subpath (specified by `NODE_SKETCH_SOLVER_SPECIFIER`) imports
+ * `node:module` via `createRequire`, which a browser-targeted bundler cannot
+ * shim for a code-splitting worker/chunk. It is therefore never written as a
+ * literal in an `import()` here: `/* @vite-ignore *` plus an opaque specifier
+ * leaves resolution entirely to the runtime, so Vite/Rollup/webpack never
+ * bundle its node:* into a browser build. A Node host resolves it normally; a
+ * browser host never reaches that branch.
+ */
+const NODE_SKETCH_SOLVER_SPECIFIER = '@faicad/faijs-sketch/node';
+async function ensureSketchSolver(opts) {
+    if (inNodeEnv()) {
+        // The /node subpath imports `node:module`, so it must never be statically
+        // imported from a browser-targeted entry. Dynamic import keeps the browser
+        // bundle free of `node:*`.
+        try {
+            const nodeSolver = (await import(/* @vite-ignore */ NODE_SKETCH_SOLVER_SPECIFIER));
+            installSketchSolver(nodeSolver.createNodePlanegcsSolver);
+        }
+        catch {
+            // The solver package is not installed in this process — sketch models
+            // will surface E_SKETCHC_NO_SOLVER. Core mesh-only containers are unaffected.
+        }
+        return;
+    }
+    const planegcsUrl = opts?.sketch?.planegcsUrl;
+    if (!planegcsUrl)
+        return; // browser without a self-hosted solver → E_SKETCHC_NO_SOLVER at execution time
+    try {
+        const res = await fetch(planegcsUrl);
+        if (!res.ok)
+            throw new Error(`planegcs fetch failed: ${planegcsUrl} (${res.status})`);
+        const wasmBytes = new Uint8Array(await res.arrayBuffer());
+        const { createPlanegcsSolver } = await import('@faicad/faijs-sketch');
+        installSketchSolver(async () => createPlanegcsSolver({ wasmBytes }));
+    }
+    catch (e) {
+        // Degrade, mirroring the Node branch: an unreachable solver (offline CDN,
+        // network policy, …) must not sink every `.fai.zip` open — models that
+        // never call `cad.sketch` load fine, and models that do surface a
+        // structured `E_SKETCHC_NO_SOLVER` at execution. Previously this threw
+        // `[faijs-viewer] planegcs solver init failed: …`, failing even pure
+        // `cad.box` containers when the solver URL could not be fetched.
+        console.warn(`[faijs-viewer] planegcs solver unavailable, sketch models will fail: ${String(e)}`);
+    }
+}
+/**
+ * Open, execute, and tessellate a project `.fai.zip`.
+ *
+ * @param bytes the container byte array.
+ * @param opts the viewer options; `opts.wasm` (three URLs) is required.
+ * @returns an `OpenFaiResult` with structured meshes, or an `error`.
+ */
+export async function openFaiZip(bytes, opts) {
+    await ensureSketchSolver(opts);
+    // 1. Engine contract. The three wasm urls are mandatory; a missing or empty
+    //    url throws (E_WASM_URL) — this is a caller contract violation, not a
+    //    per-bytes render failure, so it propagates rather than returning an
+    //    `error` result. In a browser the URLs bind occt/manifold wasm; in a
+    //    Node runner they are validated and local engines auto-load.
+    await installEngine(opts.wasm);
+    // 2. Reader-side: parse the container (manifest, active model, module graph,
+    //    payloads). Hard container errors become an E_CONTAINER result.
+    let container;
+    try {
+        container = openContainer(bytes, { modelId: opts?.modelId });
+    }
+    catch (e) {
+        return { modelId: '', meshes: [], error: failure('E_CONTAINER', e.message, e) };
+    }
+    // 3. Host ports: archive asset authorisation + the container module loader.
+    //    The loader already enumerates/reads the `model/**` module graph. The
+    //    library loader (dynamic side) serves namespace imports of third-party
+    //    faijs packages (`@faicad/faijs-gears`, `@faicad/sheetmetal`, …) — the
+    //    engine calls it lazily at execute time, only for libraries a model
+    //    actually imports. `libs.enabled === false` omits it, so unregistered
+    //    library imports fail as unbound namespaces.
+    const libLoader = await createViewerLibLoader(opts?.libs);
+    const ports = await createBrowserPorts({
+        assets: containerAssetResolver(container.assets),
+        projectLoader: container.loader,
+        ...(libLoader ? { libLoader } : {}),
+    });
+    // 4. Assemble a runtime bound to those ports, then execute the active model.
+    const runtime = createRuntime(ports, opts?.mode ?? 'auto');
+    // Real converted containers call `cad.sketch` and editor-extension ops
+    // (`cad.fai_drill` / `cad.group` / `cad.text` / …), which live in the sketch
+    // and faijs-extra libraries rather than core. Re-register the default `cad`
+    // binding with those merged in so such models execute without any import
+    // statement. The symbol-table entries are also registered so static analysis
+    // recognises them. (`@faicad/faijs-draw` is deprecated and deliberately not
+    // merged: a `cad.draw` call fails as an unknown callee.)
+    registerSketchSymbols();
+    registerEditorSymbols();
+    runtime.registerLib('cad', mergeEditorNamespace(mergeSketchNamespace(createApiNamespace())), { default: true });
+    const entryKey = container.activeModel.entry.slice('model/'.length);
+    const entrySource = await container.loader.readSource(entryKey);
+    const result = await runtime.execute(entrySource, { entryKey });
+    if (result.failedAt) {
+        return {
+            sourceFile: container.manifest.source?.file,
+            modelId: container.activeModel.id,
+            meshes: [],
+            error: failure('E_EXECUTION', `Execution failed at op "${result.failedAt.callee}": ${result.failedAt.message}`, result.failedAt),
+        };
+    }
+    // 5. Structure the visible terminals into host-friendly meshes.
+    const meshes = extractMeshes(result);
+    if (meshes.length === 0) {
+        return {
+            sourceFile: container.manifest.source?.file,
+            modelId: container.activeModel.id,
+            meshes: [],
+            error: failure('E_NO_GEOMETRY', 'The model produced no visible, tessellable geometry.'),
+        };
+    }
+    return {
+        sourceFile: container.manifest.source?.file,
+        modelId: container.activeModel.id,
+        meshes,
+    };
+}
+//# sourceMappingURL=open-fai-zip.js.map

package/dist/open-fai-zip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-fai-zip.js","sourceRoot":"","sources":["../src/open-fai-zip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACpE,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AACvG,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AACjF,OAAO,EAAE,aAAa,EAA4B,MAAM,0BAA0B,CAAA;AAClF,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAA;AAM9C,SAAS,OAAO,CAAC,IAAe,EAAE,OAAe,EAAE,MAAgB;IACjE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAA;AAClC,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAuC,KAAiC;IAC3F,MAAM,IAAI,GAAG,KAAK,CAAC,WAAmD,CAAA;IACtE,OAAO,IAAI,IAAI,CAAC,KAAK,CAAM,CAAA;AAC7B,CAAC;AAED;;;;;GAKG;AACH,SAAS,aAAa,CAAC,MAAuB;IAC5C,MAAM,MAAM,GAAoB,EAAE,CAAA;IAClC,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;IAEzD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,KAAK,MAAM,QAAQ,IAAI,OAAO,EAAE,CAAC;YAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;YAC7C,IAAI,KAAK,IAAI,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;gBAChC,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,QAAQ,CAAC,EAAE;oBACjB,SAAS,EAAE,YAAY,CAAe,KAAK,CAAC,SAAS,CAAC;oBACtD,OAAO,EAAE,YAAY,CAAc,KAAK,CAAC,OAAO,CAAC;iBAClD,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAA;IACf,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACnD,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAoE,CAAA;IAC3G,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QAC3C,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,QAAQ;YACd,SAAS,EAAE,YAAY,CAAe,IAAI,CAAC,SAAS,CAAC;YACrD,OAAO,EAAE,YAAY,CAAc,IAAI,CAAC,OAAO,CAAC;SACjD,CAAC,CAAA;IACJ,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,MAAkC;IAChE,OAAO;QACL,KAAK,CAAC,YAAY,CAAC,GAAW;YAC5B,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;YACzB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,IAAI,KAAK,CAAC,6BAA6B,GAAG,mCAAmC,CAAC,CAAA;YACtF,CAAC;YACD,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAA;YAClC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,MAAqB,EAAE,MAAM,EAAE,KAAK,EAAE,CAAA;QAC7D,CAAC;QACD,KAAK,CAAC,WAAW,CAAC,KAAa;YAC7B,MAAM,IAAI,KAAK,CACb,oHAAoH,CACrH,CAAA;QACH,CAAC;QACD,KAAK,CAAC,UAAU,CAAC,GAAW;YAC1B,IAAI,CAAC;gBACH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAA;gBAC5B,IAAI,CAAC,GAAG,CAAC,EAAE;oBAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,GAAG,KAAK,GAAG,CAAC,MAAM,GAAG,CAAC,CAAA;gBAC9F,OAAO,MAAM,GAAG,CAAC,WAAW,EAAE,CAAA;YAChC,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,MAAM,IAAI,KAAK,CAAC,wCAAwC,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;YAC9E,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC;AAED,iEAAiE;AACjE,SAAS,SAAS;IAChB,OAAO,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,gBAAgB,KAAK,UAAU,CAAA;AACvF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,4BAA4B,GAAG,2BAA2B,CAAA;AAEhE,KAAK,UAAU,kBAAkB,CAAC,IAAuB;IACvD,IAAI,SAAS,EAAE,EAAE,CAAC;QAChB,0EAA0E;QAC1E,2EAA2E;QAC3E,2BAA2B;QAC3B,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,CAAC,MAAM,MAAM,CAAC,kBAAkB,CAAC,4BAA4B,CAAC,CAEhF,CAAA;YACD,mBAAmB,CAAC,UAAU,CAAC,wBAAqE,CAAC,CAAA;QACvG,CAAC;QAAC,MAAM,CAAC;YACP,sEAAsE;YACtE,8EAA8E;QAChF,CAAC;QACD,OAAM;IACR,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,EAAE,MAAM,EAAE,WAAW,CAAA;IAC7C,IAAI,CAAC,WAAW;QAAE,OAAM,CAAC,+EAA+E;IACxG,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,WAAW,CAAC,CAAA;QACpC,IAAI,CAAC,GAAG,CAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,WAAW,KAAK,GAAG,CAAC,MAAM,GAAG,CAAC,CAAA;QACrF,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,WAAW,EAAE,CAAC,CAAA;QACzD,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAA;QACrE,mBAAmB,CAAC,KAAK,IAAI,EAAE,CAAC,oBAAoB,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAA;IACtE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,0EAA0E;QAC1E,uEAAuE;QACvE,kEAAkE;QAClE,uEAAuE;QACvE,qEAAqE;QACrE,iEAAiE;QACjE,OAAO,CAAC,IAAI,CAAC,wEAAwE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;IACnG,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,KAAiB,EAAE,IAAuB;IACzE,MAAM,kBAAkB,CAAC,IAAI,CAAC,CAAA;IAC9B,4EAA4E;IAC5E,0EAA0E;IAC1E,yEAAyE;IACzE,yEAAyE;IACzE,iEAAiE;IACjE,MAAM,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAE9B,6EAA6E;IAC7E,oEAAoE;IACpE,IAAI,SAA8B,CAAA;IAClC,IAAI,CAAC;QACH,SAAS,GAAG,aAAa,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAA;IAC9D,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,aAAa,EAAG,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAA;IAC5F,CAAC;IAED,4EAA4E;IAC5E,0EAA0E;IAC1E,2EAA2E;IAC3E,2EAA2E;IAC3E,wEAAwE;IACxE,0EAA0E;IAC1E,iDAAiD;IACjD,MAAM,SAAS,GAAG,MAAM,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IACzD,MAAM,KAAK,GAAG,MAAM,kBAAkB,CAAC;QACrC,MAAM,EAAE,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC;QAChD,aAAa,EAAE,SAAS,CAAC,MAAM;QAC/B,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACpC,CAAC,CAAA;IAEF,6EAA6E;IAC7E,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,IAAI,MAAM,CAAC,CAAA;IAC1D,uEAAuE;IACvE,6EAA6E;IAC7E,4EAA4E;IAC5E,yEAAyE;IACzE,6EAA6E;IAC7E,4EAA4E;IAC5E,yDAAyD;IACzD,qBAAqB,EAAE,CAAA;IACvB,qBAAqB,EAAE,CAAA;IACvB,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,oBAAoB,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;IAC/G,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;IACnE,MAAM,WAAW,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAA;IAC/D,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAA;IAE/D,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;QACpB,OAAO;YACL,UAAU,EAAE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI;YAC3C,OAAO,EAAE,SAAS,CAAC,WAAW,CAAC,EAAE;YACjC,MAAM,EAAE,EAAE;YACV,KAAK,EAAE,OAAO,CACZ,aAAa,EACb,2BAA2B,MAAM,CAAC,QAAQ,CAAC,MAAM,MAAM,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,EAChF,MAAM,CAAC,QAAQ,CAChB;SACF,CAAA;IACH,CAAC;IAED,gEAAgE;IAChE,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC,CAAA;IACpC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO;YACL,UAAU,EAAE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI;YAC3C,OAAO,EAAE,SAAS,CAAC,WAAW,CAAC,EAAE;YACjC,MAAM,EAAE,EAAE;YACV,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE,sDAAsD,CAAC;SACxF,CAAA;IACH,CAAC;IAED,OAAO;QACL,UAAU,EAAE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI;QAC3C,OAAO,EAAE,SAAS,CAAC,WAAW,CAAC,EAAE;QACjC,MAAM;KACP,CAAA;AACH,CAAC","sourcesContent":["/**\n * `openFaiZip` — the reference API of `@faicad/faijs-viewer`.\n *\n * v1 contract:\n * ```\n * openFaiZip(bytes, { wasm: { occtUrl, manifoldUrl, brepkitUrl } })\n * ```\n *\n * Given a project `.fai.zip` byte buffer and the three engine wasm URLs, this\n * reads the container, resolves the active (or requested) model, executes it\n * through `@faicad/faijs` (`createRuntime` over the container's own module\n * graph), and returns structured, tessellated mesh data plus provenance.\n *\n * The return value is host- and rendering-agnostic: arrays of\n * `Float32Array` / `Uint32Array` mesh data, no THREE or DOM in sight. A\n * render-relevant failure never throws — it is surfaced on `result.error` as a\n * structured `FaiViewerError`. Environment/setup failures (e.g. a missing or\n * empty `wasm` URL) throw a code-bearing error from `installEngine`.\n */\n\nimport { createBrowserPorts, createRuntime, isMeshShape } from '@faicad/faijs/browser'\nimport type { AssetResolver, ExecutionResult } from '@faicad/faijs'\nimport { createApiNamespace } from '@faicad/faijs/api/api-namespace'\nimport { mergeSketchNamespace, installSketchSolver, registerSketchSymbols } from '@faicad/faijs-sketch'\nimport { mergeEditorNamespace, registerEditorSymbols } from '@faicad/faijs-extra'\nimport { openContainer, type OpenContainerResult } from '@faicad/faijs/io/fai-zip'\nimport { installEngine } from './engine'\nimport { createViewerLibLoader } from './libs'\nimport type { FaiViewerMesh, FaiViewerError, OpenFaiZipOptions, OpenFaiResult, FaiZipViewerErrorCode } from './types'\n\n/** Error codes emitted by this module (a strict subset of the public union). */\ntype LocalCode = Exclude<FaiZipViewerErrorCode, 'E_WASM_URL'>\n\nfunction failure(code: LocalCode, message: string, detail?: unknown): FaiViewerError {\n  return { code, message, detail }\n}\n\n/**\n * Hand the exact typed-array byte range out to the host without sharing the\n * archive page. Mesh arrays are already `Float32Array` / `Uint32Array`; this\n * isolates the backing buffer so the host (and potential transfer) is safe.\n */\nfunction isolateArray<T extends Float32Array | Uint32Array>(array: Float32Array | Uint32Array): T {\n  const ctor = array.constructor as new (source: ArrayLike<number>) => T\n  return new ctor(array) as T\n}\n\n/**\n * Structure the visible terminals of an execution result into a flat mesh\n * list. Mirrors `packages/demo/main.ts#extractShapes`: hidden terminals\n * (boolean sources, etc.) are never counted; when no explicit terminal exists,\n * the last statement output is used.\n */\nfunction extractMeshes(result: ExecutionResult): FaiViewerMesh[] {\n  const meshes: FaiViewerMesh[] = []\n  const visible = result.terminals.filter((t) => !t.hidden)\n\n  if (visible.length > 0) {\n    for (const terminal of visible) {\n      const shape = result.outputs.get(terminal.id)\n      if (shape && isMeshShape(shape)) {\n        meshes.push({\n          name: terminal.id,\n          positions: isolateArray<Float32Array>(shape.positions),\n          indices: isolateArray<Uint32Array>(shape.indices),\n        })\n      }\n    }\n    return meshes\n  }\n\n  const outputs = Array.from(result.outputs.values())\n  const last = outputs[outputs.length - 1] as { positions?: Float32Array; indices?: Uint32Array } | undefined\n  if (last && last.positions && last.indices) {\n    meshes.push({\n      name: 'output',\n      positions: isolateArray<Float32Array>(last.positions),\n      indices: isolateArray<Uint32Array>(last.indices),\n    })\n  }\n  return meshes\n}\n\n/**\n * Build an asset resolver over the container's `assets/` payload map, backing\n * `cad.loadByKey` and the BREP-asset import op with the exact bytes the archive\n * carries. A missing key throws (mirrors `FetchAssetResolver`'s hard error).\n */\nfunction containerAssetResolver(assets: Record<string, Uint8Array>): AssetResolver {\n  return {\n    async resolveByKey(key: string) {\n      const bytes = assets[key]\n      if (bytes === undefined) {\n        throw new Error(`[faijs-viewer] asset key \"${key}\" is not present in this .fai.zip`)\n      }\n      const copy = new Uint8Array(bytes)\n      return { bytes: copy.buffer as ArrayBuffer, format: 'brp' }\n    },\n    async resolveFile(_path: string) {\n      throw new Error(\n        '[faijs-viewer] resolveFile is unavailable — a .fai.zip is self-contained; load assets by key (`cad.load`) instead.',\n      )\n    },\n    async resolveUrl(url: string) {\n      try {\n        const res = await fetch(url)\n        if (!res.ok) throw new Error(`[faijs-viewer] resolveUrl fetch failed: ${url} (${res.status})`)\n        return await res.arrayBuffer()\n      } catch (e) {\n        throw new Error(`[faijs-viewer] resolveUrl failed for ${url}: ${String(e)}`)\n      }\n    },\n  }\n}\n\n/** Node runner detection (mirrors core's `hasBrowserWindow`). */\nfunction inNodeEnv(): boolean {\n  return typeof window === 'undefined' || typeof window.addEventListener !== 'function'\n}\n\n/**\n * Make the `cad.sketch` / `cad.draw` constraint solver available to the\n * shared, module-global sketch op.\n *\n * The solver lives in `@faicad/faijs-sketch` and is host-injected via\n * `installSketchSolver`, because the planegcs wasm source differs between Node\n * and browser hosts. Node auto-loads the solver (its wasm ships in\n * `@salusoft89/planegcs`); a browser host self-hosts `planegcs.wasm` and passes\n * `opts.sketch.planegcsUrl`. The `E_SKETCH_NO_SOLVER` error is surfaced through\n * `OpenFaiResult.error`, never thrown.\n *\n * The Node-only subpath (specified by `NODE_SKETCH_SOLVER_SPECIFIER`) imports\n * `node:module` via `createRequire`, which a browser-targeted bundler cannot\n * shim for a code-splitting worker/chunk. It is therefore never written as a\n * literal in an `import()` here: `/* @vite-ignore *` plus an opaque specifier\n * leaves resolution entirely to the runtime, so Vite/Rollup/webpack never\n * bundle its node:* into a browser build. A Node host resolves it normally; a\n * browser host never reaches that branch.\n */\nconst NODE_SKETCH_SOLVER_SPECIFIER = '@faicad/faijs-sketch/node'\n\nasync function ensureSketchSolver(opts: OpenFaiZipOptions): Promise<void> {\n  if (inNodeEnv()) {\n    // The /node subpath imports `node:module`, so it must never be statically\n    // imported from a browser-targeted entry. Dynamic import keeps the browser\n    // bundle free of `node:*`.\n    try {\n      const nodeSolver = (await import(/* @vite-ignore */ NODE_SKETCH_SOLVER_SPECIFIER)) as {\n        createNodePlanegcsSolver: unknown\n      }\n      installSketchSolver(nodeSolver.createNodePlanegcsSolver as Parameters<typeof installSketchSolver>[0])\n    } catch {\n      // The solver package is not installed in this process — sketch models\n      // will surface E_SKETCHC_NO_SOLVER. Core mesh-only containers are unaffected.\n    }\n    return\n  }\n  const planegcsUrl = opts?.sketch?.planegcsUrl\n  if (!planegcsUrl) return // browser without a self-hosted solver → E_SKETCHC_NO_SOLVER at execution time\n  try {\n    const res = await fetch(planegcsUrl)\n    if (!res.ok) throw new Error(`planegcs fetch failed: ${planegcsUrl} (${res.status})`)\n    const wasmBytes = new Uint8Array(await res.arrayBuffer())\n    const { createPlanegcsSolver } = await import('@faicad/faijs-sketch')\n    installSketchSolver(async () => createPlanegcsSolver({ wasmBytes }))\n  } catch (e) {\n    // Degrade, mirroring the Node branch: an unreachable solver (offline CDN,\n    // network policy, …) must not sink every `.fai.zip` open — models that\n    // never call `cad.sketch` load fine, and models that do surface a\n    // structured `E_SKETCHC_NO_SOLVER` at execution. Previously this threw\n    // `[faijs-viewer] planegcs solver init failed: …`, failing even pure\n    // `cad.box` containers when the solver URL could not be fetched.\n    console.warn(`[faijs-viewer] planegcs solver unavailable, sketch models will fail: ${String(e)}`)\n  }\n}\n\n/**\n * Open, execute, and tessellate a project `.fai.zip`.\n *\n * @param bytes the container byte array.\n * @param opts the viewer options; `opts.wasm` (three URLs) is required.\n * @returns an `OpenFaiResult` with structured meshes, or an `error`.\n */\nexport async function openFaiZip(bytes: Uint8Array, opts: OpenFaiZipOptions): Promise<OpenFaiResult> {\n  await ensureSketchSolver(opts)\n  // 1. Engine contract. The three wasm urls are mandatory; a missing or empty\n  //    url throws (E_WASM_URL) — this is a caller contract violation, not a\n  //    per-bytes render failure, so it propagates rather than returning an\n  //    `error` result. In a browser the URLs bind occt/manifold wasm; in a\n  //    Node runner they are validated and local engines auto-load.\n  await installEngine(opts.wasm)\n\n  // 2. Reader-side: parse the container (manifest, active model, module graph,\n  //    payloads). Hard container errors become an E_CONTAINER result.\n  let container: OpenContainerResult\n  try {\n    container = openContainer(bytes, { modelId: opts?.modelId })\n  } catch (e) {\n    return { modelId: '', meshes: [], error: failure('E_CONTAINER', (e as Error).message, e) }\n  }\n\n  // 3. Host ports: archive asset authorisation + the container module loader.\n  //    The loader already enumerates/reads the `model/**` module graph. The\n  //    library loader (dynamic side) serves namespace imports of third-party\n  //    faijs packages (`@faicad/faijs-gears`, `@faicad/sheetmetal`, …) — the\n  //    engine calls it lazily at execute time, only for libraries a model\n  //    actually imports. `libs.enabled === false` omits it, so unregistered\n  //    library imports fail as unbound namespaces.\n  const libLoader = await createViewerLibLoader(opts?.libs)\n  const ports = await createBrowserPorts({\n    assets: containerAssetResolver(container.assets),\n    projectLoader: container.loader,\n    ...(libLoader ? { libLoader } : {}),\n  })\n\n  // 4. Assemble a runtime bound to those ports, then execute the active model.\n  const runtime = createRuntime(ports, opts?.mode ?? 'auto')\n  // Real converted containers call `cad.sketch` and editor-extension ops\n  // (`cad.fai_drill` / `cad.group` / `cad.text` / …), which live in the sketch\n  // and faijs-extra libraries rather than core. Re-register the default `cad`\n  // binding with those merged in so such models execute without any import\n  // statement. The symbol-table entries are also registered so static analysis\n  // recognises them. (`@faicad/faijs-draw` is deprecated and deliberately not\n  // merged: a `cad.draw` call fails as an unknown callee.)\n  registerSketchSymbols()\n  registerEditorSymbols()\n  runtime.registerLib('cad', mergeEditorNamespace(mergeSketchNamespace(createApiNamespace())), { default: true })\n  const entryKey = container.activeModel.entry.slice('model/'.length)\n  const entrySource = await container.loader.readSource(entryKey)\n  const result = await runtime.execute(entrySource, { entryKey })\n\n  if (result.failedAt) {\n    return {\n      sourceFile: container.manifest.source?.file,\n      modelId: container.activeModel.id,\n      meshes: [],\n      error: failure(\n        'E_EXECUTION',\n        `Execution failed at op \"${result.failedAt.callee}\": ${result.failedAt.message}`,\n        result.failedAt,\n      ),\n    }\n  }\n\n  // 5. Structure the visible terminals into host-friendly meshes.\n  const meshes = extractMeshes(result)\n  if (meshes.length === 0) {\n    return {\n      sourceFile: container.manifest.source?.file,\n      modelId: container.activeModel.id,\n      meshes: [],\n      error: failure('E_NO_GEOMETRY', 'The model produced no visible, tessellable geometry.'),\n    }\n  }\n\n  return {\n    sourceFile: container.manifest.source?.file,\n    modelId: container.activeModel.id,\n    meshes,\n  }\n}"]}

package/dist/types.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Public types for `@faicad/faijs-viewer`.
+ *
+ * The viewer is the reference consumer of a project `.fai.zip` document. Its
+ * v1 surface is deliberately narrow: read the container, execute the active
+ * (or requested) model, and hand back tessellated mesh data plus the result's
+ * failure information when execution does not complete. Structuring the meshes
+ * on screen is the host's job — this return value never depends on THREE, DOM,
+ * or any GL/rendering library.
+ */
+/** The three engine wasm URLs. All three are required by the v1 contract. */
+export interface FaiZipViewerWasmOptions {
+    /** URL of the occt-wasm `.wasm` (BREP execution chain engine). */
+    occtUrl: string;
+    /** URL of the manifold-3d `.wasm` (mesh boolean/CSG engine). */
+    manifoldUrl: string;
+    /** URL of the brepkit `brepkit_wasm_bg.wasm` (secondary BREP engine). */
+    brepkitUrl: string;
+}
+/**
+ * Options for the `cad.sketch` constraint solver that real FreeCAD-converted
+ * `.fai.zip` models require.
+ *
+ * The sketch op folds `@faicad/faijs-sketch` into the `cad` namespace and needs
+ * the planegcs constraint solver. In a Node runner the solver auto-loads its
+ * wasm from the installed `@salusoft89/planegcs` package; a browser host must
+ * self-host the `planegcs.wasm` binary and supply its URL here. When running in
+ * a browser without `planegcsUrl`, sketch-based models fail with
+ * `E_SKETCHC_NO_SOLVER` (reported through `OpenFaiResult.error`).
+ */
+export interface SketchSolverOptions {
+    /** Browser-only: URL of the self-hosted `planegcs.wasm` constraint solver. */
+    planegcsUrl?: string;
+}
+/**
+ * Dynamic-loading configuration for third-party faijs libraries.
+ *
+ * The engine already loads a model's namespace imports on demand
+ * (`autoLoadLibsFromImports`): a script like
+ * `import * as gears from "@faicad/faijs-gears"` triggers a lazy
+ * `libLoader.loadLib(packageName)` at execute time, and only for the libraries
+ * that model actually imports. This option configures the loader the viewer
+ * builds for that purpose — preset libraries (core, sketch, faijs-extra, merged
+ * into the default `cad` namespace) never go through it.
+ *
+ * Loader dispatch follows the environment: a browser host dynamic-imports from
+ * the CDN (jsDelivr), a Node host resolves installed packages. Loading or
+ * version-verification failures surface as structured `E_EXECUTION`
+ * (`failedAt`) on `OpenFaiResult.error`, never a throw.
+ */
+export interface FaiViewerLibsOptions {
+    /**
+     * Master switch for dynamic loading of non-preset libraries. Default `true`.
+     * `false` removes the loader entirely, so an import of an unregistered
+     * library fails with an unbound-namespace execution error.
+     */
+    enabled?: boolean;
+    /**
+     * CDN base for browser hosts (must end in `/`). Defaults to the jsDelivr npm
+     * mirror (`https://cdn.jsdelivr.net/npm/`).
+     */
+    cdnBase?: string;
+    /**
+     * Exact version pins: npm package name → version. Browser hosts build
+     * `+esm` direct links from these. Pin to the host engine's version line —
+     * `registerLib` rejects a library whose `contractVersion` does not match.
+     */
+    versions?: Record<string, string>;
+    /** Aliases mapping script specifiers to npm package names (`gears` → `@faicad/faijs-gears`). */
+    aliases?: Record<string, string>;
+    /**
+     * Injectable dynamic-import implementation (tests, or hosts with a custom
+     * loading channel). Defaults to the native dynamic `import()`.
+     */
+    importModule?: (url: string) => Promise<unknown>;
+}
+/** Options for {@link openFaiZip}. Only `wasm` is required. */
+export interface OpenFaiZipOptions {
+    /** The three engine wasm URLs; each must be a non-empty string. */
+    wasm: FaiZipViewerWasmOptions;
+    /** Execute this specific model id. Defaults to container `active`, else `models[0]`. */
+    modelId?: string;
+    /** Execution mode. Default `'auto'` (static BREP/mesh dispatch). */
+    mode?: 'auto' | 'brep' | 'mesh';
+    /** Execution timeout in milliseconds. Omitted = engine default. */
+    executionTimeoutMs?: number;
+    /**
+     * Optional constraint-solver config for models that use `cad.sketch`.
+     * Node auto-loads the solver; a browser host passes
+     * `planegcsUrl` to self-host the `planegcs.wasm` binary.
+     */
+    sketch?: SketchSolverOptions;
+    /**
+     * Optional dynamic-loading config for third-party faijs libraries (e.g.
+     * `@faicad/faijs-gears`, `@faicad/sheetmetal`). Omitted = dynamic loading
+     * enabled with unrestricted package set (see `FaiViewerLibsOptions`).
+     */
+    libs?: FaiViewerLibsOptions;
+}
+/** One tessellated mesh returned by {@link openFaiView}. */
+export interface FaiViewerMesh {
+    /** Part/terminal name this mesh belongs to. */
+    name: string;
+    /** Interleaved `x,y,z` triangle vertices. */
+    positions: Float32Array;
+    /** Triangle indices (groups of three) into `positions`. */
+    indices: Uint32Array;
+}
+/** Structured failure of a viewer operation. */
+export interface FaiViewerError {
+    code: FaiZipViewerErrorCode;
+    message: string;
+    /** Underlying engine error, when the failure was thrown. */
+    detail?: unknown;
+}
+/**
+ * Structured resolution code for a viewer failure. Reported through
+ * {@link OpenFaiResult.error} rather than thrown, so hosts get an inspectable
+ * result object.
+ */
+export type FaiZipViewerErrorCode = 
+/** The wasm options were missing or one of the three urls was empty. */
+'E_WASM_URL'
+/** The `.fai.zip` bytes failed container validation / read caps. */
+ | 'E_CONTAINER'
+/** The model graph failed to execute (see `detail`). */
+ | 'E_EXECUTION'
+/** The model produced no visible mesh. */
+ | 'E_NO_GEOMETRY';
+/** Result of {@link openFaiView}. A failure is reported via `error`, not a throw (except wasm/environment errors, which throw). */
+export interface OpenFaiResult {
+    /** Source file name recorded in conversion provenance, when present. */
+    sourceFile?: string;
+    /** The executed model id (after active model defaulting). */
+    modelId: string;
+    /** The visible, structured mesh list. */
+    meshes: FaiViewerMesh[];
+    /** Set when reading or executing fails; see `FaiViewerError`. */
+    error?: FaiViewerError;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,6EAA6E;AAC7E,MAAM,WAAW,uBAAuB;IACtC,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAA;IACf,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,gGAAgG;IAChG,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACjD;AAED,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,IAAI,EAAE,uBAAuB,CAAA;IAC7B,wFAAwF;IACxF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;IAC/B,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,mBAAmB,CAAA;IAC5B;;;;OAIG;IACH,IAAI,CAAC,EAAE,oBAAoB,CAAA;CAC5B;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ,6CAA6C;IAC7C,SAAS,EAAE,YAAY,CAAA;IACvB,2DAA2D;IAC3D,OAAO,EAAE,WAAW,CAAA;CACrB;AAED,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,qBAAqB,CAAA;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB;AAC/B,wEAAwE;AACtE,YAAY;AACd,oEAAoE;GAClE,aAAa;AACf,wDAAwD;GACtD,aAAa;AACf,0CAA0C;GACxC,eAAe,CAAA;AAEnB,mIAAmI;AACnI,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAA;IACf,yCAAyC;IACzC,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,iEAAiE;IACjE,KAAK,CAAC,EAAE,cAAc,CAAA;CACvB"}

package/dist/types.js

@@ -0,0 +1,12 @@
+/**
+ * Public types for `@faicad/faijs-viewer`.
+ *
+ * The viewer is the reference consumer of a project `.fai.zip` document. Its
+ * v1 surface is deliberately narrow: read the container, execute the active
+ * (or requested) model, and hand back tessellated mesh data plus the result's
+ * failure information when execution does not complete. Structuring the meshes
+ * on screen is the host's job — this return value never depends on THREE, DOM,
+ * or any GL/rendering library.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG","sourcesContent":["/**\n * Public types for `@faicad/faijs-viewer`.\n *\n * The viewer is the reference consumer of a project `.fai.zip` document. Its\n * v1 surface is deliberately narrow: read the container, execute the active\n * (or requested) model, and hand back tessellated mesh data plus the result's\n * failure information when execution does not complete. Structuring the meshes\n * on screen is the host's job — this return value never depends on THREE, DOM,\n * or any GL/rendering library.\n */\n\n/** The three engine wasm URLs. All three are required by the v1 contract. */\nexport interface FaiZipViewerWasmOptions {\n  /** URL of the occt-wasm `.wasm` (BREP execution chain engine). */\n  occtUrl: string\n  /** URL of the manifold-3d `.wasm` (mesh boolean/CSG engine). */\n  manifoldUrl: string\n  /** URL of the brepkit `brepkit_wasm_bg.wasm` (secondary BREP engine). */\n  brepkitUrl: string\n}\n\n/**\n * Options for the `cad.sketch` constraint solver that real FreeCAD-converted\n * `.fai.zip` models require.\n *\n * The sketch op folds `@faicad/faijs-sketch` into the `cad` namespace and needs\n * the planegcs constraint solver. In a Node runner the solver auto-loads its\n * wasm from the installed `@salusoft89/planegcs` package; a browser host must\n * self-host the `planegcs.wasm` binary and supply its URL here. When running in\n * a browser without `planegcsUrl`, sketch-based models fail with\n * `E_SKETCHC_NO_SOLVER` (reported through `OpenFaiResult.error`).\n */\nexport interface SketchSolverOptions {\n  /** Browser-only: URL of the self-hosted `planegcs.wasm` constraint solver. */\n  planegcsUrl?: string\n}\n\n/**\n * Dynamic-loading configuration for third-party faijs libraries.\n *\n * The engine already loads a model's namespace imports on demand\n * (`autoLoadLibsFromImports`): a script like\n * `import * as gears from \"@faicad/faijs-gears\"` triggers a lazy\n * `libLoader.loadLib(packageName)` at execute time, and only for the libraries\n * that model actually imports. This option configures the loader the viewer\n * builds for that purpose — preset libraries (core, sketch, faijs-extra, merged\n * into the default `cad` namespace) never go through it.\n *\n * Loader dispatch follows the environment: a browser host dynamic-imports from\n * the CDN (jsDelivr), a Node host resolves installed packages. Loading or\n * version-verification failures surface as structured `E_EXECUTION`\n * (`failedAt`) on `OpenFaiResult.error`, never a throw.\n */\nexport interface FaiViewerLibsOptions {\n  /**\n   * Master switch for dynamic loading of non-preset libraries. Default `true`.\n   * `false` removes the loader entirely, so an import of an unregistered\n   * library fails with an unbound-namespace execution error.\n   */\n  enabled?: boolean\n  /**\n   * CDN base for browser hosts (must end in `/`). Defaults to the jsDelivr npm\n   * mirror (`https://cdn.jsdelivr.net/npm/`).\n   */\n  cdnBase?: string\n  /**\n   * Exact version pins: npm package name → version. Browser hosts build\n   * `+esm` direct links from these. Pin to the host engine's version line —\n   * `registerLib` rejects a library whose `contractVersion` does not match.\n   */\n  versions?: Record<string, string>\n  /** Aliases mapping script specifiers to npm package names (`gears` → `@faicad/faijs-gears`). */\n  aliases?: Record<string, string>\n  /**\n   * Injectable dynamic-import implementation (tests, or hosts with a custom\n   * loading channel). Defaults to the native dynamic `import()`.\n   */\n  importModule?: (url: string) => Promise<unknown>\n}\n\n/** Options for {@link openFaiZip}. Only `wasm` is required. */\nexport interface OpenFaiZipOptions {\n  /** The three engine wasm URLs; each must be a non-empty string. */\n  wasm: FaiZipViewerWasmOptions\n  /** Execute this specific model id. Defaults to container `active`, else `models[0]`. */\n  modelId?: string\n  /** Execution mode. Default `'auto'` (static BREP/mesh dispatch). */\n  mode?: 'auto' | 'brep' | 'mesh'\n  /** Execution timeout in milliseconds. Omitted = engine default. */\n  executionTimeoutMs?: number\n  /**\n   * Optional constraint-solver config for models that use `cad.sketch`.\n   * Node auto-loads the solver; a browser host passes\n   * `planegcsUrl` to self-host the `planegcs.wasm` binary.\n   */\n  sketch?: SketchSolverOptions\n  /**\n   * Optional dynamic-loading config for third-party faijs libraries (e.g.\n   * `@faicad/faijs-gears`, `@faicad/sheetmetal`). Omitted = dynamic loading\n   * enabled with unrestricted package set (see `FaiViewerLibsOptions`).\n   */\n  libs?: FaiViewerLibsOptions\n}\n\n/** One tessellated mesh returned by {@link openFaiView}. */\nexport interface FaiViewerMesh {\n  /** Part/terminal name this mesh belongs to. */\n  name: string\n  /** Interleaved `x,y,z` triangle vertices. */\n  positions: Float32Array\n  /** Triangle indices (groups of three) into `positions`. */\n  indices: Uint32Array\n}\n\n/** Structured failure of a viewer operation. */\nexport interface FaiViewerError {\n  code: FaiZipViewerErrorCode\n  message: string\n  /** Underlying engine error, when the failure was thrown. */\n  detail?: unknown\n}\n\n/**\n * Structured resolution code for a viewer failure. Reported through\n * {@link OpenFaiResult.error} rather than thrown, so hosts get an inspectable\n * result object.\n */\nexport type FaiZipViewerErrorCode =\n  /** The wasm options were missing or one of the three urls was empty. */\n  | 'E_WASM_URL'\n  /** The `.fai.zip` bytes failed container validation / read caps. */\n  | 'E_CONTAINER'\n  /** The model graph failed to execute (see `detail`). */\n  | 'E_EXECUTION'\n  /** The model produced no visible mesh. */\n  | 'E_NO_GEOMETRY'\n\n/** Result of {@link openFaiView}. A failure is reported via `error`, not a throw (except wasm/environment errors, which throw). */\nexport interface OpenFaiResult {\n  /** Source file name recorded in conversion provenance, when present. */\n  sourceFile?: string\n  /** The executed model id (after active model defaulting). */\n  modelId: string\n  /** The visible, structured mesh list. */\n  meshes: FaiViewerMesh[]\n  /** Set when reading or executing fails; see `FaiViewerError`. */\n  error?: FaiViewerError\n}"]}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@faicad/faijs-viewer",
+  "version": "0.29.3",
+  "description": "Read + execute + tessellate a project .fai.zip for any third-party host. v1 API: openFaiZip(bytes, { wasm: { occtUrl, manifoldUrl, brepkitUrl } })",
+  "keywords": [
+    "faijs",
+    "fai",
+    "zip",
+    "viewer",
+    "cad",
+    "occt",
+    "manifold",
+    "three"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitcode.com/Faicad/faijs.git"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "NOTICE",
+    "LICENSE"
+  ],
+  "dependencies": {},
+  "peerDependencies": {
+    "@faicad/faijs": "^0.29.0",
+    "@faicad/faijs-extra": "^0.29.0",
+    "@faicad/faijs-sketch": "^0.29.0",
+    "occt-wasm": "3.8.4",
+    "three": "^0.162.0 || ^0.184.0"
+  },
+  "devDependencies": {
+    "@faicad/faijs": "file:../core",
+    "@faicad/faijs-extra": "file:../faijs-extra",
+    "@faicad/faijs-gears": "file:../faijs-gears",
+    "@types/three": "^0.184.1",
+    "occt-wasm": "^3.8.4",
+    "three": "^0.184.0",
+    "typescript": "*",
+    "vitest": "*"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/fix-import-extensions.mjs dist",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src"
+  }
+}