fix: locate bundled lame binary in flattened dist builds

Author: jankarres

.github/workflows/ci.yml

@@ -43,6 +43,14 @@ jobs:
             - name: Build package
               run: pnpm run build
 
+            - name: Ensure bundled LAME binary
+              env:
+                  LAME_FORCE_DOWNLOAD: "1"
+              run: node ./scripts/install-lame.mjs
+
+            - name: Diagnose bundled LAME binary
+              run: node ./scripts/diagnose-lame.mjs
+
             - name: Run examples
               run: |
                   pnpm run example:wav-to-mp3

scripts/diagnose-lame.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { platform } from "node:os";
+
+const {
+    resolveLameBinary,
+} = await import(new URL("../dist/index.cjs", import.meta.url));
+
+function logSection(title) {
+    console.log(`[lame-diagnostics] ${title}`);
+}
+
+const binaryPath = resolveLameBinary();
+logSection(`Resolved binary: ${binaryPath}`);
+
+try {
+    const stats = statSync(binaryPath);
+    logSection(
+        `File stats -> size=${stats.size} mode=${stats.mode.toString(8)} mtime=${stats.mtime.toISOString()}`,
+    );
+} catch (error) {
+    logSection(`stat() failed: ${error instanceof Error ? error.message : error}`);
+}
+
+const runCommand = (cmd, args) => {
+    const result = spawnSync(cmd, args, {
+        encoding: "utf-8",
+    });
+
+    logSection(
+        `${cmd} ${args.join(" ")} exited ${result.status} (signal: ${result.signal ?? "none"})`,
+    );
+
+    if (result.stdout) {
+        console.log(result.stdout.trim());
+    }
+
+    if (result.stderr) {
+        console.error(result.stderr.trim());
+    }
+};
+
+runCommand(binaryPath, ["--version"]);
+
+if (platform() === "linux") {
+    runCommand("ldd", [binaryPath]);
+}

src/core/lame-process.ts

@@ -168,7 +168,10 @@ function processProgressChunk(
     return {};
 }
 
-function getExitError(code: number | null): Error | null {
+function getExitError(
+    code: number | null,
+    executable: string,
+): Error | null {
     if (code === 0) {
         return null;
     }
@@ -179,6 +182,12 @@ function getExitError(code: number | null): Error | null {
         );
     }
 
+    if (code === 127) {
+        return new Error(
+            `lame: Failed to execute '${executable}'. Exit code 127 usually indicates missing shared libraries or an unreadable binary. Run scripts/diagnose-lame.mjs for details.`,
+        );
+    }
+
     if (code !== null) {
         return new Error(`lame: Process exited with code ${code}`);
     }
@@ -323,7 +332,7 @@ function spawnLameProcess(
 
     child.on("error", emitCliError);
     child.on("close", (code) => {
-        const exitError = getExitError(code);
+        const exitError = getExitError(code, executable);
         if (exitError) {
             const bufferedLines = stderrBuffer
                 .split(/\r?\n/)

src/internal/binary/resolve-binary.ts

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 declare const __dirname: string | undefined;
@@ -36,10 +36,41 @@ const moduleUrl = (() => {
     return deriveModuleUrl(meta, resolvedFilename);
 })();
 
+function findPackageRootFrom(startDir: string): string | null {
+    let current = startDir;
+
+    while (true) {
+        const packageJsonPath = join(current, "package.json");
+        if (existsSync(packageJsonPath)) {
+            return current;
+        }
+
+        const parent = dirname(current);
+        if (parent === current) {
+            return null;
+        }
+
+        current = parent;
+    }
+}
+
 function resolvePackageRoot(
     moduleHref: string | undefined,
     dirname: string | undefined,
 ): string {
+    const normalizedDir =
+        dirname ??
+        (moduleHref != null
+            ? fileURLToPath(new URL(".", moduleHref))
+            : undefined);
+
+    if (normalizedDir) {
+        const detectedRoot = findPackageRootFrom(normalizedDir);
+        if (detectedRoot) {
+            return detectedRoot;
+        }
+    }
+
     if (dirname) {
         return join(dirname, "..", "..", "..");
     }

tests/unit/lame-process.test.ts

@@ -184,22 +184,30 @@ describe("processProgressChunk", () => {
 });
 
 describe("getExitError", () => {
+    const binary = "/tmp/lame";
+
     it("returns null for successful exit", () => {
-        expect(getExitError(0)).toBeNull();
+        expect(getExitError(0, binary)).toBeNull();
     });
 
     it("returns descriptive error for exit code 255", () => {
-        const error = getExitError(255);
+        const error = getExitError(255, binary);
         expect(error?.message).toContain("Unexpected termination of the process");
     });
 
+    it("returns descriptive error for exit code 127", () => {
+        const error = getExitError(127, binary);
+        expect(error?.message).toContain(binary);
+        expect(error?.message).toContain("127");
+    });
+
     it("returns error for other exit codes", () => {
-        const error = getExitError(3);
+        const error = getExitError(3, binary);
         expect(error?.message).toBe("lame: Process exited with code 3");
     });
 
     it("handles null exit codes", () => {
-        const error = getExitError(null);
+        const error = getExitError(null, binary);
         expect(error?.message).toBe("lame: Process exited unexpectedly");
     });
 });

tests/unit/resolve-binary.test.ts

@@ -105,4 +105,20 @@ describe("resolve-binary", () => {
         const derivedFromCwd = resolvePackageRoot(undefined, undefined);
         expect(derivedFromCwd).toBe(process.cwd());
     });
+
+    it("detects package root when compiled assets live directly inside dist", async () => {
+        const projectRoot = join(sharedTempDir, "pkg-flat");
+        const distDir = join(projectRoot, "dist");
+
+        await mkdir(distDir, { recursive: true });
+        await writeFile(join(projectRoot, "package.json"), "{}");
+
+        const { resolvePackageRoot } = await importResolver();
+        const derived = resolvePackageRoot(
+            pathToFileURL(join(distDir, "index.cjs")).href,
+            distDir,
+        );
+
+        expect(derived).toBe(projectRoot);
+    });
 });