lecodes-cli 2.0.1 → 2.0.3

package/src/hosts/archives.ts

@@ -0,0 +1,32 @@
+import pkg from "../../package.json"
+
+/* The peers that are no packages of npm's: the headless host and the editors go out as ARCHIVES in
+ * the releases bucket (the core's scripts/release/archives.ts says why), installed by their url —
+ * `npm install <url>` puts the package in place under its own name.
+ *
+ * A url names one version, and which one is this CLI's to say: the headless host at the CLI's own
+ * version (one ABI set), an editor at the version the CLI was published against (its peer range,
+ * snapped to it by scripts/sync-peer-versions.ts). */
+
+export const ARCHIVED_PEERS: ReadonlySet<string> = new Set(["lecodes-headless", "lecodes-design", "lecodes-3d-editor"])
+
+const BASE = "https://storage.yandexcloud.net/le-codes/releases/packages"
+/** LECODES_PACKAGES_URL moves it (a mirror, a bucket of one's own). */
+export const packagesBase = (): string => (process.env.LECODES_PACKAGES_URL || BASE).replace(/\/$/, "")
+
+export const archiveUrl = (name: string, version: string): string => `${packagesBase()}/${name}/${name}-${version}.tgz`
+
+/** The version of an archived peer this CLI installs; null for a peer that is none. */
+export const archivedVersion = (name: string): string | null => {
+  if (!ARCHIVED_PEERS.has(name)) return null
+  if (name === "lecodes-headless") return pkg.version
+  const range = (pkg.peerDependencies as Record<string, string> | undefined)?.[name]
+  const version = range?.replace(/^[\^~>=\s]+/, "")
+  return version && /^\d+\.\d+\.\d+/.test(version) ? version : null
+}
+
+/** What an archived peer is installed by; null for a peer that is none. */
+export const archiveSpec = (name: string): string | null => {
+  const version = archivedVersion(name)
+  return version ? archiveUrl(name, version) : null
+}

package/src/hosts/liteBrowser.mjs

@@ -0,0 +1,86 @@
+// The browser of `lecodes test --lite`, as a process of its own: headless Chromium through
+// Playwright, driven over stdin / stdout in JSON lines (liteRunner.ts is the other end).
+//
+// A process of NODE, whatever runs the CLI: Playwright does not start a browser under Bun on
+// Windows (its launch never returns), and the CLI runs under Bun in a checkout.
+//
+//   → { "id": 1, "op": "open", "args": { "width": 390, "height": 844 } }
+//   ← { "id": 1, "ok": true, "value": null }
+//   ← { "event": "console", "level": "log", "text": "…" }       whatever the page says, as it says it
+//
+// One page at a time: `open` closes the one before it.
+import { createRequire } from "node:module"
+import { createInterface } from "node:readline"
+import { pathToFileURL } from "node:url"
+
+const send = (message) => process.stdout.write(JSON.stringify(message) + "\n")
+
+let browser = null
+let context = null
+let page = null
+
+const ops = {
+  /** `from`: where Playwright may be, as files to resolve it from. */
+  async launch({ from }) {
+    let chromium = null
+    for (const base of from) {
+      try {
+        const pw = await import(pathToFileURL(createRequire(base).resolve("playwright")).href)
+        chromium = pw.chromium ?? pw.default?.chromium
+        if (chromium) break
+      } catch { /* not there */ }
+    }
+    if (!chromium) throw new Error("NO_PLAYWRIGHT")
+    browser = await chromium.launch()
+    return null
+  },
+  async open({ width, height }) {
+    await context?.close().catch(() => {})
+    context = await browser.newContext({ viewport: { width, height }, deviceScaleFactor: 1 })
+    page = await context.newPage()
+    page.on("console", (message) => send({ event: "console", level: message.type(), text: message.text() }))
+    page.on("pageerror", (error) => send({ event: "console", level: "error", text: String(error) }))
+    return null
+  },
+  async goto({ url }) { await page.goto(url); return null },
+  async waitFor({ expression, timeout }) { await page.waitForFunction(expression, null, { timeout }); return null },
+  evaluate: ({ expression }) => page.evaluate(expression),
+  async timeout({ ms }) { await page.waitForTimeout(ms); return null },
+  async mouse({ action, x, y }) {
+    if (action === "move") await page.mouse.move(x, y)
+    else if (action === "down") await page.mouse.down()
+    else if (action === "up") await page.mouse.up()
+    else if (action === "wheel") await page.mouse.wheel(x, y)
+    return null
+  },
+  async keyboard({ action, text }) {
+    if (action === "type") await page.keyboard.type(text)
+    else if (action === "down") await page.keyboard.down(text)
+    else if (action === "up") await page.keyboard.up(text)
+    return null
+  },
+  async screenshot({ path, clip }) { await page.screenshot({ path, ...(clip ? { clip } : {}) }); return null },
+  async close() {
+    await context?.close().catch(() => {})
+    await browser?.close().catch(() => {})
+    setTimeout(() => process.exit(0), 0)
+    return null
+  },
+}
+
+// One request at a time, in the order they came: the page is one.
+let chain = Promise.resolve()
+createInterface({ input: process.stdin }).on("line", (line) => {
+  let request
+  try { request = JSON.parse(line) } catch { return }
+  chain = chain.then(async () => {
+    try {
+      const op = ops[request.op]
+      if (!op) throw new Error(`no such op: ${request.op}`)
+      send({ id: request.id, ok: true, value: (await op(request.args ?? {})) ?? null })
+    } catch (e) {
+      send({ id: request.id, ok: false, error: e instanceof Error ? e.message.split("\n")[0] : String(e) })
+    }
+  })
+})
+process.stdin.on("end", () => { void ops.close() })

package/src/hosts/liteRunner.ts

@@ -0,0 +1,386 @@
+import { spawn, type ChildProcess } from "node:child_process"
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { createServer } from "node:net"
+import { dirname, join } from "node:path"
+import { createInterface } from "node:readline"
+import { CliError } from "../cli"
+import { startDevServer, type DevServer } from "../dev/devServer"
+import type { Manifest } from "../project/manifest"
+import { distRoot } from "./distRoot"
+import { peersDir } from "./peers"
+import type { DesktopPlan } from "./desktopScript"
+// (a relative source import, as desktopScript.ts does: lecodes-headless is an optional peer)
+import { findDumpTarget, parseTreeDump } from "../../../../runtime/headless/src/headless/paintDump"
+
+/*
+ * `lecodes test --lite`: a flow scenario on WEB LITE, in a real browser. The scenario is the one
+ * every host takes; it is translated by desktopScript.ts into the native host's command file, and
+ * this module is a third reader of those commands — it plays them on the page of Web Lite in
+ * headless Chromium (Playwright: the page's own pointer and key events, nothing injected past
+ * them) and answers in the native host's words (`[script] #<line> done <op>`), so the verdict is
+ * desktopScript.ts's `evaluateDesktopRun`, the same rules as on the desktop.
+ *
+ * What differs is the CLOCK: a page runs on the browser's time, not on a fixed step. `frames N` /
+ * `wait ms` wait that long in real time — and a step that expects a log line is through as soon
+ * as the line is there, with room past its frames for a page that is slower than a fixed clock.
+ *
+ * The browser is a process of its own (liteBrowser.mjs, run by Node): Playwright does not start
+ * one under Bun on Windows.
+ */
+
+type Clip = { x: number, y: number, width: number, height: number }
+
+/** The browser, as this module drives it: one page at a time. */
+type Driver = {
+  open(width: number, height: number, onConsole: (level: string, text: string) => void): Promise<void>
+  goto(url: string): Promise<void>
+  waitFor(expression: string, timeout: number): Promise<void>
+  evaluate<T>(expression: string): Promise<T>
+  timeout(ms: number): Promise<void>
+  mouse(action: "move" | "down" | "up" | "wheel", x?: number, y?: number): Promise<void>
+  keyboard(action: "type" | "down" | "up", text: string): Promise<void>
+  screenshot(path: string, clip: Clip | null): Promise<void>
+  close(): Promise<void>
+}
+
+const FRAME_MS = 16
+/** How long past its frames a step that expects a log line may wait for it. */
+const LOG_SLACK_MS = 3000
+
+const NO_NODE = "--lite needs Node on the PATH: the browser is driven from a Node process."
+const NO_PLAYWRIGHT = "--lite runs the flows in a browser and needs Playwright: `npm install -D playwright` in the project, then `npx playwright install chromium` once."
+
+/** Start the browser's process and its browser. */
+const startDriver = async (): Promise<Driver> => {
+  const script = join(distRoot, "src", "hosts", "liteBrowser.mjs")
+  if (!existsSync(script)) throw new CliError("--lite is not available in this build of the CLI (its browser driver ships with the npm package).")
+  const child: ChildProcess = spawn("node", [script], { stdio: ["pipe", "pipe", "inherit"] })
+
+  const waiting = new Map<number, { resolve: (value: unknown) => void, reject: (error: Error) => void }>()
+  let onConsole: (level: string, text: string) => void = () => {}
+  let next = 1
+  let dead: Error | null = null
+  const fail = (error: Error) => {
+    dead = dead ?? error
+    for (const w of waiting.values()) w.reject(dead)
+    waiting.clear()
+  }
+  child.on("error", () => fail(new CliError(NO_NODE)))
+  child.on("exit", () => fail(new Error("the browser's process ended")))
+  createInterface({ input: child.stdout! }).on("line", (line) => {
+    let message: { id?: number, ok?: boolean, value?: unknown, error?: string, event?: string, level?: string, text?: string }
+    try { message = JSON.parse(line) } catch { return }
+    if (message.event === "console") { onConsole(message.level ?? "log", message.text ?? ""); return }
+    const w = message.id !== undefined ? waiting.get(message.id) : undefined
+    if (!w) return
+    waiting.delete(message.id!)
+    if (message.ok) w.resolve(message.value)
+    else w.reject(new Error(message.error ?? "failed"))
+  })
+  const call = <T = void>(op: string, args: object = {}): Promise<T> => new Promise<T>((resolve, reject) => {
+    if (dead) { reject(dead); return }
+    const id = next++
+    waiting.set(id, { resolve: resolve as (value: unknown) => void, reject })
+    child.stdin!.write(JSON.stringify({ id, op, args }) + "\n")
+  })
+
+  // Playwright, from where it may be: the project, the CLI, the CLI's peers, a checkout's gl-lite.
+  const from = [
+    join(process.cwd(), "package.json"),
+    join(distRoot, "package.json"),
+    join(peersDir(), "package.json"),
+    join(distRoot, "..", "..", "engines", "gl-lite", "package.json"),
+  ]
+  try {
+    await call("launch", { from })
+  } catch (e) {
+    child.kill()
+    if (e instanceof CliError) throw e
+    const message = e instanceof Error ? e.message : String(e)
+    throw new CliError(message === "NO_PLAYWRIGHT" ? NO_PLAYWRIGHT : `Chromium did not start (${message}) — run "npx playwright install chromium" once.`)
+  }
+
+  return {
+    open(width, height, listener) { onConsole = listener; return call("open", { width, height }) },
+    goto: (url) => call("goto", { url }),
+    waitFor: (expression, timeout) => call("waitFor", { expression, timeout }),
+    evaluate: <T>(expression: string) => call<T>("evaluate", { expression }),
+    timeout: (ms) => call("timeout", { ms }),
+    mouse: (action, x, y) => call("mouse", { action, x, y }),
+    keyboard: (action, text) => call("keyboard", { action, text }),
+    screenshot: (path, clip) => call("screenshot", { path, clip }),
+    async close() {
+      await call("close").catch(() => {})
+      child.kill()
+    },
+  }
+}
+
+const freePort = (): Promise<number> => new Promise((resolve, reject) => {
+  const probe = createServer()
+  probe.once("error", reject)
+  probe.listen(0, "127.0.0.1", () => {
+    const address = probe.address()
+    const port = typeof address === "object" && address ? address.port : 0
+    probe.close(() => resolve(port))
+  })
+})
+
+export type LiteRunOptions = { width: number, height: number, onConsole?: (level: string, text: string) => void }
+
+export type LiteSession = {
+  /** Play one case; the host's output as `evaluateDesktopRun` reads it. */
+  run(plan: DesktopPlan, options: LiteRunOptions): Promise<string>
+  close(): Promise<void>
+}
+
+/** The project compiled and served with the page of Web Lite, and a browser to open it in. */
+export const startLiteSession = async (options: { root: string, manifest: Manifest | null, name: string, lite: string, entry?: string }): Promise<LiteSession> => {
+  const port = await freePort()
+  const server: DevServer = await startDevServer({
+    root: options.root, manifest: options.manifest, name: options.name, lite: options.lite,
+    origin: `http://127.0.0.1:${port}`, bind: "127.0.0.1", port, token: "test", entryOverride: options.entry,
+  })
+  const compiled = await server.recompile()
+  if (!compiled.ok) { server.close(); throw new CliError(`Compile failed:\n${compiled.error}`) }
+
+  let driver: Driver
+  try {
+    driver = await startDriver()
+  } catch (e) {
+    server.close()
+    throw e
+  }
+
+  return {
+    run: (plan, runOptions) => runPlan(driver, `${server.liteUrl}?dev=..&test`, plan, runOptions),
+    async close() {
+      await driver.close()
+      server.close()
+    },
+  }
+}
+
+// ---- the commands ------------------------------------------------------------------------------------------------
+
+type Arg = number | string
+
+/** The arguments of a command line: numbers and quoted names (`"` and `\` escaped). */
+export const parseArgs = (rest: string): Arg[] => {
+  const out: Arg[] = []
+  let i = 0
+  while (i < rest.length) {
+    if (rest[i] === " ") { i++; continue }
+    if (rest[i] === '"') {
+      let text = ""
+      i++
+      while (i < rest.length && rest[i] !== '"') {
+        if (rest[i] === "\\") i++
+        text += rest[i] ?? ""
+        i++
+      }
+      i++
+      out.push(text)
+      continue
+    }
+    const end = rest.indexOf(" ", i)
+    const token = rest.slice(i, end < 0 ? rest.length : end)
+    const n = Number(token)
+    out.push(Number.isFinite(n) && token !== "" ? n : token)
+    i = end < 0 ? rest.length : end
+  }
+  return out
+}
+
+const unwire = (text: string): string => text.replace(/\\(n|\\)/g, (_, c: string) => (c === "n" ? "\n" : "\\"))
+
+const LEVEL: Record<string, string> = { log: "DEBUG", debug: "DEBUG", info: "INFO", warning: "WARN", warn: "WARN", error: "ERROR" }
+
+// What is on show: the root's children that the router did not cover.
+const ON_SHOW = ".lc-root > .lc:not(.lc-covered)"
+
+const FRAME = "new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(() => r(null))))"
+
+const FILL_VALUE = `(f) => f.type === "email" ? "test@example.com" : f.type === "tel" ? "5550100" : f.inputMode === "numeric" || f.inputMode === "decimal" ? "1" : f.type === "date" ? "2026-01-01" : f.type === "time" ? "12:00" : "test"`
+
+const runPlan = async (driver: Driver, url: string, plan: DesktopPlan, options: LiteRunOptions): Promise<string> => {
+  const output: string[] = []
+  const seen: string[] = []
+  const say = (line: string) => { output.push(line) }
+
+  await driver.open(options.width, options.height, (level, text) => {
+    seen.push(text)
+    say(`[${LEVEL[level] ?? "DEBUG"}] ${text}`)
+    options.onConsole?.(level, text)
+  })
+
+  // Which step a line belongs to: a step that expects a log line waits for it.
+  const expectOf = new Map<number, string>()
+  for (const step of plan.steps) if (step.expectLog !== undefined) for (const line of step.lines) expectOf.set(line, step.expectLog)
+
+  const dump = () => driver.evaluate<string>("window.lecodesTest.dump()")
+  const rectOf = (id: number) => driver.evaluate<[number, number, number, number] | null>(`window.lecodesTest.rect(${id})`)
+  const nodeOf = async (name: string) => {
+    const node = findDumpTarget(parseTreeDump(await dump()), name)
+    if (!node) throw new Error(`no element "${name}" on the screen`)
+    return node
+  }
+  /** The point of a target: a name resolved in the tree as every host resolves it, or a point. */
+  const pointOf = async (args: Arg[], at: number): Promise<{ point: [number, number], next: number }> => {
+    const first = args[at]
+    if (typeof first === "number") return { point: [first, Number(args[at + 1])], next: at + 2 }
+    const rect = await rectOf((await nodeOf(String(first))).id)
+    if (!rect || rect[2] === 0 || rect[3] === 0) throw new Error(`"${first}" is not laid out`)
+    return { point: [rect[0] + rect[2] / 2, rect[1] + rect[3] / 2], next: at + 1 }
+  }
+  const frame = () => driver.evaluate<null>(FRAME)
+  /** Wait `ms`; a line that expects a log is through when the log is there. */
+  const waitFor = async (ms: number, line: number) => {
+    const expected = expectOf.get(line)
+    if (expected === undefined) { await driver.timeout(ms); return }
+    const until = Date.now() + ms + LOG_SLACK_MS
+    while (Date.now() < until) {
+      if (seen.some((text) => text.includes(expected))) return
+      await driver.timeout(FRAME_MS)
+    }
+  }
+
+  let clip: Clip | null = null
+
+  const play = async (op: string, rest: string, line: number): Promise<void> => {
+    const args = parseArgs(rest)
+    switch (op) {
+      case "frames": await waitFor(Math.max(0, Number(args[0])) * FRAME_MS, line); return
+      case "wait": await waitFor(Math.max(0, Number(args[0])), line); return
+      case "tap": {
+        const { point } = await pointOf(args, 0)
+        await driver.mouse("move", point[0], point[1])
+        await driver.mouse("down")
+        await driver.mouse("up")
+        await frame()
+        return
+      }
+      case "hold": {
+        const { point, next } = await pointOf(args, 0)
+        await driver.mouse("move", point[0], point[1])
+        await driver.mouse("down")
+        await driver.timeout(Number(args[next]) || 0)
+        await driver.mouse("up")
+        await frame()
+        return
+      }
+      case "drag": {
+        const from = await pointOf(args, 0)
+        const to = await pointOf(args, from.next)
+        const ms = Number(args[to.next]) || 300
+        const steps = Math.max(2, Math.round(ms / FRAME_MS))
+        await driver.mouse("move", from.point[0], from.point[1])
+        await driver.mouse("down")
+        for (let i = 1; i <= steps; i++) {
+          const t = i / steps
+          await driver.mouse("move", from.point[0] + (to.point[0] - from.point[0]) * t, from.point[1] + (to.point[1] - from.point[1]) * t)
+          await driver.timeout(ms / steps)
+        }
+        await driver.mouse("up")
+        await frame()
+        return
+      }
+      case "mouseto": {
+        const { point } = await pointOf(args, 0)
+        await driver.mouse("move", point[0], point[1])
+        await frame()
+        return
+      }
+      case "type": await driver.keyboard("type", unwire(rest)); await frame(); return
+      case "fill": {
+        const value = rest === "" ? undefined : unwire(rest)
+        // every empty field on show, in the tree's order: what the native hosts fill
+        const count = await driver.evaluate<number>(`(() => {
+          window.__lecodesFill = [...document.querySelectorAll("${ON_SHOW} input.lc, ${ON_SHOW} textarea.lc")].filter((f) => f.value === "")
+          return window.__lecodesFill.length
+        })()`)
+        for (let i = 0; i < count; i++) {
+          const text = value ?? await driver.evaluate<string>(`(${FILL_VALUE})(window.__lecodesFill[${i}])`)
+          await driver.evaluate(`window.__lecodesFill[${i}].focus()`)
+          await driver.keyboard("type", text)
+        }
+        await frame()
+        return
+      }
+      case "scroll": {
+        const by = Number(args[0])
+        const name = typeof args[1] === "string" ? args[1] : null
+        const target = name === null
+          ? `document.querySelector("${ON_SHOW} .lc-scrollable, ${ON_SHOW} .lc-vlist")`
+          : `document.querySelector('[data-node="${(await nodeOf(name)).id}"]')`
+        const found = await driver.evaluate<boolean>(`(() => {
+          const el = ${target}
+          if (!el) return false
+          const style = getComputedStyle(el)
+          if (style.overflowX !== "hidden" && style.overflowY === "hidden") el.scrollLeft += ${by}
+          else el.scrollTop += ${by}
+          return true
+        })()`)
+        if (!found) throw new Error(name === null ? "no scrollable on the screen" : `"${name}" is not there`)
+        await frame()
+        return
+      }
+      case "key": {
+        await driver.keyboard("down", String(args[0]))
+        await driver.timeout(Number(args[1]) || 0)
+        await driver.keyboard("up", String(args[0]))
+        return
+      }
+      case "keydown": await driver.keyboard("down", String(args[0])); return
+      case "keyup": await driver.keyboard("up", String(args[0])); return
+      case "wheel": await driver.mouse("wheel", Number(args[0]) * 100, Number(args[1]) * 100); await frame(); return
+      case "dump": {
+        const file = rest.trim()
+        mkdirSync(dirname(file), { recursive: true })
+        writeFileSync(file, await dump())
+        return
+      }
+      case "clip": {
+        if (rest.trim() === "off") { clip = null; return }
+        if (typeof args[0] === "number") { clip = { x: args[0], y: Number(args[1]), width: Number(args[2]), height: Number(args[3]) }; return }
+        const rect = await rectOf((await nodeOf(String(args[0]))).id)
+        if (!rect) throw new Error(`"${args[0]}" is not laid out`)
+        clip = { x: rect[0], y: rect[1], width: rect[2], height: rect[3] }
+        return
+      }
+      case "shot": {
+        const file = rest.trim()
+        mkdirSync(dirname(file), { recursive: true })
+        await driver.screenshot(file, clip)
+        return
+      }
+      default:
+        throw new Error(`"${op}" is not available on Web Lite (it has no 3D scene, no gamepad)`)
+    }
+  }
+
+  try {
+    await driver.goto(url)
+    await driver.waitFor("window.lecodesTest && window.lecodesTest.ready === true", 20000)
+    say("[script] loaded")
+    const lines = plan.text.split("\n")
+    for (let i = 0; i < lines.length; i++) {
+      const text = lines[i]!.trim()
+      if (text === "" || text.startsWith("#")) continue
+      const space = text.indexOf(" ")
+      const op = space < 0 ? text : text.slice(0, space)
+      const rest = space < 0 ? "" : text.slice(space + 1)
+      try {
+        await play(op, rest, i + 1)
+        say(`[script] #${i + 1} done ${op}`)
+      } catch (e) {
+        say(`[script] #${i + 1} error ${op}: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`)
+        break
+      }
+    }
+    say("[script] end")
+  } catch (e) {
+    say(`[ERROR] ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`)
+  }
+  return output.join("\n")
+}

package/src/hosts/peerInstall.ts

@@ -4,13 +4,15 @@ import { join } from "node:path"
 import { pathToFileURL } from "node:url"
 import pkg from "../../package.json"
 import { peerDirInPrefix, peersDir, peerVersionGlobal } from "./peers"
+import { archiveSpec } from "./archives"
 import { CliError, c, confirm, log, note } from "../cli"
 
 /*
  * Peers install themselves on first use. `lecodes render` on a machine with only the CLI asks once,
  * then puts lecodes-headless (+ @napi-rs/canvas for PNG) into ~/.lecodes/peers and loads it from
  * there — the same pattern as matc and the desktop host (downloaded into ~/.lecodes on first use),
- * applied to npm packages. Why a private prefix and not `npm install -g`: no sudo / system prefix
+ * applied to packages: the headless host and the editors are ARCHIVES of the releases bucket,
+ * installed by their url (./archives.ts); canvas and lecodes-assets are npm's. Why a private prefix and not `npm install -g`: no sudo / system prefix
  * to guess, and the runtime-set peer is installed at EXACTLY this CLI's version — the compiler and the
  * headless host are one ABI set, so a global renderer that drifted behind the CLI is the very failure
  * this removes. A newer CLI re-installs its own version on the next use (peerSpec → `lecodes update`).
@@ -28,10 +30,12 @@ const CANVAS_RANGE_FALLBACK = "^0.1.65"
 
 const readJson = (path: string): any => { try { return JSON.parse(readFileSync(path, "utf8")) } catch { return null } }
 
-/** The npm spec a peer installs at: the renderer at exactly this CLI's version (one ABI set), canvas
- *  at the range the installed renderer declares, the editors / assets at this CLI's peer ranges. */
+/** What a peer installs by: the url of its archive — the renderer at exactly this CLI's version (one
+ *  ABI set), an editor at the version this CLI was published against — or, for npm's, a spec: canvas
+ *  at the range the installed renderer declares, lecodes-assets at this CLI's peer range. */
 export const peerSpec = (name: string): string => {
-  if (name === "lecodes-headless") return `lecodes-headless@${pkg.version}`
+  const archive = archiveSpec(name)
+  if (archive) return archive
   if (name === "@napi-rs/canvas") {
     const renderer = readJson(join(peerDirInPrefix("lecodes-headless"), "package.json"))
     const range = renderer?.peerDependencies?.["@napi-rs/canvas"] ?? renderer?.optionalDependencies?.["@napi-rs/canvas"] ?? CANVAS_RANGE_FALLBACK