mirinjs 0.1.0-alpha.25 → 0.1.0-alpha.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirinjs",
-  "version": "0.1.0-alpha.25",
+  "version": "0.1.0-alpha.27",
   "description": "Build desktop apps with Bun, TypeScript, and Chromium (CEF). The Bun-native Electron alternative.",
   "type": "module",
   "license": "MIT",

package/src/app/facade.ts

@@ -12,6 +12,7 @@ import type { Updater } from "../updater/index.ts";
 import { updater } from "../updater/index.ts";
 import { Emitter } from "./lib/emitter.ts";
 import { normalizeMaterial } from "./lib/material.ts";
+import { type RpcEmitters, rpcEmitters } from "./lib/rpc-emitters.ts";
 import type {
   AppEvents,
   BroadcastEmitters,
@@ -139,22 +140,6 @@ export class WindowHandle extends Emitter<WindowEvents> {
   }
 }
 
-type RpcEmitters = Record<
-  string,
-  { emit(payload: unknown): void; broadcast(payload: unknown): void }
->;
-
-function rpcEmitters(send: (method: string, payload: unknown) => void): RpcEmitters {
-  return new Proxy({} as RpcEmitters, {
-    get(_t, method: string) {
-      return {
-        emit: (payload: unknown) => send(method, payload),
-        broadcast: (payload: unknown) => send(method, payload),
-      };
-    },
-  });
-}
-
 class Windows {
   #byName = new Map<string, WindowHandle>();
   #byId = new Map<number, WindowHandle>();

package/src/app/lib/rpc-emitters.ts

@@ -0,0 +1,37 @@
+/**
+ * The untyped emitters behind `app.rpc` and a window's `rpc`: `rpc.progress`
+ * sends the event `progress`, and `rpc.window.focused` the nested router's
+ * `window.focused` (docs/api-design.md §3). `app.serve` hands out the same
+ * object typed by the router (BroadcastEmitters).
+ */
+
+import { SEPARATOR } from "../../shared/rpc-paths.ts";
+
+/** An event by name, and the events of a nested router under it (`rpc.window.focused`). */
+export type RpcEmitter = {
+  emit(payload: unknown): void;
+  broadcast(payload: unknown): void;
+} & RpcEmitters;
+
+export interface RpcEmitters {
+  readonly [name: string]: RpcEmitter;
+}
+
+export function rpcEmitters(send: (method: string, payload: unknown) => void): RpcEmitters {
+  const node = (method: string): RpcEmitter =>
+    new Proxy({} as RpcEmitter, {
+      get(_t, prop) {
+        if (prop === "emit" || prop === "broadcast") {
+          return (payload: unknown) => send(method, payload);
+        }
+        // Not a promise, and nothing behind symbols.
+        if (typeof prop !== "string" || prop === "then") return undefined;
+        return node(`${method}${SEPARATOR}${prop}`);
+      },
+    });
+  return new Proxy({} as RpcEmitters, {
+    get(_t, method) {
+      return typeof method === "string" ? node(method) : undefined;
+    },
+  });
+}

package/src/app/types.ts

@@ -41,13 +41,18 @@ export interface WindowOpenOptions extends WindowConfig {
   name?: string;
 }
 
-/** Typed push emitters derived from a router's `event` procedures.
+/** Typed push emitters derived from a router's `event` procedures, nested
+ * routers under their names (`rpc.window.focused.broadcast(...)`).
  * Type-level `any` keeps the caller's router payload inference intact. */
 export type BroadcastEmitters<R extends Router<any>> = R extends Router<infer T>
   ? {
-      [K in keyof T as T[K] extends EventProc<any> ? K : never]: T[K] extends EventProc<infer P>
+      [K in keyof T as T[K] extends EventProc<any> | Router<any>
+        ? K
+        : never]: T[K] extends EventProc<infer P>
         ? { broadcast(payload: P): void }
-        : never;
+        : T[K] extends Router<any>
+          ? BroadcastEmitters<T[K]>
+          : never;
     }
   : never;
 

package/src/client.ts

@@ -6,6 +6,7 @@
  */
 
 import type { EventProc, MutationProc, QueryProc, Router } from "./rpc.ts";
+import { SEPARATOR } from "./shared/rpc-paths.ts";
 
 // Type-level `any` preserves the app router's concrete procedure inference for UI callers.
 export type ClientFor<R extends Router<any>> = R extends Router<infer T>
@@ -16,7 +17,9 @@ export type ClientFor<R extends Router<any>> = R extends Router<infer T>
           ? (input: I) => Promise<Awaited<O>>
           : T[K] extends EventProc<infer P>
             ? { on(listener: (payload: P) => void): () => void }
-            : never;
+            : T[K] extends Router<any>
+              ? ClientFor<T[K]>
+              : never;
     }
   : never;
 
@@ -51,20 +54,44 @@ function transport(): MirinTransport {
  */
 // Type-level `any` keeps `client<AppRouter>()` inference intact.
 export function client<R extends Router<any>>(): ClientFor<R> {
-  const eventCache = new Map<string, { on(l: (p: unknown) => void): () => void }>();
-
+  const nodes = new Map<string, unknown>();
+  const node = (path: string): unknown => {
+    let found = nodes.get(path);
+    if (found === undefined) {
+      found = clientNode(path, node);
+      nodes.set(path, found);
+    }
+    return found;
+  };
   return new Proxy({} as ClientFor<R>, {
     get(_target, prop) {
-      if (typeof prop !== "string") return undefined;
-      // Procedure kind is unknowable from the type-erased proxy; expose a callable
-      // that is *also* event-shaped. The router type makes misuse a compile error.
-      const callable = (input: unknown) => transport().call(prop, input);
-      let ev = eventCache.get(prop);
-      if (!ev) {
-        ev = { on: (listener) => transport().onEvent(prop, listener) };
-        eventCache.set(prop, ev);
+      return typeof prop === "string" ? node(prop) : undefined;
+    },
+  });
+}
+
+/** What a function's caller expects to find on it; anything else is a nested name. */
+const FUNCTION_MEMBERS = new Set(["apply", "bind", "call", "toString"]);
+
+/**
+ * One name in the client, `path` from the root. Procedure kind is unknowable
+ * from the type-erased proxy, so it is all of them at once: callable (a query
+ * or mutation), event-shaped (`.on`), and a router (any other name is a child
+ * at `path.name`). The router type makes misuse a compile error, and
+ * rpc.router keeps nested routers off the names used here.
+ */
+function clientNode(path: string, node: (path: string) => unknown): unknown {
+  const call = (input: unknown) => transport().call(path, input);
+  const on = (listener: (payload: unknown) => void) => transport().onEvent(path, listener);
+  return new Proxy(call, {
+    get(target, prop, receiver) {
+      if (prop === "on") return on;
+      // Not a promise: `await` and promise helpers must not take a node for one.
+      if (prop === "then") return undefined;
+      if (typeof prop !== "string" || FUNCTION_MEMBERS.has(prop)) {
+        return Reflect.get(target, prop, receiver);
       }
-      return Object.assign(callable, ev);
+      return node(`${path}${SEPARATOR}${prop}`);
     },
   });
 }

package/src/config/manifest.ts

@@ -183,6 +183,14 @@ export interface MirinConfig {
    * app worker owns AppKit/CEF (see docs/architecture.md).
    */
   workers?: Record<string, string>;
+  /**
+   * Extra directories bundled verbatim into the app (`Contents/Resources/<name>`
+   * on macOS, `resources/<name>` elsewhere), for assets the main process reads
+   * at runtime: a bundled server, templates, data files. Maps a filename-safe
+   * name to a project-relative directory. Resolve one with `resolveResource(name)`;
+   * under `mirin dev` it points at the source directory.
+   */
+  resources?: Record<string, string>;
   /**
    * Custom URL schemes this app registers as a handler for (macOS
    * `CFBundleURLTypes`), e.g. `["anko"]` so `anko://…` links launch the app (or

package/src/index.ts

@@ -62,7 +62,7 @@ export type { MenuItemTemplate, MenuRole } from "./menu.ts";
 export { menu } from "./menu.ts";
 export type { NotificationOptions } from "./notification.ts";
 export { notification } from "./notification.ts";
-export { NotAttachedError, resolveWorker } from "./runtime.ts";
+export { NotAttachedError, resolveResource, resolveWorker } from "./runtime.ts";
 export { globalShortcut } from "./shortcut.ts";
 export type { SidecarOptions, SidecarProcess } from "./sidecar.ts";
 export { resolveSidecar, sidecar } from "./sidecar.ts";

package/src/logger.ts

@@ -14,7 +14,9 @@
  * Every emitted line is also recorded to the devtools sink (docs/agent-devtools.md).
  */
 
+import { format } from "node:util";
 import { record } from "./devtools/sink.ts";
+import { writeLine } from "./shared/console.ts";
 import { firstError, formatArgs, formatStack } from "./shared/format.ts";
 
 export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
@@ -97,8 +99,7 @@ export class Logger {
     const name = this.#scope ? `[mirin:${this.#scope}]` : "[mirin]";
     const prefix = useColor ? `${COLOR.dim}${name}${COLOR.reset}` : name;
     const tag = useColor ? `${COLOR[level]}${level}${COLOR.reset}` : level;
-    const out = level === "warn" || level === "error" ? console.error : console.log;
-    out(`${prefix} ${tag}`, ...args);
+    writeLine(level === "warn" || level === "error" ? 2 : 1, `${prefix} ${tag} ${format(...args)}`);
     this.#record(level, args);
   }
 

package/src/rpc-server.ts

@@ -9,6 +9,7 @@ import { devtoolsOptions } from "./devtools/options.ts";
 import { record } from "./devtools/sink.ts";
 import type { Procedure, Router, RpcContext } from "./rpc.ts";
 import { formatArg } from "./shared/format.ts";
+import { procedures, SEPARATOR } from "./shared/rpc-paths.ts";
 
 interface SocketData {
   webview: number;
@@ -44,8 +45,8 @@ export type ControlHandler = (frame: ControlFrame, webview: number) => void;
 export class RpcServer {
   readonly token = crypto.randomUUID();
   #server?: ReturnType<typeof Bun.serve>;
-  // Type-level `any` keeps the server able to store any concrete app router.
-  #router?: Router<any>;
+  /** The served router's procedures by path (`greet`, `window.min`). */
+  #procedures = new Map<string, Procedure>();
   #control?: ControlHandler;
   #sockets = new Set<ServerWebSocket<SocketData>>();
 
@@ -96,16 +97,16 @@ export class RpcServer {
     await server.stop(true);
   }
 
-  /** Type-level `any` keeps the caller's concrete router shape. */
+  /** Serve `router`, replacing the one served before (compose routers to serve
+   *  several). Type-level `any` keeps the caller's concrete router shape. */
   setRouter(router: Router<any>): void {
-    this.#router = router;
+    this.#procedures = procedures(router);
   }
 
-  /** The registered procedures, for the inspector's `/state`: a tool can discover
-   *  the RPC surface without reading source. */
+  /** The registered procedures by path, for the inspector's `/state`: a tool can
+   *  discover the RPC surface without reading source. */
   routes(): { name: string; type: string }[] {
-    const routes: Record<string, Procedure> = this.#router?.routes ?? {};
-    return Object.entries(routes).map(([name, proc]) => ({ name, type: proc.type }));
+    return [...this.#procedures].map(([name, proc]) => ({ name, type: proc.type }));
   }
 
   /** Register the handler for internal `mirin:*` control actions (e.g. window drag). */
@@ -127,6 +128,19 @@ export class RpcServer {
     }
   }
 
+  /** Why `method` can't be called: unknown, an event, or a router rather than one of its procedures. */
+  #notCallable(method: string, proc: Procedure | undefined): string {
+    if (proc?.type === "event") {
+      return `${method} is an event: the main process emits it and the UI listens with .on()`;
+    }
+    const prefix = `${method}${SEPARATOR}`;
+    const inside = [...this.#procedures.keys()].filter((name) => name.startsWith(prefix));
+    if (inside.length > 0) {
+      return `no such procedure: ${method} is a router; call one of its procedures (${inside.slice(0, 5).join(", ")}${inside.length > 5 ? ", …" : ""})`;
+    }
+    return `no such procedure: ${method}`;
+  }
+
   async #onMessage(ws: ServerWebSocket<SocketData>, raw: string | Buffer): Promise<void> {
     let frame: IncomingFrame;
     try {
@@ -148,9 +162,9 @@ export class RpcServer {
     const webview = ws.data.webview;
     traceRequest(frame, webview);
 
-    const proc = this.#router?.routes[frame.method];
+    const proc = this.#procedures.get(frame.method);
     if (!proc || (proc.type !== "query" && proc.type !== "mutation")) {
-      const error = `no such procedure: ${frame.method}`;
+      const error = this.#notCallable(frame.method, proc);
       traceFailure(frame, webview, 0, error, "unknown-procedure");
       reply(false, { error });
       return;

package/src/rpc.ts

@@ -3,9 +3,13 @@
  *
  * Imported by BOTH the main process (handlers run here, in the Bun Worker)
  * and UI code (type-only, via `client<Router>()` from mirin/client).
- * The router is global; handlers learn their caller from `ctx`.
+ * The router is global; handlers learn their caller from `ctx`. Routers nest:
+ * a router's routes can be other routers, and their procedures are called by
+ * path (`api.window.min()`, `window.min` on the wire).
  */
 
+import { procedures } from "./shared/rpc-paths.ts";
+
 export interface RpcContext {
   /** Name of the calling window, if it was opened with one. */
   window?: string;
@@ -35,14 +39,29 @@ export interface EventProc<P> {
 // no runtime value is widened through this union.
 export type Procedure = QueryProc<any, any> | MutationProc<any, any> | EventProc<any>;
 
-export interface Router<T extends Record<string, Procedure> = Record<string, Procedure>> {
+/** What a router holds: procedures, and other routers under their own names. */
+export interface Routes {
+  // Type-level `any` keeps each nested router's own procedure types.
+  readonly [name: string]: Procedure | Router<any>;
+}
+
+export interface Router<T extends Routes = Routes> {
   readonly type: "router";
   readonly routes: T;
 }
 
 export const rpc = {
-  router<T extends Record<string, Procedure>>(routes: T): Router<T> {
-    return { type: "router", routes };
+  /**
+   * Define a router. Nested routers keep their procedures apart
+   * (`window.close` and `install.close` are two procedures). Throws when two
+   * procedures end up with the same path, or when a nested router uses a name
+   * the client needs (`on`, `then`, `emit`, `broadcast`, `apply`, `bind`,
+   * `call`, `toString`).
+   */
+  router<T extends Routes>(routes: T): Router<T> {
+    const router: Router<T> = { type: "router", routes };
+    procedures(router);
+    return router;
   },
 
   /** Request/response, semantically a read. Runtime-identical to mutation in the MVP. */

package/src/runtime.ts

@@ -4,12 +4,13 @@
  * API lives in app/index.ts and the feature modules, which subscribe here.
  */
 
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { workerData } from "node:worker_threads";
 import type { DevtoolsConfig, WindowConfig } from "./config/index.ts";
 import { parseDevtoolsConfig } from "./devtools/options.ts";
 import { Core } from "./native.ts";
 import { RpcServer } from "./rpc-server.ts";
+import { installWorkerConsole } from "./shared/console.ts";
 
 export interface ManifestWindowConfig extends WindowConfig {
   name: string;
@@ -32,6 +33,8 @@ export interface Runtime {
   sidecarDir?: string;
   /** Dir holding bundled extra-worker JS (for `resolveWorker`). */
   workersDir?: string;
+  /** Declared resource directories: source paths in dev, bundle-relative names in prod. */
+  resources: Record<string, string>;
   /** `devtools` block from the manifest, resolved by the devtools module. */
   devtools?: DevtoolsConfig;
 }
@@ -137,7 +140,11 @@ export function claimBootSlot(): boolean {
 export function boot(): void {
   const data = (workerData ?? {}) as {
     corePath?: string;
-    manifest?: { windows?: Record<string, WindowConfig>; devtools?: unknown };
+    manifest?: {
+      windows?: Record<string, WindowConfig>;
+      devtools?: unknown;
+      resources?: Record<string, string>;
+    };
     id?: string;
     devUrl?: string;
     resourcesDir?: string;
@@ -146,6 +153,7 @@ export function boot(): void {
   };
   const corePath = data.corePath ?? process.env.MIRIN_CORE;
   if (!corePath) return; // not under the host; the API stays detached
+  installWorkerConsole();
   if (!claimBootSlot()) {
     console.error(
       "[mirin] refusing to boot a second mirinjs copy in this process — the bundle " +
@@ -199,6 +207,7 @@ export function boot(): void {
     corePath,
     sidecarDir: data.sidecarDir,
     workersDir: data.workersDir,
+    resources: data.manifest?.resources ?? {},
     devtools: parseDevtoolsConfig(data.manifest?.devtools),
   };
   core.onEvent(dispatch);
@@ -210,6 +219,19 @@ export function boot(): void {
  * Works in `mirin dev` and the built `.app`. Extra workers run off the main
  * thread and must not call window/native APIs.
  */
+/**
+ * Resolve a bundled resource directory (declared in `mirin.config.ts` `resources`)
+ * to an absolute path. Under `mirin dev` this is the source directory; in a built
+ * app it lives under the bundle's resources directory.
+ */
+export function resolveResource(name: string): string {
+  const entry = current?.resources[name];
+  if (!current || entry === undefined) throw new NotAttachedError(`resolveResource("${name}")`);
+  if (isAbsolute(entry)) return entry;
+  if (!current.resourcesDir) throw new NotAttachedError(`resolveResource("${name}")`);
+  return join(current.resourcesDir, entry);
+}
+
 export function resolveWorker(name: string): string {
   const dir = current?.workersDir;
   if (!dir) throw new NotAttachedError("resolveWorker");

package/src/shared/console.ts

@@ -0,0 +1,46 @@
+import { writeSync } from "node:fs";
+import { format } from "node:util";
+import { record } from "../devtools/sink.ts";
+import type { DevEventLevel } from "../devtools/types.ts";
+import { firstError, formatArgs, formatStack } from "./format.ts";
+
+export type LineWriter = (fd: 1 | 2, line: string) => void;
+
+// The app Worker's console normally hands output to the main thread, which sits
+// inside CEF's message loop for the life of the app, so nothing is ever written.
+// A direct fd write from the Worker thread bypasses that.
+export function writeLine(fd: 1 | 2, line: string): void {
+  try {
+    writeSync(fd, line.endsWith("\n") ? line : `${line}\n`);
+  } catch {
+    // A closed pipe (parent gone) must not take the app down with a log line.
+  }
+}
+
+const CONSOLE_LEVELS = {
+  log: "info",
+  info: "info",
+  debug: "debug",
+  warn: "warn",
+  error: "error",
+} as const satisfies Record<string, DevEventLevel>;
+
+export type ConsoleMethod = keyof typeof CONSOLE_LEVELS;
+
+/** Route `console.*` from the Worker to fd 1/2 directly and into the devtools sink. */
+export function installWorkerConsole(write: LineWriter = writeLine): void {
+  for (const method of Object.keys(CONSOLE_LEVELS) as ConsoleMethod[]) {
+    const level = CONSOLE_LEVELS[method];
+    console[method] = (...args: unknown[]) => {
+      write(level === "warn" || level === "error" ? 2 : 1, format(...args));
+      const error = firstError(args);
+      record({
+        src: "main",
+        level,
+        type: "console",
+        msg: formatArgs(args),
+        data: { method, ...(error !== undefined ? { stack: formatStack(error) } : {}) },
+      });
+    };
+  }
+}

package/src/shared/rpc-paths.ts

@@ -0,0 +1,83 @@
+/**
+ * Nested routers on the wire (docs/api-design.md §3). A router can hold other
+ * routers; each procedure is then named by its path, joined with dots
+ * (`window.min`), which is the method name a request frame carries. Flat
+ * routers keep their names as they were.
+ *
+ * The UI client and the main-process emitters are proxies that only know the
+ * router's type, so inside a nested router a few names belong to them: on a
+ * client node `on` subscribes, `then` would make it look like a promise, and
+ * `apply`, `bind`, `call`, `toString` keep it a normal function; on an emitter
+ * node `emit` and `broadcast` send. A nested router can't use those names.
+ * Top-level names are not restricted, as before.
+ */
+
+import type { Procedure, Router } from "../rpc.ts";
+
+export const SEPARATOR = ".";
+
+export const RESERVED_NESTED_NAMES: ReadonlySet<string> = new Set([
+  "on",
+  "then",
+  "emit",
+  "broadcast",
+  "apply",
+  "bind",
+  "call",
+  "toString",
+]);
+
+const KINDS = new Set(["query", "mutation", "event"]);
+
+export function isRouter(value: unknown): value is Router {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as { type?: unknown; routes?: unknown };
+  return (
+    candidate.type === "router" && typeof candidate.routes === "object" && candidate.routes !== null
+  );
+}
+
+function isProcedure(value: unknown): value is Procedure {
+  if (typeof value !== "object" || value === null) return false;
+  return KINDS.has(String((value as { type?: unknown }).type));
+}
+
+/**
+ * Every procedure of `router` by its full path. Throws on a value that is not
+ * a procedure or a router, on two procedures with the same path (a flat
+ * `"window.min"` beside a nested `window: { min }`), on a router that contains
+ * itself, and on a reserved name inside a nested router.
+ */
+export function procedures(router: Router): Map<string, Procedure> {
+  const found = new Map<string, Procedure>();
+  const walk = (current: Router, prefix: string, open: Set<Router>): void => {
+    open.add(current);
+    for (const [name, value] of Object.entries(current.routes)) {
+      const path = prefix === "" ? name : `${prefix}${SEPARATOR}${name}`;
+      if (prefix !== "" && RESERVED_NESTED_NAMES.has(name)) {
+        throw new Error(
+          `rpc.router: "${path}" can't be used inside a nested router: ${[...RESERVED_NESTED_NAMES].join(", ")} are taken by the client and the event emitters. Rename it.`,
+        );
+      }
+      if (isRouter(value)) {
+        if (open.has(value)) throw new Error(`rpc.router: "${path}" contains itself`);
+        walk(value, path, open);
+        continue;
+      }
+      if (!isProcedure(value)) {
+        throw new Error(
+          `rpc.router: "${path}" is not a procedure or a router (use rpc.query, rpc.mutation, rpc.event, or rpc.router)`,
+        );
+      }
+      if (found.has(path)) {
+        throw new Error(
+          `rpc.router: two procedures are named "${path}" (a nested router's procedures are named <router>${SEPARATOR}<procedure>). Rename one.`,
+        );
+      }
+      found.set(path, value);
+    }
+    open.delete(current);
+  };
+  walk(router, "", new Set());
+  return found;
+}

package/src/updater/lib/version.ts

@@ -0,0 +1,45 @@
+// Loose semver: "1.2.3", "v1.2.3", "1.2.3-nightly.4". Numeric segments compare
+// as numbers, anything else lexically; a prerelease sorts below its release.
+function parse(version: string): { main: string[]; pre: string[] } {
+  const trimmed = version.trim().replace(/^v/i, "");
+  const plus = trimmed.indexOf("+");
+  const noBuild = plus === -1 ? trimmed : trimmed.slice(0, plus);
+  const dash = noBuild.indexOf("-");
+  const main = (dash === -1 ? noBuild : noBuild.slice(0, dash)).split(".");
+  const pre = dash === -1 ? [] : noBuild.slice(dash + 1).split(".");
+  return { main, pre };
+}
+
+function compareSegment(a: string | undefined, b: string | undefined): number {
+  if (a === undefined && b === undefined) return 0;
+  if (a === undefined) return -1;
+  if (b === undefined) return 1;
+  const na = /^\d+$/.test(a) ? Number(a) : null;
+  const nb = /^\d+$/.test(b) ? Number(b) : null;
+  if (na !== null && nb !== null) return na === nb ? 0 : na < nb ? -1 : 1;
+  if (na !== null) return -1;
+  if (nb !== null) return 1;
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+
+/** Negative when `a` is older than `b`, zero when equal, positive when newer. */
+export function compareVersions(a: string, b: string): number {
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < Math.max(pa.main.length, pb.main.length); i++) {
+    const c = compareSegment(pa.main[i] ?? "0", pb.main[i] ?? "0");
+    if (c !== 0) return c;
+  }
+  if (pa.pre.length === 0 && pb.pre.length === 0) return 0;
+  if (pa.pre.length === 0) return 1;
+  if (pb.pre.length === 0) return -1;
+  for (let i = 0; i < Math.max(pa.pre.length, pb.pre.length); i++) {
+    const c = compareSegment(pa.pre[i], pb.pre[i]);
+    if (c !== 0) return c;
+  }
+  return 0;
+}
+
+export function isNewerVersion(candidate: string, current: string): boolean {
+  return compareVersions(candidate, current) > 0;
+}

package/src/updater/updater.ts

@@ -25,6 +25,7 @@ import { downloadVerifiedArtifact, verifyFileSha256 } from "./lib/integrity.ts";
 import { parseManifest } from "./lib/manifest.ts";
 import { IS_LINUX, IS_MAC, IS_WINDOWS, platformName } from "./lib/platform.ts";
 import { artifactUrl, assertTrustedUpdateUrl, trustedBaseUrl } from "./lib/urls.ts";
+import { isNewerVersion } from "./lib/version.ts";
 import type {
   Listener,
   Manifest,
@@ -85,7 +86,7 @@ export class Updater {
         platform: platformName(),
         arch: process.arch,
       });
-      if (!m.version || m.version === v.version) {
+      if (!m.version || !isNewerVersion(m.version, v.version)) {
         this.#manifest = null;
         this.#setStatus("idle");
         return null;