fluidcad 0.0.34 → 0.0.36

package/server/dist/index.js

@@ -1,12 +1,14 @@
-import crypto from 'crypto';
 import fs from 'fs';
 import http from 'http';
 import path from 'path';
 import express from 'express';
-import { WebSocketServer, WebSocket } from 'ws';
 import { FluidCadServer } from "./fluidcad-server.js";
+import { createServerCore } from "./server-core.js";
 import { createPropertiesRouter } from "./routes/properties.js";
-import { createActionsRouter } from "./routes/actions.js";
+import { createParamsRouter } from "./routes/params.js";
+import { createHitTestRouter } from "./routes/hit-test.js";
+import { createTimelineRouter } from "./routes/timeline.js";
+import { createSketchEditsRouter } from "./routes/sketch-edits.js";
 import { createExportRouter } from "./routes/export.js";
 import { createScreenshotRouter } from "./routes/screenshot.js";
 import { createPreferencesRouter } from "./routes/preferences.js";
@@ -15,6 +17,7 @@ import { createSceneRouter } from "./routes/scene.js";
 import { createEditorRouter, DirtyBufferState } from "./routes/editor.js";
 import { createRenderRouter } from "./routes/render.js";
 import { createLintRouter } from "./routes/lint.js";
+import { createPackRouter } from "./routes/pack.js";
 import { normalizePath } from "./normalize-path.js";
 import { writeInstanceFile, deleteInstanceFile } from "./instance-file.js";
 import { addInstance, removeInstance } from "./global-registry.js";
@@ -53,20 +56,32 @@ const fluidCadServer = new FluidCadServer();
 const dirtyBufferState = new DirtyBufferState();
 const app = express();
 app.use(express.json({ limit: '50mb' }));
+// ---------------------------------------------------------------------------
+// HTTP + WebSocket server (set up early so routes can reference its helpers)
+// ---------------------------------------------------------------------------
+const httpServer = http.createServer(app);
+const core = createServerCore(httpServer);
+const broadcastToUI = core.broadcastToUI;
+const requestScreenshot = core.requestScreenshot;
+const getLastCameraState = core.getLastCameraState;
 app.use('/api', createHealthRouter({
     version: PACKAGE_VERSION,
     workspacePath: WORKSPACE_PATH,
     startedAt: STARTED_AT,
 }));
 app.use('/api', createPropertiesRouter(fluidCadServer));
-app.use('/api', createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, WORKSPACE_PATH));
+app.use('/api', createParamsRouter(fluidCadServer, sendToExtension, broadcastToUI));
+app.use('/api', createHitTestRouter(fluidCadServer));
+app.use('/api', createTimelineRouter(fluidCadServer, sendToExtension, broadcastToUI));
+app.use('/api', createSketchEditsRouter(fluidCadServer, sendToExtension, WORKSPACE_PATH));
 app.use('/api', createExportRouter(fluidCadServer, WORKSPACE_PATH));
 app.use('/api', createScreenshotRouter(requestScreenshot));
 app.use('/api', createPreferencesRouter());
-app.use('/api', createSceneRouter(fluidCadServer, () => lastCameraState));
+app.use('/api', createSceneRouter(fluidCadServer, getLastCameraState));
 app.use('/api', createEditorRouter(dirtyBufferState));
 app.use('/api', createRenderRouter((fileName, code) => runLiveRender(fileName, code)));
 app.use('/api', createLintRouter());
+app.use('/api', createPackRouter(fluidCadServer, WORKSPACE_PATH, PACKAGE_VERSION, getLastCameraState));
 // Static files — serve UI build, with SPA fallback
 app.use(express.static(UI_DIST, {
     setHeaders(res, filePath) {
@@ -80,121 +95,12 @@ app.get('*splat', (_req, res) => {
     res.sendFile(path.join(UI_DIST, 'index.html'));
 });
 // ---------------------------------------------------------------------------
-// HTTP + WebSocket server
-// ---------------------------------------------------------------------------
-const httpServer = http.createServer(app);
-const wss = new WebSocketServer({ server: httpServer });
-const uiClients = new Set();
-let lastSceneMessage = null;
-let initCompleteMessage = null;
-let lastCameraState = null;
-function broadcastToUI(msg) {
-    const data = JSON.stringify(msg);
-    if (msg.type === 'scene-rendered') {
-        lastSceneMessage = data;
-    }
-    if (msg.type === 'init-complete') {
-        initCompleteMessage = data;
-    }
-    for (const client of uiClients) {
-        if (client.readyState === WebSocket.OPEN) {
-            client.send(data);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Screenshot request/response coordination
-// ---------------------------------------------------------------------------
-const SCREENSHOT_TIMEOUT_MS = 10_000;
-const pendingScreenshots = new Map();
-function requestScreenshot(options) {
-    return new Promise((resolve, reject) => {
-        if (uiClients.size === 0) {
-            reject(new Error('No UI client connected.'));
-            return;
-        }
-        const requestId = crypto.randomUUID();
-        const timeout = setTimeout(() => {
-            pendingScreenshots.delete(requestId);
-            reject(new Error('Screenshot request timed out.'));
-        }, SCREENSHOT_TIMEOUT_MS);
-        pendingScreenshots.set(requestId, {
-            resolve(data) {
-                clearTimeout(timeout);
-                pendingScreenshots.delete(requestId);
-                resolve(data);
-            },
-            reject(err) {
-                clearTimeout(timeout);
-                pendingScreenshots.delete(requestId);
-                reject(err);
-            },
-        });
-        broadcastToUI({ type: 'take-screenshot', requestId, options });
-    });
-}
-function handleUIMessage(raw) {
-    let msg;
-    try {
-        msg = JSON.parse(raw);
-    }
-    catch {
-        return;
-    }
-    if (msg.type === 'screenshot-result' && msg.requestId) {
-        const pending = pendingScreenshots.get(msg.requestId);
-        if (!pending) {
-            return;
-        }
-        if (msg.success && msg.data) {
-            pending.resolve(Buffer.from(msg.data, 'base64'));
-        }
-        else {
-            pending.reject(new Error(msg.error || 'Screenshot failed.'));
-        }
-        return;
-    }
-    if (msg.type === 'camera-state') {
-        // Trust UI structure — we own both ends. Just shape-check arrays.
-        if (Array.isArray(msg.position) && msg.position.length === 3 &&
-            Array.isArray(msg.target) && msg.target.length === 3 &&
-            Array.isArray(msg.up) && msg.up.length === 3) {
-            lastCameraState = {
-                type: 'camera-state',
-                position: msg.position,
-                target: msg.target,
-                up: msg.up,
-                projection: msg.projection === 'perspective' ? 'perspective' : 'orthographic',
-            };
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// WebSocket connections
-// ---------------------------------------------------------------------------
-wss.on('connection', (ws) => {
-    uiClients.add(ws);
-    // Replay init-complete and last scene to newly connected UI client
-    if (initCompleteMessage) {
-        ws.send(initCompleteMessage);
-    }
-    if (lastSceneMessage) {
-        ws.send(lastSceneMessage);
-    }
-    ws.on('message', (data) => {
-        handleUIMessage(String(data));
-    });
-    ws.on('close', () => {
-        uiClients.delete(ws);
-    });
-});
-// ---------------------------------------------------------------------------
 // IPC message handling — extension host → server
 // ---------------------------------------------------------------------------
 let currentFile = null;
 let renderVersion = 0;
 const lastSceneByFile = new Map();
-function emitSuccess(version, absPath, result, rollbackStop, breakpointHit) {
+function emitSuccess(version, absPath, result, rollbackStop, breakpointHit, params) {
     lastSceneByFile.set(absPath, { result, rollbackStop });
     fluidCadServer.setCompileError(null);
     sendToExtension({
@@ -209,6 +115,7 @@ function emitSuccess(version, absPath, result, rollbackStop, breakpointHit) {
         absPath,
         rollbackStop,
         breakpointHit,
+        params,
     });
     broadcastToUI({ type: 'render-version', version, state: 'end', absPath });
 }
@@ -277,7 +184,7 @@ async function runLiveRender(fileName, code) {
         if (!data) {
             return { state: 'no-scene-manager', version: myVersion, durationMs: Date.now() - startedAt };
         }
-        emitSuccess(myVersion, data.absPath, data.result, data.rollbackStop, data.breakpointHit);
+        emitSuccess(myVersion, data.absPath, data.result, data.rollbackStop, data.breakpointHit, data.params);
         return {
             state: 'rendered',
             version: myVersion,
@@ -312,7 +219,7 @@ async function handleExtensionMessage(msg) {
                         return;
                     }
                     if (data) {
-                        emitSuccess(myVersion, data.absPath, data.result, data.rollbackStop, data.breakpointHit);
+                        emitSuccess(myVersion, data.absPath, data.result, data.rollbackStop, data.breakpointHit, data.params);
                     }
                 }
                 catch (err) {

package/server/dist/model-package/capture-params.d.ts

@@ -0,0 +1,19 @@
+import type { ParamDefinition } from '../../../lib/dist/index.js';
+/**
+ * Render a model once, headlessly, and return its full parameter schema.
+ *
+ * Param *definitions* (type, default, current value, constraints) only exist
+ * after the engine runs the model — the packer/bundler never executes user
+ * code, so a static manifest can carry override values at most. `fluidcad
+ * publish` calls this to capture the real schema and embeds it in the manifest
+ * (`paramDefinitions`), so the hub can build param forms without a live worker.
+ *
+ * The render doubles as a build gate: a compile/runtime error in the model
+ * propagates out of here, failing the publish before any draft is created.
+ *
+ * Side-effect-free at import time — it constructs its own `FluidCadServer`
+ * (which boots OC wasm + a Vite SSR pipeline) and tears the Vite server down
+ * before returning so a one-shot CLI process can exit. Import this (or use
+ * `fluidcad/server/api`), NOT `fluidcad/server`, which boots the desktop binary.
+ */
+export declare function captureParamDefinitions(entryPath: string, workspacePath: string): Promise<ParamDefinition[]>;

package/server/dist/model-package/capture-params.js

@@ -0,0 +1,42 @@
+import { LocalSceneHost } from "../host/local-scene-host.js";
+import { FluidCadServer } from "../fluidcad-server.js";
+/**
+ * Render a model once, headlessly, and return its full parameter schema.
+ *
+ * Param *definitions* (type, default, current value, constraints) only exist
+ * after the engine runs the model — the packer/bundler never executes user
+ * code, so a static manifest can carry override values at most. `fluidcad
+ * publish` calls this to capture the real schema and embeds it in the manifest
+ * (`paramDefinitions`), so the hub can build param forms without a live worker.
+ *
+ * The render doubles as a build gate: a compile/runtime error in the model
+ * propagates out of here, failing the publish before any draft is created.
+ *
+ * Side-effect-free at import time — it constructs its own `FluidCadServer`
+ * (which boots OC wasm + a Vite SSR pipeline) and tears the Vite server down
+ * before returning so a one-shot CLI process can exit. Import this (or use
+ * `fluidcad/server/api`), NOT `fluidcad/server`, which boots the desktop binary.
+ */
+export async function captureParamDefinitions(entryPath, workspacePath) {
+    const host = new LocalSceneHost();
+    const server = new FluidCadServer(host);
+    try {
+        await server.init(workspacePath);
+        const rendered = await server.processFile(entryPath);
+        if (!rendered) {
+            throw new Error('The engine did not initialize — is there an init.js at the workspace root? ' +
+                'Run `fluidcad init` to scaffold one.');
+        }
+        return rendered.params ?? [];
+    }
+    finally {
+        // LocalSceneHost.init() starts a Vite dev server that keeps the event loop
+        // alive; close it so the CLI can exit after a single render.
+        try {
+            await host.server?.close();
+        }
+        catch {
+            /* best-effort teardown */
+        }
+    }
+}

package/server/dist/model-package/pack.d.ts

@@ -0,0 +1,23 @@
+import type { ParamDefinition } from '../../../lib/dist/index.js';
+import { type ModelPackageCamera, type ModelPackageManifest, type ParamValue } from './types.ts';
+export interface PackInputs {
+    entryPath: string;
+    workspacePath: string;
+    fluidcadVersion: string;
+    name?: string;
+    description?: string;
+    paramOverrides?: Record<string, ParamValue>;
+    /**
+     * Full param schema to embed in the manifest. `fluidcad publish` renders the
+     * model once to capture this (see `capture-params.ts`); `fluidcad pack` omits
+     * it. Kept as an input (rather than rendering inside `packModel`) so packing
+     * stays a pure, engine-free file producer.
+     */
+    paramDefinitions?: ParamDefinition[];
+    camera?: ModelPackageCamera;
+}
+export interface PackResult {
+    manifest: ModelPackageManifest;
+    zip: Buffer;
+}
+export declare function packModel(inputs: PackInputs): Promise<PackResult>;

package/server/dist/model-package/pack.js

@@ -0,0 +1,230 @@
+import { build } from 'esbuild';
+import { readFile, readdir, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { basename, extname, join, relative } from 'path';
+import JSZip from 'jszip';
+import ignoreFactory from 'ignore';
+import { normalizePath } from "../normalize-path.js";
+import { getBlockedNodeModule } from "../host/blocked-imports.js";
+import { ASSETS_PREFIX, BUNDLE_FILENAME, FILES_PREFIX, MANIFEST_FILENAME, } from "./types.js";
+/**
+ * Reject Node.js builtins that are off-limits in `.fluid.js` code. Same
+ * defence the LocalSceneHost applies at SSR transform time; here it runs
+ * at pack time so the produced bundle is verified before it ships.
+ */
+function blockNodeBuiltinsPlugin() {
+    return {
+        name: 'block-node-builtins',
+        setup(b) {
+            b.onResolve({ filter: /.*/ }, (args) => {
+                const blocked = getBlockedNodeModule(args.path);
+                if (!blocked)
+                    return null;
+                return {
+                    errors: [
+                        {
+                            text: `Module "${args.path}" is not allowed in FluidCAD scripts. ` +
+                                `Access to Node.js "${blocked}" module is restricted for security.`,
+                        },
+                    ],
+                };
+            });
+        },
+    };
+}
+/**
+ * Bundle the model into a single ES module via a virtual wrapper. When
+ * `init.js` exists it runs FIRST (its side effects set up the engine) and
+ * its `default` export is forwarded as the bundle's `default` export so
+ * the hub-side loader has a handle on the SceneManager. When there's no
+ * init.js, the entry is bundled directly.
+ *
+ * The bundle is self-contained — every transitively-imported workspace file
+ * is inlined (npm deps too). The original file text the hub displays comes
+ * from the `files/` tree, not from this bundle.
+ */
+async function bundleModel(entryAbs, initAbs, workspaceAbs) {
+    const entryRel = './' + normalizePath(relative(workspaceAbs, entryAbs));
+    const initRel = initAbs ? './' + normalizePath(relative(workspaceAbs, initAbs)) : null;
+    const wrapperSource = initRel
+        ? `import sceneManager from ${JSON.stringify(initRel)};\n` +
+            `import ${JSON.stringify(entryRel)};\n` +
+            `export default sceneManager;\n`
+        : `export * from ${JSON.stringify(entryRel)};\n`;
+    const result = await build({
+        stdin: {
+            contents: wrapperSource,
+            resolveDir: workspaceAbs,
+            sourcefile: '__fluidpkg_entry__.js',
+            loader: 'js',
+        },
+        format: 'esm',
+        bundle: true,
+        write: false,
+        platform: 'node',
+        external: ['fluidcad', 'fluidcad/*'],
+        plugins: [blockNodeBuiltinsPlugin()],
+        logLevel: 'silent',
+    });
+    if (result.errors.length) {
+        throw new Error(result.errors.map((e) => e.text).join('\n'));
+    }
+    if (!result.outputFiles || result.outputFiles.length === 0) {
+        throw new Error(`esbuild produced no output for ${entryAbs}`);
+    }
+    return result.outputFiles[0].text;
+}
+async function collectImportAssetPaths(workspacePath) {
+    // STEP imports are stored as cached `.brep` (+ `.colors.json` sidecar) under
+    // `imports/` — the engine reads those at render time, not the original
+    // `.step` files. Walk the whole workspace so any `.brep`/`.colors.json` is
+    // captured; also include any `.step`/`.stp` originals the user kept around
+    // (for display in the hub's file viewer; the engine ignores them).
+    const out = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry === 'node_modules' || entry === '.git' || entry === 'dist')
+                continue;
+            const full = join(dir, entry);
+            let st;
+            try {
+                st = await stat(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                await walk(full);
+            }
+            else if (st.isFile()) {
+                const lower = entry.toLowerCase();
+                const ext = extname(lower);
+                const isColors = lower.endsWith('.colors.json');
+                if (ext === '.step' || ext === '.stp' || ext === '.brep' || isColors) {
+                    out.push(normalizePath(relative(workspacePath, full)));
+                }
+            }
+        }
+    }
+    await walk(workspacePath);
+    return out.sort();
+}
+// Enforced on top of any `.gitignore`: dependency trees, prior pack outputs
+// (the latter would otherwise recurse into the next pack), and `fluidcad.json`
+// (the local hub binding — model id + name — which the hub already owns and
+// should never ship as model source). `node_modules` is also pruned during the
+// walk for speed. Hidden dot-entries are excluded by the walk directly (see
+// below), so VCS metadata (`.git`) and secrets (`.env`) need no pattern here.
+const ALWAYS_EXCLUDE = ['node_modules', '*.fluidpkg', 'fluidcad.json'];
+// `ignore` ships a CJS `module.exports = factory`, but its bundled types use
+// `export default`, which loses the call signature under `module: nodenext`.
+// Pin the factory's real signature; the runtime value is the callable factory.
+const ignore = ignoreFactory;
+/**
+ * Pack v2 file selection: every non-ignored file in the workspace, so the hub
+ * ships the whole project (README, package.json, configs, sources) — not just
+ * the entry's transitive imports.
+ *
+ * A root `.gitignore` is honored via the mature `ignore` package (same matcher
+ * eslint/prettier use). Hidden dot-entries (names starting with `.`) are ALWAYS
+ * excluded — `.git`, `.env`, and tool/editor state like `.claude`/`.vscode` are
+ * never model content and may hold secrets — regardless of whether they're
+ * gitignored. `node_modules` is pruned too; `ALWAYS_EXCLUDE` (prior `.fluidpkg`
+ * outputs) is enforced on top of any `.gitignore`. We walk and filter per-file
+ * rather than pruning ignored directories so negation rules (`!keep/this`) work.
+ */
+async function collectWorkspaceFiles(workspaceAbs) {
+    const gitignorePath = join(workspaceAbs, '.gitignore');
+    const hasGitignore = existsSync(gitignorePath);
+    const ig = ignore().add(ALWAYS_EXCLUDE);
+    if (hasGitignore) {
+        ig.add(await readFile(gitignorePath, 'utf8'));
+    }
+    const out = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const name = entry.name;
+            // Skip dependency trees and ALL hidden dot-entries (VCS metadata, secrets,
+            // editor/tool state) — never packaged, gitignore or not.
+            if (name === 'node_modules' || name.startsWith('.'))
+                continue;
+            const full = join(dir, name);
+            const rel = normalizePath(relative(workspaceAbs, full));
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else if (entry.isFile()) {
+                if (ig.ignores(rel))
+                    continue;
+                out.push(rel);
+            }
+        }
+    }
+    await walk(workspaceAbs);
+    return out.sort();
+}
+export async function packModel(inputs) {
+    const entryAbs = normalizePath(inputs.entryPath);
+    const workspaceAbs = normalizePath(inputs.workspacePath);
+    const initPath = join(workspaceAbs, 'init.js');
+    const initAbs = existsSync(initPath) ? normalizePath(initPath) : null;
+    const bundle = await bundleModel(entryAbs, initAbs, workspaceAbs);
+    const assetPaths = await collectImportAssetPaths(workspaceAbs);
+    // The full human tree, minus anything already shipped under assets/ (so large
+    // brep/STEP bytes aren't duplicated). assets + files together = the package.
+    const assetSet = new Set(assetPaths);
+    const filePaths = (await collectWorkspaceFiles(workspaceAbs)).filter((p) => !assetSet.has(p));
+    const entryRelative = normalizePath(relative(workspaceAbs, entryAbs));
+    const defaultName = basename(entryAbs).replace(/\.fluid\.js$/i, '');
+    const manifest = {
+        schemaVersion: 2,
+        name: inputs.name ?? defaultName,
+        fluidcadVersion: inputs.fluidcadVersion,
+        createdAt: new Date().toISOString(),
+        entry: entryRelative,
+        hasInit: !!initAbs,
+        assets: assetPaths,
+        files: filePaths,
+    };
+    if (inputs.description)
+        manifest.description = inputs.description;
+    if (inputs.paramOverrides && Object.keys(inputs.paramOverrides).length > 0) {
+        manifest.params = inputs.paramOverrides;
+    }
+    if (inputs.paramDefinitions && inputs.paramDefinitions.length > 0) {
+        manifest.paramDefinitions = inputs.paramDefinitions;
+    }
+    if (inputs.camera)
+        manifest.camera = inputs.camera;
+    const zip = new JSZip();
+    zip.file(MANIFEST_FILENAME, JSON.stringify(manifest, null, 2));
+    zip.file(BUNDLE_FILENAME, bundle);
+    for (const relPath of assetPaths) {
+        const bytes = await readFile(join(workspaceAbs, relPath));
+        zip.file(ASSETS_PREFIX + relPath, bytes);
+    }
+    for (const relPath of filePaths) {
+        const bytes = await readFile(join(workspaceAbs, relPath));
+        zip.file(FILES_PREFIX + relPath, bytes);
+    }
+    const buffer = await zip.generateAsync({
+        type: 'nodebuffer',
+        compression: 'DEFLATE',
+        compressionOptions: { level: 6 },
+    });
+    return { manifest, zip: buffer };
+}

package/server/dist/model-package/types.d.ts

@@ -0,0 +1,79 @@
+import type { ParamDefinition } from '../../../lib/dist/index.js';
+export type ParamValue = string | number | boolean | (string | number)[];
+export interface ModelPackageCamera {
+    position: [number, number, number];
+    target: [number, number, number];
+    up: [number, number, number];
+    projection: 'orthographic' | 'perspective';
+}
+/**
+ * Contents of `manifest.json` inside a `.fluidpkg` archive. The bundle, the
+ * optional init.js, and any STEP assets live alongside this manifest as
+ * separate entries in the zip — we never base64-embed binaries in JSON.
+ *
+ * The HubSceneHost reads this manifest first to decide what else to load from
+ * the archive (presence of `init.js`, which asset paths to map, the file tree).
+ *
+ * `schemaVersion: 2` retired the `src/` source tree: the single self-contained
+ * `bundle.js` is what the engine executes, and the `files` tree (below) is the
+ * full human-readable project the hub displays — so `sources`/`src/` (the old
+ * transitive-import subset) is gone.
+ */
+export interface ModelPackageManifest {
+    schemaVersion: 2;
+    name: string;
+    description?: string;
+    fluidcadVersion: string;
+    createdAt: string;
+    entry: string;
+    /**
+     * True when the workspace had an `init.js`. Its code is bundled at the top of
+     * `bundle.js` so the engine pipeline is set up before the entry runs, and the
+     * bundle's `default` export is init's default (the SceneManager). The original
+     * `init.js` text is still in the `files` tree for display.
+     */
+    hasInit: boolean;
+    assets: string[];
+    /**
+     * Workspace-relative paths of every non-ignored file in the workspace
+     * (Pack v2), shipped verbatim under `files/<path>`. The full human tree —
+     * README, package.json, configs, the `.fluid.js` sources — that the hub's
+     * file viewer lists and serves, separate from the self-contained `bundle.js`
+     * the engine executes. Paths already shipped under `assets/` (engine
+     * brep/STEP) are NOT repeated here; `files` + `assets` is the whole package.
+     *
+     * Selection respects a root `.gitignore` (via the `ignore` package) and
+     * always excludes `node_modules`, prior `*.fluidpkg` outputs, `fluidcad.json`
+     * (the local hub binding), and every hidden dot-entry (`.git`, `.env`,
+     * `.claude`, `.vscode`, … — never model content, may hold secrets), whether or
+     * not they're gitignored.
+     */
+    files: string[];
+    params?: Record<string, ParamValue>;
+    /**
+     * Full parameter schema captured by rendering the model once at pack time
+     * (type/default/current value/constraints per `param()` call). Unlike
+     * `params` (override VALUES only), this is the complete definition set the
+     * hub stores and renders forms from. Populated by `fluidcad publish` (which
+     * boots the engine to render); plain `fluidcad pack` leaves it undefined.
+     */
+    paramDefinitions?: ParamDefinition[];
+    camera?: ModelPackageCamera;
+}
+/**
+ * Standard layout inside a `.fluidpkg` zip:
+ *   manifest.json    — ModelPackageManifest as JSON
+ *   bundle.js        — esbuild ES module output: init.js code first (if
+ *                      hasInit), then the entry; bundle's default export
+ *                      is init's default (SceneManager) when present
+ *   assets/<path>    — raw bytes of imported STEP files, paths preserved
+ *                      relative to the workspace root
+ *   files/<path>     — every non-ignored workspace file (Pack v2), verbatim;
+ *                      the full human tree the hub viewer lists and serves.
+ *                      Excludes anything already under assets/ to avoid
+ *                      duplicate bytes.
+ */
+export declare const MANIFEST_FILENAME = "manifest.json";
+export declare const BUNDLE_FILENAME = "bundle.js";
+export declare const ASSETS_PREFIX = "assets/";
+export declare const FILES_PREFIX = "files/";

package/server/dist/model-package/types.js

@@ -0,0 +1,17 @@
+/**
+ * Standard layout inside a `.fluidpkg` zip:
+ *   manifest.json    — ModelPackageManifest as JSON
+ *   bundle.js        — esbuild ES module output: init.js code first (if
+ *                      hasInit), then the entry; bundle's default export
+ *                      is init's default (SceneManager) when present
+ *   assets/<path>    — raw bytes of imported STEP files, paths preserved
+ *                      relative to the workspace root
+ *   files/<path>     — every non-ignored workspace file (Pack v2), verbatim;
+ *                      the full human tree the hub viewer lists and serves.
+ *                      Excludes anything already under assets/ to avoid
+ *                      duplicate bytes.
+ */
+export const MANIFEST_FILENAME = 'manifest.json';
+export const BUNDLE_FILENAME = 'bundle.js';
+export const ASSETS_PREFIX = 'assets/';
+export const FILES_PREFIX = 'files/';

package/server/dist/routes/hit-test.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+export declare function createHitTestRouter(fluidCadServer: FluidCadServer): Router;

package/server/dist/routes/hit-test.js

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+export function createHitTestRouter(fluidCadServer) {
+    const router = Router();
+    router.post('/hit-test', (req, res) => {
+        const { shapeId, rayOrigin, rayDir, edgeThreshold } = req.body;
+        if (typeof shapeId !== 'string' ||
+            !Array.isArray(rayOrigin) || rayOrigin.length !== 3 ||
+            !Array.isArray(rayDir) || rayDir.length !== 3 ||
+            typeof edgeThreshold !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        const result = fluidCadServer.hitTest(shapeId, rayOrigin, rayDir, edgeThreshold);
+        res.json(result);
+    });
+    return router;
+}

package/server/dist/routes/pack.d.ts

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+import type { CameraStateMessage } from '../ws-protocol.ts';
+/**
+ * `POST /api/pack` — produce a `.fluidpkg` (zip) archive of the currently
+ * rendered file. Pulls live param overrides and the last-known camera state
+ * from the running server so the archive matches what the user is seeing.
+ * Returns the binary archive directly (application/zip).
+ */
+export declare function createPackRouter(fluidCadServer: FluidCadServer, workspacePath: string, fluidcadVersion: string, getLastCameraState: () => CameraStateMessage | null): Router;