fluidcad 0.0.33 → 0.0.35

package/server/dist/lint-fluid-js.js

@@ -0,0 +1,271 @@
+// Static import linter for `.fluid.js` sources.
+//
+// LLMs frequently emit a first draft that uses FluidCAD APIs (`sketch`,
+// `extrude`, `face`, …) without an `import { … } from "fluidcad/core"` line —
+// the script then explodes at runtime with `ReferenceError`. The MCP server
+// calls this linter before writing a `.fluid.js` file so the agent gets a
+// precise error pointing at the missing symbols instead of a confusing
+// render failure.
+//
+// Tree-sitter (web-tree-sitter + tree-sitter-wasms) is reused — the parser
+// instance is the same singleton the param editor in `code-editor.ts` uses.
+// Doing it that way means we don't double-load the JavaScript wasm grammar.
+import { getJavaScriptParser } from "./code-editor.js";
+// Authoritative FluidCAD symbol→module map. Mirrors the exports in
+// `lib/core/index.ts`, `lib/core/2d/index.ts`, `lib/filters/index.ts`, and
+// `lib/features/2d/constraints/geometry-qualifier.ts`. If a new public symbol
+// is added there, add it here too — the import lint is the wall the LLM
+// hits, so keep it accurate.
+const CORE_SYMBOLS = new Set([
+    'axis', 'local', 'plane', 'sketch', 'fuse', 'subtract', 'common',
+    'cut', 'revolve', 'extrude', 'sphere', 'cylinder', 'select', 'shell',
+    'chamfer', 'fillet', 'translate', 'rotate', 'mirror', 'copy', 'repeat',
+    'load', 'loft', 'sweep', 'rib', 'color', 'draft', 'remove', 'split',
+    'trim', 'part', 'breakpoint',
+    'line', 'circle', 'ellipse', 'rect', 'hMove', 'vMove', 'rMove',
+    'hLine', 'vLine', 'tLine', 'tCircle', 'tArc', 'arc', 'move', 'pMove',
+    'aLine', 'slot', 'connect', 'polygon', 'offset', 'project', 'intersect',
+    'bezier', 'center', 'back',
+]);
+const FILTER_SYMBOLS = new Set(['face', 'edge']);
+const CONSTRAINT_SYMBOLS = new Set([
+    'outside', 'enclosed', 'enclosing', 'unqualified',
+]);
+const MODULE_FOR_SYMBOL = new Map();
+for (const s of CORE_SYMBOLS) {
+    MODULE_FOR_SYMBOL.set(s, 'fluidcad/core');
+}
+for (const s of FILTER_SYMBOLS) {
+    MODULE_FOR_SYMBOL.set(s, 'fluidcad/filters');
+}
+for (const s of CONSTRAINT_SYMBOLS) {
+    MODULE_FOR_SYMBOL.set(s, 'fluidcad/constraints');
+}
+/**
+ * Walk every named child recursively, invoking `visit` once per node. The
+ * walker stops descending into a subtree when `visit` returns `false`.
+ */
+function walk(node, visit) {
+    const cont = visit(node);
+    if (cont === false) {
+        return;
+    }
+    for (const child of node.namedChildren) {
+        walk(child, visit);
+    }
+}
+/**
+ * Determine whether `node` (an `identifier`) is at a position the JS spec
+ * treats as a *reference* (would throw `ReferenceError` if unbound) vs a
+ * *binding* (a declared name) vs a *property name* (never a reference at
+ * all).
+ *
+ * Tree-sitter's JavaScript grammar has distinct node types for some of
+ * these (`property_identifier`, `shorthand_property_identifier_pattern`,
+ * etc.), but plain `identifier` nodes still cover a lot of ground and we
+ * have to look at parent context to classify them.
+ */
+function isReferenceUse(node) {
+    if (node.type !== 'identifier') {
+        return false;
+    }
+    const parent = node.parent;
+    if (!parent) {
+        return true;
+    }
+    switch (parent.type) {
+        case 'import_specifier':
+        case 'namespace_import':
+        case 'import_clause':
+        case 'import_statement':
+            // Anything inside an `import` statement is bookkeeping, not a use.
+            return false;
+        case 'variable_declarator': {
+            // `const X = ...` → the `name` field is a binding.
+            const nameField = parent.childForFieldName('name');
+            if (nameField && nameField.startIndex === node.startIndex) {
+                return false;
+            }
+            return true;
+        }
+        case 'function_declaration':
+        case 'function_expression':
+        case 'generator_function_declaration':
+        case 'class_declaration':
+        case 'class_expression':
+        case 'method_definition': {
+            const nameField = parent.childForFieldName('name');
+            if (nameField && nameField.startIndex === node.startIndex) {
+                return false;
+            }
+            return true;
+        }
+        case 'formal_parameters':
+        case 'required_parameter':
+        case 'optional_parameter':
+        case 'rest_pattern':
+            // Parameter names are bindings.
+            return false;
+        case 'arrow_function': {
+            // `(x) => …` or `x => …` — parameter is a binding when it's the
+            // function's `parameter` field.
+            const param = parent.childForFieldName('parameter');
+            if (param && param.startIndex === node.startIndex) {
+                return false;
+            }
+            return true;
+        }
+        case 'member_expression': {
+            // `obj.foo` — the `property` field is a name lookup, not a reference.
+            const prop = parent.childForFieldName('property');
+            if (prop && prop.startIndex === node.startIndex) {
+                return false;
+            }
+            return true;
+        }
+        case 'pair': {
+            // `{ key: value }` — `key` (if an identifier) is a property name.
+            const key = parent.childForFieldName('key');
+            if (key && key.startIndex === node.startIndex) {
+                return false;
+            }
+            return true;
+        }
+        case 'property_signature':
+        case 'public_field_definition':
+            // Class/object field declarations — the name slot is a binding.
+            return false;
+        case 'labeled_statement':
+            // `label: stmt` — labels are not references.
+            return false;
+    }
+    return true;
+}
+/**
+ * Walk an `import_statement` and collect every name it locally binds.
+ * Handles:
+ *   - `import x from "…"`               (default)
+ *   - `import { a, b as c } from "…"`   (named, with renaming)
+ *   - `import x, { a } from "…"`        (default + named)
+ *   - `import * as ns from "…"`         (namespace)
+ *   - `import "…"`                      (side-effect, binds nothing)
+ */
+function collectImportedNames(importNode, into) {
+    walk(importNode, (n) => {
+        if (n.type === 'import_specifier') {
+            // `{ a as b }` → `alias` field (b) is what binds; otherwise `name` (a).
+            const alias = n.childForFieldName('alias');
+            const name = n.childForFieldName('name');
+            const local = alias ?? name;
+            if (local && local.type === 'identifier') {
+                into.add(local.text);
+            }
+            return false;
+        }
+        if (n.type === 'namespace_import') {
+            const id = n.namedChildren.find((c) => c.type === 'identifier');
+            if (id) {
+                into.add(id.text);
+            }
+            return false;
+        }
+        if (n.type === 'import_clause') {
+            // The default import (if any) is a direct `identifier` child.
+            for (const child of n.namedChildren) {
+                if (child.type === 'identifier') {
+                    into.add(child.text);
+                }
+            }
+        }
+    });
+}
+/**
+ * Collect names that are bound at the top level of the program: `const`,
+ * `let`, `var`, `function`, `class`. Used so user code like
+ * `const sketch = …` shadows the FluidCAD `sketch` without tripping the
+ * lint. We deliberately keep this top-level-only to keep the implementation
+ * simple — local shadowing inside a function is rare in `.fluid.js` files.
+ */
+function collectTopLevelDeclaredNames(root, into) {
+    for (const stmt of root.namedChildren) {
+        if (stmt.type === 'variable_declaration' || stmt.type === 'lexical_declaration') {
+            for (const decl of stmt.namedChildren) {
+                if (decl.type !== 'variable_declarator') {
+                    continue;
+                }
+                const name = decl.childForFieldName('name');
+                if (name && name.type === 'identifier') {
+                    into.add(name.text);
+                }
+                // Destructuring (`const { a, b } = …`) — pick up shorthand pattern names.
+                if (name) {
+                    walk(name, (n) => {
+                        if (n.type === 'shorthand_property_identifier_pattern' ||
+                            n.type === 'identifier') {
+                            if (n.parent && n.parent.type !== 'pair_pattern') {
+                                into.add(n.text);
+                            }
+                        }
+                    });
+                }
+            }
+        }
+        if (stmt.type === 'function_declaration' || stmt.type === 'class_declaration') {
+            const name = stmt.childForFieldName('name');
+            if (name && name.type === 'identifier') {
+                into.add(name.text);
+            }
+        }
+    }
+}
+export async function lintFluidJs(code) {
+    const parser = await getJavaScriptParser();
+    const tree = parser.parse(code);
+    const root = tree.rootNode;
+    const bound = new Set();
+    for (const stmt of root.namedChildren) {
+        if (stmt.type === 'import_statement') {
+            collectImportedNames(stmt, bound);
+        }
+    }
+    collectTopLevelDeclaredNames(root, bound);
+    const missingByName = new Map();
+    walk(root, (n) => {
+        if (n.type === 'import_statement') {
+            return false;
+        }
+        if (n.type !== 'identifier') {
+            return;
+        }
+        if (!MODULE_FOR_SYMBOL.has(n.text)) {
+            return;
+        }
+        if (bound.has(n.text)) {
+            return;
+        }
+        if (!isReferenceUse(n)) {
+            return;
+        }
+        if (missingByName.has(n.text)) {
+            return;
+        }
+        missingByName.set(n.text, {
+            symbol: n.text,
+            module: MODULE_FOR_SYMBOL.get(n.text),
+            line: n.startPosition.row,
+            column: n.startPosition.column,
+        });
+    });
+    const sorted = Array.from(missingByName.values()).sort((a, b) => a.symbol.localeCompare(b.symbol));
+    const byModule = new Map();
+    for (const m of sorted) {
+        const list = byModule.get(m.module) ?? [];
+        list.push(m.symbol);
+        byModule.set(m.module, list);
+    }
+    const suggestion = Array.from(byModule.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([mod, syms]) => `import { ${syms.join(', ')} } from "${mod}";`)
+        .join('\n');
+    return { missing: sorted, suggestion };
+}

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,229 @@
+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 and prior pack outputs
+// (the latter would otherwise recurse into the next pack). `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'];
+// `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,78 @@
+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, 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/';