@mirinjs/cli 0.1.0-alpha.16 → 0.1.0-alpha.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirinjs/cli",
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.18",
   "description": "CLI for mirin apps: dev, build, init.",
   "type": "module",
   "license": "MIT",
@@ -27,15 +27,15 @@
     "bun": ">=1.2.0"
   },
   "dependencies": {
-    "create-mirinjs": "0.1.0-alpha.16",
-    "mirinjs": "0.1.0-alpha.16"
+    "create-mirinjs": "0.1.0-alpha.18",
+    "mirinjs": "0.1.0-alpha.18"
   },
   "optionalDependencies": {
-    "@mirinjs/darwin-arm64": "0.1.0-alpha.16",
-    "@mirinjs/win32-x64": "0.1.0-alpha.16",
-    "@mirinjs/win32-arm64": "0.1.0-alpha.16",
-    "@mirinjs/linux-arm64": "0.1.0-alpha.16",
-    "@mirinjs/linux-x64": "0.1.0-alpha.16"
+    "@mirinjs/darwin-arm64": "0.1.0-alpha.18",
+    "@mirinjs/win32-x64": "0.1.0-alpha.18",
+    "@mirinjs/win32-arm64": "0.1.0-alpha.18",
+    "@mirinjs/linux-arm64": "0.1.0-alpha.18",
+    "@mirinjs/linux-x64": "0.1.0-alpha.18"
   },
   "publishConfig": {
     "access": "public"

package/src/artifacts.ts

@@ -35,6 +35,8 @@ const IN_REPO = existsSync(join(REPO_ROOT, "crates", "mirin-core"));
 export interface Artifacts {
   /** libmirin_core.dylib — dlopened by the host. */
   coreDylib: string;
+  /** Standalone updater codec used by `mirin release`. */
+  codecBin: string;
   /** mirin-helper — the CEF subprocess binary. */
   helperBin: string;
   /** host entry (TS/JS) compiled with `bun build --compile`. */
@@ -53,12 +55,13 @@ export async function resolveArtifacts(opts: { release: boolean }): Promise<Arti
 
   if (IN_REPO) {
     const profile = opts.release ? "release" : "debug";
-    console.log(`[mirin] building native core + helper (${profile})…`);
+    console.log(`[mirin] building native core + helpers (${profile})…`);
     const flags = opts.release ? ["--release"] : [];
-    await $`cargo build -p mirin-core -p mirin-helper ${flags}`.cwd(REPO_ROOT);
+    await $`cargo build -p mirin-codec -p mirin-core -p mirin-helper ${flags}`.cwd(REPO_ROOT);
     const target = join(REPO_ROOT, "target", profile);
     return {
       coreDylib: join(target, coreFileName()),
+      codecBin: join(target, codecFileName()),
       helperBin: join(target, helperFileName()),
       hostEntry: join(REPO_ROOT, "packages", "mirin", "src", "host.ts"),
       cefPath,
@@ -68,6 +71,7 @@ export async function resolveArtifacts(opts: { release: boolean }): Promise<Arti
   const nativeDir = resolveNativeDir();
   return {
     coreDylib: join(nativeDir, coreFileName()),
+    codecBin: join(nativeDir, codecFileName()),
     helperBin: join(nativeDir, helperFileName()),
     hostEntry: resolvePackageFile("mirinjs/host"),
     cefPath,
@@ -86,6 +90,10 @@ function helperFileName(): string {
   return process.platform === "win32" ? "mirin-helper.exe" : "mirin-helper";
 }
 
+function codecFileName(): string {
+  return process.platform === "win32" ? "mirin-codec.exe" : "mirin-codec";
+}
+
 function assertSupportedPlatform(): void {
   const supported =
     (process.platform === "darwin" && process.arch === "arm64") ||

package/src/build.ts

@@ -125,6 +125,8 @@ export interface BuildResult {
   releaseNotes?: string;
   /** libmirin_core path (for the updater codec at release time). */
   coreDylib: string;
+  /** Standalone updater codec executable used at release time. */
+  codecBin: string;
   /** Project root (so `mirin release` can resolve relative asset paths). */
   projectDir: string;
   /** DMG config from mirin.config.ts (`true`/object/`false`); default `true`. */
@@ -209,7 +211,11 @@ export async function build(
   const workerJs = join(work, "worker.release.js");
   const sidecars = normalizeSidecars(projectDir, config.sidecars);
   const hostBuild = (async (): Promise<void> => {
-    await $`bun build --compile --minify ${artifacts.hostEntry} --outfile ${hostExe}`.cwd(
+    // Bun's Windows arm64 build currently has no bun:ffi/TinyCC runtime. The
+    // win32-arm64 Mirin package therefore carries an x64 compatibility payload,
+    // which Windows 11 ARM executes through its built-in x64 emulation layer.
+    const target = IS_WINDOWS && process.arch === "arm64" ? ["--target=bun-windows-x64"] : [];
+    await $`bun build --compile --minify ${target} ${artifacts.hostEntry} --outfile ${hostExe}`.cwd(
       projectDir,
     );
     if (IS_WINDOWS) {
@@ -325,6 +331,7 @@ export async function build(
     baseUrl,
     releaseNotes,
     coreDylib: artifacts.coreDylib,
+    codecBin: artifacts.codecBin,
     projectDir,
     dmg,
     nsis,

package/src/dev.ts

@@ -59,7 +59,11 @@ export async function dev(projectDir = process.cwd()): Promise<number> {
   // `bun build --compile` emits an `.exe` on Windows; name it so explicitly.
   const hostExe = join(work, IS_WINDOWS ? "host.exe" : "host");
   const workerJs = join(work, "worker.js");
-  await $`bun build --compile ${artifacts.hostEntry} --outfile ${hostExe}`.cwd(projectDir);
+  const hostTarget =
+    process.platform === "win32" && process.arch === "arm64" ? ["--target=bun-windows-x64"] : [];
+  await $`bun build --compile ${hostTarget} ${artifacts.hostEntry} --outfile ${hostExe}`.cwd(
+    projectDir,
+  );
   await $`bun build ${mainEntry} --target=bun --outfile ${workerJs}`.cwd(projectDir);
 
   // Extra assets (dev): compile workers into .mirin/workers and symlink sidecar

package/src/release.ts

@@ -20,7 +20,6 @@ import { existsSync, mkdirSync, mkdtempSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { $ } from "bun";
-import { loadCodec } from "mirinjs/codec";
 import { build } from "./build.ts";
 import { notarizeAndStaple } from "./dmg.ts";
 import { buildReleaseInstaller } from "./release/installers.ts";
@@ -35,6 +34,37 @@ import {
 // The native codec uses multiple workers, so this scales across CI runner cores.
 const RELEASE_COMPRESSION_LEVEL = 10;
 
+interface ReleaseCodec {
+  compress(src: string, dst: string, level: number): void;
+  decompress(src: string, dst: string): void;
+  diff(oldPath: string, newPath: string, patchPath: string): void;
+}
+
+export function createReleaseCodec(binary: string): ReleaseCodec {
+  const run = (operation: string, ...args: string[]) => {
+    const result = Bun.spawnSync({
+      cmd: [binary, operation, ...args],
+      stdout: "inherit",
+      stderr: "pipe",
+    });
+    if (result.exitCode !== 0) {
+      const detail = new TextDecoder().decode(result.stderr).trim();
+      throw new Error(`codec ${operation} failed${detail ? `: ${detail}` : ""}`);
+    }
+  };
+  return {
+    compress(src, dst, level) {
+      run("compress", src, dst, String(level));
+    },
+    decompress(src, dst) {
+      run("decompress", src, dst);
+    },
+    diff(oldPath, newPath, patchPath) {
+      run("diff", oldPath, newPath, patchPath);
+    },
+  };
+}
+
 async function sha256File(path: string): Promise<string> {
   const hasher = new Bun.CryptoHasher("sha256");
   for await (const chunk of Bun.file(path).stream()) {
@@ -83,20 +113,10 @@ export async function release(projectDir = process.cwd()): Promise<number> {
     isLinux,
   });
 
-  // Load the codec (zstd/bsdiff) from the *bundled* core, not the raw build output:
-  // on Windows mirin_core.dll imports libcef.dll. The DLL loader resolves imports
-  // from PATH (and the loader exe's dir), not the dll's own dir, so prepend the
-  // bundle dir to PATH so libcef.dll is found. On Linux libmirin_core.so has a
-  // NEEDED libcef.so (RUNPATH $ORIGIN), so load the *bundled* .so where libcef.so
-  // sits beside it — the raw native package has no libcef.so and dlopen fails.
-  // (On macOS the framework loads at runtime, so result.coreDylib works directly.)
-  const codecCore = isWindows
-    ? join(result.app, "mirin_core.dll")
-    : isLinux
-      ? join(result.app, "libmirin_core.so")
-      : result.coreDylib;
-  if (isWindows) process.env.PATH = `${result.app};${process.env.PATH ?? ""}`;
-  const codec = loadCodec(codecCore);
+  // Release tooling runs in plain Bun, including Windows arm64 builds where
+  // bun:ffi is unavailable. The standalone helper also avoids loading CEF merely
+  // to compress updater artifacts.
+  const codec = createReleaseCodec(result.codecBin);
 
   // Uncompressed tar — the identity + diff/patch basis (BSD tar keeps symlinks).
   const newTar = join(outDir, "_new.tar");