@meshy-ai/cli 0.2.0 → 0.3.0

package/dist/internal/obj-transform.js

@@ -0,0 +1,649 @@
+/**
+ * OBJ print preparation — the legacy `fix_obj.py` transform as a streaming module.
+ *
+ * Meshy exports Y-up OBJ files in arbitrary units; slicers want Z-up
+ * millimetres with the model standing on the build plate. The transform is
+ *
+ *   R(x, y, z) = (x, -z, y)        Y-up → Z-up; determinant +1, so face winding is kept
+ *   v' = s·R(v) + (tx, ty, tz)     s = height_mm / (zmax − zmin) of the rotated box,
+ *                                  XY centred on the origin, minZ on the plate (0)
+ *   n' = R(n)                      normals only rotate — no scale, no translation
+ *
+ * Every other line (vt, f, o, g, s, usemtl, mtllib, comments, blanks) is copied
+ * verbatim, so topology, UVs and material bindings cannot drift. Extra fields on
+ * a `v` line (vertex colours, w) are kept verbatim after the three coordinates.
+ *
+ * Two streaming passes keep memory constant regardless of file size: pass 1 folds
+ * every vertex into a bounding box, pass 2 rewrites lines through a write stream
+ * into a temp file in the target directory. The temp file is published only after
+ * the whole rewrite succeeded — nothing is written when validation fails, an
+ * existing output is never overwritten, and the input is replaced only with
+ * `inPlace` (temp file + rename on the same filesystem).
+ *
+ * Material dependencies (`mtllib`, and `map_*` textures inside those MTLs) are
+ * resolved relative to the input and only inside the input's directory tree.
+ * When the output lands in another directory they are copied alongside it; a
+ * missing or escaping dependency is a validation error there unless the caller
+ * asked for `geometryOnly`, because a "success" with a silently broken material
+ * is worse than a refusal. Every copy target is proven to lie inside the write
+ * root (`root`, i.e. the --workspace, else the output directory) on its *real*
+ * path before any directory is created or byte copied, and again right before
+ * publication — a symlinked `materials/` inside the target cannot redirect a
+ * copy outside. No env, no credentials, no network.
+ */
+import { chmodSync, closeSync, createReadStream, createWriteStream, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, } from "node:fs";
+import { once } from "node:events";
+import { basename, dirname, extname, join, posix, relative, resolve as resolvePath, win32 } from "node:path";
+import { finished } from "node:stream/promises";
+import { StringDecoder } from "node:string_decoder";
+import { copyFilePublished, publishTempFile, tempPathFor } from "./atomic-file.js";
+import { CliError, UsageError } from "./errors.js";
+import { freezeRoot, isInside, realpathLenient, resolveWithinRoot } from "./paths.js";
+import { warning } from "./result.js";
+export const OBJ_ROTATION = "(x,y,z)->(x,-z,y)";
+export const DEFAULT_HEIGHT_MM = 75;
+/** Same engineering ceiling as endpoint-contracts.json `limits.obj_bytes`. */
+export const DEFAULT_MAX_OBJ_BYTES = 2 * 1024 * 1024 * 1024;
+/** A rotated height at or below this is treated as degenerate (flat model). */
+export const MIN_MODEL_HEIGHT = 1e-6;
+const READ_CHUNK_BYTES = 256 * 1024;
+/** A "line" longer than this is not a text OBJ; refusing keeps the carry buffer bounded. */
+const MAX_LINE_CHARS = 16 * 1024 * 1024;
+const WS = /\s+/;
+const NUMBER_RE = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const TEXTURE_KEY_RE = /^(?:map_[A-Za-z0-9_]+|bump|disp|decal|refl|norm)$/i;
+const URL_RE = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//;
+export function rotateYUpToZUp(v) {
+    return [v[0], -v[2], v[1]];
+}
+/** Default output beside the input: `<stem>.print.obj`. */
+export function defaultOutputPath(input) {
+    const ext = extname(input);
+    const stem = ext ? basename(input, ext) : basename(input);
+    return join(dirname(input), `${stem}.print.obj`);
+}
+/**
+ * Six fixed decimals (error ≤ 5e-7, inside the 1e-5 mm oracle tolerance) with
+ * trailing zeros trimmed so a unit box does not become a wall of `.000000`.
+ * `-0` never appears: a slicer gains nothing from a signed zero.
+ */
+export function formatObjNumber(n) {
+    if (n === 0)
+        return "0";
+    let s = n.toFixed(6);
+    if (s.includes("."))
+        s = s.replace(/0+$/, "").replace(/\.$/, "");
+    return s === "-0" ? "0" : s;
+}
+function validation(message, extra = {}) {
+    return new CliError({ code: "validation", message, hint: extra.hint, details: extra.details });
+}
+function localIo(message, cause) {
+    return new CliError({ code: "local_io", message, cause });
+}
+function errno(err) {
+    return err?.code;
+}
+function removeQuietly(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        /* already gone */
+    }
+}
+function noNegZero(n) {
+    return n === 0 ? 0 : n;
+}
+function parseCoord(token) {
+    if (token === undefined || !NUMBER_RE.test(token))
+        return null;
+    const n = Number(token);
+    return Number.isFinite(n) ? n : null;
+}
+/** First whitespace-delimited token (the OBJ keyword) of an already-trimmed line. */
+function keywordOf(t) {
+    const m = WS.exec(t);
+    return m ? t.slice(0, m.index) : t;
+}
+function parseVec3(tokens, lineNo, kind) {
+    if (tokens.length < 4) {
+        throw validation(`${kind} line ${lineNo} has ${tokens.length - 1} coordinate(s); expected 3`);
+    }
+    const out = [];
+    for (let i = 1; i <= 3; i++) {
+        const n = parseCoord(tokens[i]);
+        if (n === null) {
+            throw validation(`non-finite or unparseable coordinate '${tokens[i] ?? ""}' in ${kind} line ${lineNo}`);
+        }
+        out.push(n);
+    }
+    return [out[0], out[1], out[2]];
+}
+/** Negate a numeric token textually so the input's precision survives the rotation. */
+function negateToken(token) {
+    const n = Number(token);
+    if (n === 0)
+        return "0";
+    if (token.startsWith("-"))
+        return token.slice(1);
+    if (token.startsWith("+"))
+        return `-${token.slice(1)}`;
+    return `-${token}`;
+}
+function emptyBbox() {
+    return { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity], seen: false };
+}
+function fold(b, v) {
+    for (let i = 0; i < 3; i++) {
+        const c = v[i];
+        if (c < b.min[i])
+            b.min[i] = c;
+        if (c > b.max[i])
+            b.max[i] = c;
+    }
+    b.seen = true;
+}
+/**
+ * Stream `path` line by line. Each line's own terminator ("\n", "\r\n", or ""
+ * for a final unterminated line) is handed to the sink so pass 2 can preserve
+ * the input's style. UTF-8 is decoded across chunk boundaries. `afterChunk`
+ * runs after every read chunk so a writer can apply backpressure.
+ */
+async function forEachLine(path, onLine, afterChunk) {
+    const stream = createReadStream(path, { highWaterMark: READ_CHUNK_BYTES });
+    const decoder = new StringDecoder("utf8");
+    let carry = "";
+    let lineNo = 0;
+    try {
+        for await (const chunk of stream) {
+            carry += decoder.write(chunk);
+            let start = 0;
+            let nl;
+            while ((nl = carry.indexOf("\n", start)) !== -1) {
+                let end = nl;
+                let eol = "\n";
+                if (end > start && carry.charCodeAt(end - 1) === 13) {
+                    end -= 1;
+                    eol = "\r\n";
+                }
+                lineNo += 1;
+                onLine(carry.slice(start, end), eol, lineNo);
+                start = nl + 1;
+            }
+            carry = start > 0 ? carry.slice(start) : carry;
+            if (carry.length > MAX_LINE_CHARS) {
+                throw validation(`line ${lineNo + 1} exceeds ${MAX_LINE_CHARS} characters; not a text OBJ file`);
+            }
+            if (afterChunk)
+                await afterChunk();
+        }
+        carry += decoder.end();
+        if (carry.length > 0) {
+            lineNo += 1;
+            onLine(carry, "", lineNo);
+            if (afterChunk)
+                await afterChunk();
+        }
+        return lineNo;
+    }
+    catch (err) {
+        stream.destroy();
+        if (err instanceof CliError || err instanceof UsageError)
+            throw err;
+        throw localIo(`failed to read ${path}: ${err instanceof Error ? err.message : String(err)}`, err);
+    }
+}
+/** Pass 1: bounding boxes, counts and material references. Constant memory. */
+async function scanObj(input) {
+    const scan = { raw: emptyBbox(), rotated: emptyBbox(), vertices: 0, normals: 0, uvs: 0, faces: 0, lines: 0, mtllib: [] };
+    const seenMtl = new Set();
+    scan.lines = await forEachLine(input, (text, _eol, lineNo) => {
+        const t = text.trim();
+        if (t.length === 0)
+            return;
+        switch (keywordOf(t)) {
+            case "v": {
+                const v = parseVec3(t.split(WS), lineNo, "v");
+                fold(scan.raw, v);
+                fold(scan.rotated, rotateYUpToZUp(v));
+                scan.vertices += 1;
+                break;
+            }
+            case "vn":
+                parseVec3(t.split(WS), lineNo, "vn");
+                scan.normals += 1;
+                break;
+            case "vt":
+                scan.uvs += 1;
+                break;
+            case "f":
+                scan.faces += 1;
+                break;
+            case "mtllib": {
+                const ref = t.slice("mtllib".length).trim();
+                if (ref && !seenMtl.has(ref)) {
+                    seenMtl.add(ref);
+                    scan.mtllib.push(ref);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }, null);
+    return scan;
+}
+function rewriteLine(text, lineNo, tf) {
+    const t = text.trim();
+    if (t.length === 0)
+        return text;
+    const key = keywordOf(t);
+    if (key === "v") {
+        const tokens = t.split(WS);
+        const [rx, ry, rz] = rotateYUpToZUp(parseVec3(tokens, lineNo, "v"));
+        const parts = [
+            "v",
+            formatObjNumber(rx * tf.scale + tf.translation[0]),
+            formatObjNumber(ry * tf.scale + tf.translation[1]),
+            formatObjNumber(rz * tf.scale + tf.translation[2]),
+        ];
+        for (let i = 4; i < tokens.length; i++)
+            parts.push(tokens[i]);
+        return parts.join(" ");
+    }
+    if (key === "vn") {
+        const tokens = t.split(WS);
+        parseVec3(tokens, lineNo, "vn");
+        // (nx, ny, nz) → (nx, -nz, ny), reordering the original tokens so no precision is lost.
+        const parts = ["vn", tokens[1], negateToken(tokens[3]), tokens[2]];
+        for (let i = 4; i < tokens.length; i++)
+            parts.push(tokens[i]);
+        return parts.join(" ");
+    }
+    return text;
+}
+/** Pass 2: rewrite into `tmp`, streaming with backpressure. */
+async function rewriteObj(input, tmp, tf) {
+    const out = createWriteStream(tmp, { flags: "wx" });
+    let writeError = null;
+    out.on("error", (err) => {
+        writeError = err;
+    });
+    let buf = "";
+    const flush = async () => {
+        if (writeError)
+            throw writeError;
+        if (buf.length === 0)
+            return;
+        const chunk = buf;
+        buf = "";
+        if (!out.write(chunk))
+            await once(out, "drain");
+        if (writeError)
+            throw writeError;
+    };
+    try {
+        await forEachLine(input, (text, eol, lineNo) => {
+            buf += rewriteLine(text, lineNo, tf) + eol;
+        }, flush);
+        await flush();
+        out.end();
+        await finished(out);
+    }
+    catch (err) {
+        out.destroy();
+        if (err instanceof CliError || err instanceof UsageError)
+            throw err;
+        throw localIo(`failed to write ${tmp}: ${err instanceof Error ? err.message : String(err)}`, err);
+    }
+}
+/**
+ * Resolve a material reference relative to `baseDir`, admitting only regular
+ * files whose real path stays inside `rootDir`. URLs, absolute paths (POSIX or
+ * Windows) and anything escaping the tree are never read.
+ */
+function locateDependency(ref, baseDir, rootReal) {
+    if (!ref || URL_RE.test(ref) || /^data:/i.test(ref))
+        return { kind: "outside" };
+    const candidates = [ref];
+    if (ref.includes("\\"))
+        candidates.push(ref.replaceAll("\\", "/"));
+    let sawMissing = false;
+    for (const candidate of candidates) {
+        if (posix.isAbsolute(candidate) || win32.isAbsolute(candidate))
+            return { kind: "outside" };
+        const abs = resolvePath(baseDir, candidate);
+        let real;
+        try {
+            real = realpathLenient(abs);
+        }
+        catch {
+            sawMissing = true;
+            continue;
+        }
+        if (!isInside(rootReal, real))
+            return { kind: "outside" };
+        let st = null;
+        try {
+            st = statSync(real);
+        }
+        catch (err) {
+            if (errno(err) !== "ENOENT" && errno(err) !== "ENOTDIR")
+                throw localIo(`cannot access ${abs}: ${err.message}`, err);
+        }
+        if (st?.isFile())
+            return { kind: "found", path: abs, real };
+        sawMissing = true;
+    }
+    return sawMissing ? { kind: "missing" } : { kind: "outside" };
+}
+/** Texture references (`map_Kd [-options] file`) inside an MTL. */
+export function textureReferencesInMtl(text) {
+    const refs = [];
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const key = keywordOf(line);
+        if (!TEXTURE_KEY_RE.test(key))
+            continue;
+        const rest = line.slice(key.length).trim();
+        if (!rest)
+            continue;
+        // Options (`-s 1 1 1`, `-bm 0.5`) precede the filename; without options the
+        // whole remainder is the name so spaces in filenames survive.
+        const ref = rest.startsWith("-") ? rest.split(WS).at(-1) : rest;
+        if (!refs.includes(ref))
+            refs.push(ref);
+    }
+    return refs;
+}
+function planMaterials(refs, inputDir, outputDir, wantCopies) {
+    const plan = { copies: [], missing: [], warnings: [] };
+    const inputReal = realpathLenient(inputDir);
+    const targets = new Set();
+    const note = (ref, located, origin) => {
+        plan.missing.push(ref);
+        if (located.kind === "outside") {
+            plan.warnings.push(warning("material_dependency_outside_input_dir", `${origin} references '${ref}', which is a URL, an absolute path or escapes the input's directory; it was not read or copied`));
+        }
+        else {
+            plan.warnings.push(warning("material_dependency_missing", `${origin} references '${ref}', which does not exist next to the input`));
+        }
+    };
+    const schedule = (ref, real) => {
+        if (!wantCopies)
+            return;
+        const target = join(outputDir, relative(inputReal, real));
+        if (targets.has(target))
+            return;
+        targets.add(target);
+        plan.copies.push({ ref, source: real, target, real: target });
+    };
+    for (const written of refs) {
+        // `mtllib a.mtl b.mtl` lists several files, but names with spaces exist in
+        // the wild: try the whole remainder first, split only when it is not a file.
+        let names = [written];
+        if (WS.test(written) && locateDependency(written, inputDir, inputReal).kind !== "found") {
+            names = written.split(WS);
+        }
+        for (const name of names) {
+            const located = locateDependency(name, inputDir, inputReal);
+            if (located.kind !== "found") {
+                note(name, located, "mtllib");
+                continue;
+            }
+            schedule(name, located.real);
+            let mtlText;
+            try {
+                mtlText = readFileSync(located.real, "utf8");
+            }
+            catch (err) {
+                throw localIo(`failed to read material file ${located.path}: ${err.message}`, err);
+            }
+            const mtlDir = dirname(located.real);
+            for (const texRef of textureReferencesInMtl(mtlText)) {
+                const tex = locateDependency(texRef, mtlDir, inputReal);
+                if (tex.kind !== "found") {
+                    note(texRef, tex, `${name}`);
+                    continue;
+                }
+                schedule(texRef, tex.real);
+            }
+        }
+    }
+    return plan;
+}
+function sameContent(a, b) {
+    const sa = statSync(a);
+    const sb = statSync(b);
+    if (sa.size !== sb.size)
+        return false;
+    return readFileSync(a).equals(readFileSync(b));
+}
+/** Copy a dependency without overwriting; an identical file already there counts as present. */
+function copyDependency(source, target) {
+    let existing = null;
+    try {
+        existing = lstatSync(target);
+    }
+    catch (err) {
+        if (errno(err) !== "ENOENT" && errno(err) !== "ENOTDIR")
+            throw localIo(`cannot access ${target}: ${err.message}`, err);
+    }
+    if (existing) {
+        if (existing.isFile() && sameContent(source, target))
+            return "present";
+        throw localIo(`refusing to overwrite ${target}: a different file already exists there (needed for material dependency ${basename(source)})`);
+    }
+    copyFilePublished(source, target);
+    return "copied";
+}
+function statInput(input) {
+    let lst;
+    try {
+        lst = lstatSync(input);
+    }
+    catch (err) {
+        if (errno(err) === "ENOENT" || errno(err) === "ENOTDIR") {
+            throw new CliError({ code: "not_found", message: `input file not found: ${input}` });
+        }
+        throw localIo(`cannot access ${input}: ${err.message}`, err);
+    }
+    let st;
+    try {
+        st = statSync(input);
+    }
+    catch (err) {
+        if (errno(err) === "ENOENT" || errno(err) === "ENOTDIR") {
+            throw new CliError({ code: "not_found", message: `input file not found: ${input} (dangling symbolic link)` });
+        }
+        throw localIo(`cannot access ${input}: ${err.message}`, err);
+    }
+    if (!st.isFile())
+        throw validation(`input is not a regular file: ${input}`);
+    return { stat: st, lstat: lst };
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function exists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Rotate, scale and ground an OBJ for printing. See the module comment for the
+ * maths and the file contract. Throws CliError (`validation` / `local_io` /
+ * `not_found`) or UsageError; on any failure no output file exists.
+ */
+export async function prepareObjForPrint(inputPath, opts = {}) {
+    const heightMm = opts.heightMm ?? DEFAULT_HEIGHT_MM;
+    if (typeof heightMm !== "number" || !Number.isFinite(heightMm) || heightMm <= 0) {
+        throw validation(`--height-mm must be a finite number greater than 0 (got ${String(heightMm)})`);
+    }
+    const inPlace = opts.inPlace === true;
+    const geometryOnly = opts.geometryOnly === true;
+    if (opts.outputPath !== undefined && inPlace) {
+        throw new UsageError("--output/-o and --in-place are mutually exclusive: pick a new file or replace the input, not both");
+    }
+    const maxBytes = opts.maxBytes ?? DEFAULT_MAX_OBJ_BYTES;
+    const input = resolvePath(inputPath);
+    const { stat, lstat } = statInput(input);
+    if (stat.size === 0)
+        throw validation(`input is empty: ${input}`);
+    if (stat.size > maxBytes) {
+        throw localIo(`input is ${stat.size} bytes, above the ${maxBytes}-byte limit for local OBJ processing: ${input}`);
+    }
+    if (inPlace && lstat.isSymbolicLink()) {
+        throw localIo(`refusing to replace ${input} in place: it is a symbolic link`);
+    }
+    const inputDir = dirname(input);
+    let output;
+    if (inPlace) {
+        output = input;
+    }
+    else {
+        output = opts.outputPath !== undefined ? resolvePath(opts.outputPath) : defaultOutputPath(input);
+        if (isDirectory(output))
+            output = join(output, basename(defaultOutputPath(input)));
+        if (exists(output)) {
+            throw new CliError({
+                code: "local_io",
+                message: `refusing to overwrite existing file: ${output} (choose another --output path, or pass --in-place to replace the input itself)`,
+                recovery: { action: "choose_path", automatic: false },
+            });
+        }
+    }
+    const outputDir = dirname(output);
+    // Pass 1 — validate and measure. Nothing has been written yet.
+    const scan = await scanObj(input);
+    if (scan.vertices === 0)
+        throw validation(`no vertex (v) lines found in ${input}`);
+    const rot = scan.rotated;
+    const height = rot.max[2] - rot.min[2];
+    if (!(height > MIN_MODEL_HEIGHT)) {
+        throw validation(`degenerate model: rotated height is ${height} (≤ ${MIN_MODEL_HEIGHT}); every vertex shares the same up-axis value, so no scale can be derived`);
+    }
+    const scale = heightMm / height;
+    const translation = [
+        noNegZero((-(rot.min[0] + rot.max[0]) / 2) * scale),
+        noNegZero((-(rot.min[1] + rot.max[1]) / 2) * scale),
+        noNegZero(-rot.min[2] * scale),
+    ];
+    const tf = { scale, translation };
+    // Materials — decided before any write so a broken binding is refused up front.
+    const crossDir = !inPlace && realpathLenient(outputDir) !== realpathLenient(inputDir);
+    const wantCopies = crossDir && !geometryOnly;
+    const plan = planMaterials(scan.mtllib, inputDir, outputDir, wantCopies);
+    const warnings = [...plan.warnings];
+    // Every path written by this run must resolve inside the write root: the
+    // output itself and each dependency copy, checked on real paths before any
+    // directory is created. A `materials/` symlink pointing elsewhere fails here.
+    const writeRoot = opts.root === undefined ? freezeRoot(outputDir, { label: "output directory" }) : typeof opts.root === "string" ? freezeRoot(opts.root, { label: "--workspace" }) : opts.root;
+    if (!inPlace)
+        resolveWithinRoot(output, writeRoot, { label: "output" });
+    for (const copy of plan.copies) {
+        copy.real = resolveWithinRoot(copy.target, writeRoot, { label: `material dependency target for '${copy.ref}'` }).path;
+    }
+    if (wantCopies && plan.missing.length > 0) {
+        throw validation(`material dependencies of ${input} cannot be carried to ${outputDir}: ${plan.missing.join(", ")} — the output would reference files that are not there. ` +
+            "Pass --geometry-only to write only the geometry, or keep the output in the input's directory", { hint: "pass --geometry-only, or write the output next to the input" });
+    }
+    if (crossDir && geometryOnly && scan.mtllib.length > 0) {
+        warnings.push(warning("material_dependencies_not_copied", `--geometry-only: ${scan.mtllib.join(", ")} referenced by the output were not copied to ${outputDir}`));
+    }
+    // Pass 2 — rewrite into a temp file beside the target, then publish.
+    if (!inPlace) {
+        try {
+            mkdirSync(outputDir, { recursive: true });
+        }
+        catch (err) {
+            throw localIo(`cannot create output directory ${outputDir}: ${err.message}`, err);
+        }
+    }
+    const tmp = tempPathFor(output);
+    const copied = [];
+    try {
+        await rewriteObj(input, tmp, tf);
+        if (inPlace) {
+            const fd = openSync(tmp, "r");
+            try {
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            try {
+                chmodSync(tmp, stat.mode & 0o777);
+            }
+            catch {
+                /* keep default mode */
+            }
+            renameSync(tmp, output);
+        }
+        else {
+            for (const copy of plan.copies) {
+                // Re-proven at publication time: the tree may have changed since planning.
+                copy.real = resolveWithinRoot(copy.target, writeRoot, { label: `material dependency target for '${copy.ref}'` }).path;
+                if (copyDependency(copy.source, copy.real) === "copied") {
+                    copied.push(copy.target);
+                }
+                else {
+                    warnings.push(warning("material_dependency_already_present", `${copy.target} already exists with identical content; not copied again`));
+                }
+            }
+            resolveWithinRoot(output, writeRoot, { label: "output" });
+            publishTempFile(tmp, output);
+        }
+    }
+    catch (err) {
+        removeQuietly(tmp);
+        if (err instanceof CliError || err instanceof UsageError)
+            throw err;
+        throw localIo(`failed to write ${output}: ${err instanceof Error ? err.message : String(err)}`, err);
+    }
+    const afterBbox = {
+        min: [
+            noNegZero(rot.min[0] * scale + translation[0]),
+            noNegZero(rot.min[1] * scale + translation[1]),
+            noNegZero(rot.min[2] * scale + translation[2]),
+        ],
+        max: [
+            noNegZero(rot.max[0] * scale + translation[0]),
+            noNegZero(rot.max[1] * scale + translation[1]),
+            noNegZero(rot.max[2] * scale + translation[2]),
+        ],
+    };
+    return {
+        input,
+        output,
+        height_mm: heightMm,
+        scale,
+        rotation: OBJ_ROTATION,
+        translation,
+        before_bbox: { min: [...scan.raw.min], max: [...scan.raw.max] },
+        after_bbox: afterBbox,
+        counts: {
+            vertices: scan.vertices,
+            normals: scan.normals,
+            uvs: scan.uvs,
+            faces: scan.faces,
+            lines_total: scan.lines,
+        },
+        material: { mtllib: scan.mtllib, copied, missing: plan.missing },
+        in_place: inPlace,
+        warnings,
+    };
+}
+//# sourceMappingURL=obj-transform.js.map