lecodes-cli 2.2.8 → 2.2.10

package/src/commands/shared.ts

@@ -1,79 +1,79 @@
-import { basename } from "node:path"
-import { bool, str, type FlagValues } from "../cli"
-import { loadConfig, requireApiUrl, requireToken } from "../platform/config"
-import { findProjectRoot, readManifest, type Manifest } from "../project/manifest"
-
-/*
- * What several commands share: the flag groups (spread into a command's `flags:`) and the
- * "where am I / who am I" lookups every platform command starts with.
- */
-
-// ---- flag groups -----------------------------------------------------------------------------
-
-/** How the project is compiled — `compile`, `dev`, `render`, `test`, `desktop run`, `app sync` … */
-export const bundleFlags = {
-  entry: str("compile from this entry instead of the detected one", { value: "<path>" }),
-  "public-url": str("resolve assets from this URL prefix (default: the API origin / the working tree)", { value: "<url>" }),
-  "remote-assets": bool("desktop hosts: load asset() resources from the server instead of the working tree"),
-  "no-header": bool("omit the metadata header"),
-  "no-minify": bool("keep the bundle readable (no compress / mangle)"),
-  "no-sourcemap": bool("don't generate / inline the source map"),
-}
-
-/** `-o` for commands whose result is a file. */
-export const outFlag = { out: str("write to this file instead of stdout", { alias: "o", value: "<file>" }) }
-
-/** The compiler's view of the bundle flags (see compile.ts `buildBundle`). */
-export type BundleOptions = {
-  entry?: string
-  publicUrl?: string
-  remoteAssets?: boolean
-  header?: boolean
-  minify?: boolean
-  sourcemap?: boolean
-}
-
-export const bundleOptions = (flags: FlagValues<typeof bundleFlags>): BundleOptions => ({
-  entry: flags.entry,
-  publicUrl: flags["public-url"],
-  remoteAssets: flags["remote-assets"],
-  header: !flags["no-header"],
-  // Both default on; `false` only when the flag is present, so the SDK's own defaults stand.
-  minify: flags["no-minify"] ? false : undefined,
-  sourcemap: flags["no-sourcemap"] ? false : undefined,
-})
-
-// ---- where / who -----------------------------------------------------------------------------
-
-export type Session = { apiUrl: string, token: string }
-
-/** The logged-in session (api origin + token) or a "run `lecodes login`" error. */
-export const session = (): Session => {
-  const config = loadConfig()
-  return { apiUrl: requireApiUrl(config), token: requireToken(config) }
-}
-
-export type LinkedProject = Session & { root: string, manifest: Manifest }
-
-/** A server-backed checkout: the project root (found upward from the cwd), its manifest and the session. */
-export const linkedProject = (): LinkedProject => {
-  const root = findProjectRoot(process.cwd())
-  return { root, manifest: readManifest(root), ...session() }
-}
-
-export type LocalProject = { root: string, manifest: Manifest | null, name: string }
-
-/** Any project: a linked checkout, else the current folder standing alone (no login needed). */
-export const localProject = (): LocalProject => {
-  try {
-    const root = findProjectRoot(process.cwd())
-    const manifest = readManifest(root)
-    return { root, manifest, name: manifest.name }
-  } catch {
-    const root = process.cwd()
-    return { root, manifest: null, name: basename(root) }
-  }
-}
-
-/** A folder name for a project: lower-case, dashes, never empty. */
-export const slugOf = (name: string): string => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project"
+import { basename } from "node:path"
+import { bool, str, type FlagValues } from "../cli"
+import { loadConfig, requireApiUrl, requireToken } from "../platform/config"
+import { findProjectRoot, readManifest, type Manifest } from "../project/manifest"
+
+/*
+ * What several commands share: the flag groups (spread into a command's `flags:`) and the
+ * "where am I / who am I" lookups every platform command starts with.
+ */
+
+// ---- flag groups -----------------------------------------------------------------------------
+
+/** How the project is compiled — `compile`, `dev`, `render`, `test`, `desktop run`, `app sync` … */
+export const bundleFlags = {
+  entry: str("compile from this entry instead of the detected one", { value: "<path>" }),
+  "public-url": str("resolve assets from this URL prefix (default: the API origin / the working tree)", { value: "<url>" }),
+  "remote-assets": bool("desktop hosts: load asset() resources from the server instead of the working tree"),
+  "no-header": bool("omit the metadata header"),
+  "no-minify": bool("keep the bundle readable (no compress / mangle)"),
+  "no-sourcemap": bool("don't generate / inline the source map"),
+}
+
+/** `-o` for commands whose result is a file. */
+export const outFlag = { out: str("write to this file instead of stdout", { alias: "o", value: "<file>" }) }
+
+/** The compiler's view of the bundle flags (see compile.ts `buildBundle`). */
+export type BundleOptions = {
+  entry?: string
+  publicUrl?: string
+  remoteAssets?: boolean
+  header?: boolean
+  minify?: boolean
+  sourcemap?: boolean
+}
+
+export const bundleOptions = (flags: FlagValues<typeof bundleFlags>): BundleOptions => ({
+  entry: flags.entry,
+  publicUrl: flags["public-url"],
+  remoteAssets: flags["remote-assets"],
+  header: !flags["no-header"],
+  // Both default on; `false` only when the flag is present, so the SDK's own defaults stand.
+  minify: flags["no-minify"] ? false : undefined,
+  sourcemap: flags["no-sourcemap"] ? false : undefined,
+})
+
+// ---- where / who -----------------------------------------------------------------------------
+
+export type Session = { apiUrl: string, token: string }
+
+/** The logged-in session (api origin + token) or a "run `lecodes login`" error. */
+export const session = (): Session => {
+  const config = loadConfig()
+  return { apiUrl: requireApiUrl(config), token: requireToken(config) }
+}
+
+export type LinkedProject = Session & { root: string, manifest: Manifest }
+
+/** A server-backed checkout: the project root (found upward from the cwd), its manifest and the session. */
+export const linkedProject = (): LinkedProject => {
+  const root = findProjectRoot(process.cwd())
+  return { root, manifest: readManifest(root), ...session() }
+}
+
+export type LocalProject = { root: string, manifest: Manifest | null, name: string }
+
+/** Any project: a linked checkout, else the current folder standing alone (no login needed). */
+export const localProject = (): LocalProject => {
+  try {
+    const root = findProjectRoot(process.cwd())
+    const manifest = readManifest(root)
+    return { root, manifest, name: manifest.name }
+  } catch {
+    const root = process.cwd()
+    return { root, manifest: null, name: basename(root) }
+  }
+}
+
+/** A folder name for a project: lower-case, dashes, never empty. */
+export const slugOf = (name: string): string => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project"

package/src/commands/test.ts

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs"
 import { dirname, resolve } from "node:path"
 import { compileHeadlessBundle } from "../compile/headlessBundle"
 import { desktopDefaultViewport, desktopPluginLibraries, resolveDesktopRenderer } from "./app/shared"
-import { desktopRenderFlags, fileScenarioIO, requireRenderer, resolveFixtures, resolveSafeAreaChoice, viewportFlags } from "./render"
+import { desktopRenderFlags, fileScenarioIO, parseNativeViews, requireRenderer, resolveFixtures, resolveSafeAreaChoice, viewportFlags } from "./render"
 import { buildBundle } from "./compile"
 import { runBackend } from "../dev/projectBackend"
 import { resolvePicks } from "../hosts/flowPick"
@@ -415,6 +415,7 @@ const runTests = async (args: string[], flags: TestFlags): Promise<void> => {
         localAssets: useLocalAssets,
         fixtures: kase.fixtures,
         ...resolveSafeAreaChoice(flags["safe-area"] ?? kase.safeArea, flags.device ?? kase.device),
+        nativeViews: parseNativeViews(flags["native-view"]),
         onConsole,
       })
       try {

package/src/commands/thumbs.ts

@@ -1,185 +1,185 @@
-import { createRequire } from "node:module"
-import { execFileSync } from "node:child_process"
-import { existsSync, mkdtempSync, readdirSync, rmSync, statSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { extname, join, relative, resolve } from "node:path"
-import { loadPeer } from "../hosts/peerInstall"
-import { projectRootOf } from "./scene"
-import { CliError, bool, c, defineCommand, endProgress, log, note, num, progress, warnErr } from "../cli"
-import { toKey } from "../project/paths"
-
-/*
- * `lecodes thumbs [path…]` — the scene editor's asset thumbnails, generated from the COMMAND LINE.
- *
- * The editor renders previews in a hidden browser host (3D assets need an engine), but image
- * thumbnails need no engine at all — and a .ktx2 has no picture until something decodes it. This
- * command fills the same cache the editor reads (`.lecodes/preview/<asset>.<hash>.png`, owned by
- * lecodes-3d-editor's server/previewCache) with no browser in the loop, so opening the editor on a
- * texture-heavy project shows a full grid immediately instead of rendering 40 thumbnails on the
- * spot.
- *
- * Incremental by construction: the cache file name carries the first 10 hex of the SOURCE file's
- * sha256, so an asset whose preview is already there is skipped after one hash — re-running over a
- * big project is nearly free. `--force` ignores that.
- *
- * Decoders, in the order tried: sharp (through the optional `lecodes-assets` peer — handles webp),
- * else jimp (bundled with this CLI: png / jpeg / bmp / gif / tiff). KTX2 goes through
- * KTX-Software's `ktx extract` first (it is a GPU-compressed format; nothing in JS reads it), and
- * the extracted PNG then takes the same resize path.
- *
- * NOT covered: models, materials and prefabs — those are RENDERED, which needs an engine. The
- * editor still does them on demand (and `lecodes render --desktop` is the browserless renderer if
- * that ever becomes a batch job).
- */
-
-const DEFAULT_SIZE = 256
-const IMAGE_EXT = /\.(png|jpe?g|webp|bmp|gif|tiff?|ktx2)$/i
-const RENDERED_EXT = /\.(glb|gltf|material\.ts|scene\.ts)$/i
-
-/** KTX-Software's `ktx` CLI (v4.3+ has `extract`), resolved like lecodes-assets resolves toktx. */
-const findKtx = (): string | null => {
-  const exe = process.platform === "win32" ? "ktx.exe" : "ktx"
-  const candidates = [
-    process.env.LECODES_KTX,
-    process.env.KTX_CLI,
-    process.env.KTX_TOKTX?.replace(/toktx(\.exe)?$/i, exe),
-    process.platform === "win32" ? join(process.env.LOCALAPPDATA ?? "", "Programs", "KTX-Software", "bin", exe) : null,
-    process.platform === "win32" ? join(process.env.ProgramFiles ?? "", "KTX-Software", "bin", exe) : null,
-    "/usr/local/bin/ktx",
-    "/opt/homebrew/bin/ktx",
-  ].filter((p): p is string => !!p)
-  for (const path of candidates) { if (existsSync(path)) return path }
-  try {
-    execFileSync(exe, [ "--version" ], { stdio: "ignore" })
-    return exe
-  } catch { return null }
-}
-
-type Resizer = (file: string, size: number) => Promise<Uint8Array>
-
-/** sharp through the `lecodes-assets` peer (it declares it optional), or null when neither is
- *  installed — jimp then covers everything but webp. */
-const sharpResizer = (): Resizer | null => {
-  try {
-    const req = createRequire(import.meta.url)
-    const sharp = createRequire(req.resolve("lecodes-assets/cli"))("sharp")
-    return async (file, size) =>
-      sharp(file).resize({ width: size, height: size, fit: "inside", withoutEnlargement: true }).png().toBuffer()
-  } catch { return null }
-}
-
-const jimpResizer = (): Resizer => async (file, size) => {
-  const { Jimp } = await import("jimp")
-  const img = await Jimp.read(file)
-  if (Math.max(img.width, img.height) > size) img.scaleToFit({ w: size, h: size })
-  return await img.getBuffer("image/png")
-}
-
-/** KTX2 → a temporary PNG (level 0, transcoded to RGBA8 when the payload is Basis-compressed). */
-const ktxToPng = (ktx: string, file: string, out: string): void => {
-  const run = (args: string[]) => execFileSync(ktx, args, { stdio: [ "ignore", "ignore", "pipe" ], encoding: "utf8" })
-  try {
-    run([ "extract", "--transcode", "rgba8", "--level", "0", file, out ])
-  } catch (e: any) {
-    // Only Basis (ETC1S/UASTC) payloads are transcodable; a plain uncompressed KTX2 extracts as-is
-    run([ "extract", "--level", "0", file, out ])
-    if (!existsSync(out)) throw e
-  }
-}
-
-/** Every previewable file under a folder — the SAME sweep the editor's asset panel lists with
- *  (node_modules + dotfiles out, nothing else): what this command doesn't cover, the browser would
- *  end up rendering itself. */
-const collect = (dir: string): string[] => {
-  const out: string[] = []
-  for (const name of readdirSync(dir)) {
-    if (name === "node_modules" || name.startsWith(".")) continue
-    const full = join(dir, name)
-    if (statSync(full).isDirectory()) out.push(...collect(full))
-    else if (IMAGE_EXT.test(name)) out.push(full)
-  }
-  return out
-}
-
-export default defineCommand({
-  name: "thumbs",
-  summary: "Asset thumbnails for the scene editor, without a browser",
-  usage: "[path…]",
-  description: "Decodes the project's images (KTX2 too, via KTX-Software's ktx tool) into the editor's preview cache. Incremental: the cached name carries the asset's content hash, so unchanged files are skipped. Models, materials and prefabs are rendered by the editor, not here.",
-  flags: {
-    force: bool("redo even the up-to-date ones"),
-    size: num("longest edge, px", { default: DEFAULT_SIZE }),
-  },
-  run: ({ args, flags }) => thumbs(args, flags.size, flags.force),
-})
-
-const thumbs = async (targets: string[], size: number, force: boolean): Promise<void> => {
-  const root = projectRootOf(process.cwd())
-
-  // The scene editor owns the preview cache — installed into ~/.lecodes/peers on first use.
-  const sceneServer = await loadPeer<typeof import("lecodes-3d-editor/server")>("lecodes-3d-editor", "server", { for: "lecodes thumbs" })
-
-  // Targets: the paths given (a file or a folder each), else the whole project.
-  let files: string[] = []
-  const rendered: string[] = []
-  if (targets.length > 0) {
-    for (const arg of targets) {
-      const abs = resolve(process.cwd(), arg)
-      if (!existsSync(abs)) throw new CliError(`No such file or folder: ${arg}`)
-      if (statSync(abs).isDirectory()) files.push(...collect(abs))
-      else if (IMAGE_EXT.test(abs)) files.push(abs)
-      else if (RENDERED_EXT.test(abs)) rendered.push(arg)
-      else throw new CliError(`Not a previewable asset: ${arg}`)
-    }
-  } else {
-    files = collect(root)
-  }
-  files = [ ...new Set(files) ]
-
-  if (files.length === 0 && rendered.length === 0) {
-    log("No images to thumbnail.")
-    return
-  }
-
-  const ktx = files.some((f) => f.toLowerCase().endsWith(".ktx2")) ? findKtx() : null
-  const sharp = sharpResizer()
-  const resize = sharp ?? jimpResizer()
-  const tmp = mkdtempSync(join(tmpdir(), "lecodes-thumbs-"))
-
-  let made = 0, fresh = 0
-  const skipped: string[] = []
-  try {
-    for (const [ i, file ] of files.entries()) {
-      const asset = "./" + toKey(relative(root, file))
-      progress(i, files.length, asset)
-      const hash = sceneServer.hashAsset(root, asset)
-      if (!hash) continue
-      if (!force && sceneServer.previewIsCurrent(root, asset, hash)) { fresh++; continue }
-
-      const ext = extname(file).toLowerCase()
-      if (ext === ".webp" && !sharp) { skipped.push(`${asset} (webp needs sharp — npm install -g lecodes-assets)`); continue }
-      try {
-        let source = file
-        if (ext === ".ktx2") {
-          if (!ktx) { skipped.push(`${asset} (KTX2 needs KTX-Software's \`ktx\` — set LECODES_KTX or put it on PATH)`); continue }
-          source = join(tmp, `${i}.png`)
-          ktxToPng(ktx, file, source)
-        }
-        sceneServer.writePreviewFile(root, asset, await resize(source, size))
-        made++
-      } catch (e: any) {
-        skipped.push(`${asset} (${(e?.message ?? String(e)).split("\n")[0]})`)
-      }
-    }
-  } finally {
-    endProgress()
-    rmSync(tmp, { recursive: true, force: true })
-  }
-
-  log(`${c.bold(String(made))} generated · ${fresh} already current${skipped.length > 0 ? ` · ${skipped.length} skipped` : ""}`)
-  for (const s of skipped) warnErr(s)
-  if (rendered.length > 0) {
-    warnErr(`Models, materials and prefabs are RENDERED, not decoded — the scene editor does those: ${rendered.join(", ")}`)
-  }
-  note(`Cache: ${join(root, ".lecodes", "preview")}  (re-runs skip everything unchanged)`)
-}
+import { createRequire } from "node:module"
+import { execFileSync } from "node:child_process"
+import { existsSync, mkdtempSync, readdirSync, rmSync, statSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { extname, join, relative, resolve } from "node:path"
+import { loadPeer } from "../hosts/peerInstall"
+import { projectRootOf } from "./scene"
+import { CliError, bool, c, defineCommand, endProgress, log, note, num, progress, warnErr } from "../cli"
+import { toKey } from "../project/paths"
+
+/*
+ * `lecodes thumbs [path…]` — the scene editor's asset thumbnails, generated from the COMMAND LINE.
+ *
+ * The editor renders previews in a hidden browser host (3D assets need an engine), but image
+ * thumbnails need no engine at all — and a .ktx2 has no picture until something decodes it. This
+ * command fills the same cache the editor reads (`.lecodes/preview/<asset>.<hash>.png`, owned by
+ * lecodes-3d-editor's server/previewCache) with no browser in the loop, so opening the editor on a
+ * texture-heavy project shows a full grid immediately instead of rendering 40 thumbnails on the
+ * spot.
+ *
+ * Incremental by construction: the cache file name carries the first 10 hex of the SOURCE file's
+ * sha256, so an asset whose preview is already there is skipped after one hash — re-running over a
+ * big project is nearly free. `--force` ignores that.
+ *
+ * Decoders, in the order tried: sharp (through the optional `lecodes-assets` peer — handles webp),
+ * else jimp (bundled with this CLI: png / jpeg / bmp / gif / tiff). KTX2 goes through
+ * KTX-Software's `ktx extract` first (it is a GPU-compressed format; nothing in JS reads it), and
+ * the extracted PNG then takes the same resize path.
+ *
+ * NOT covered: models, materials and prefabs — those are RENDERED, which needs an engine. The
+ * editor still does them on demand (and `lecodes render --desktop` is the browserless renderer if
+ * that ever becomes a batch job).
+ */
+
+const DEFAULT_SIZE = 256
+const IMAGE_EXT = /\.(png|jpe?g|webp|bmp|gif|tiff?|ktx2)$/i
+const RENDERED_EXT = /\.(glb|gltf|material\.ts|scene\.ts)$/i
+
+/** KTX-Software's `ktx` CLI (v4.3+ has `extract`), resolved like lecodes-assets resolves toktx. */
+const findKtx = (): string | null => {
+  const exe = process.platform === "win32" ? "ktx.exe" : "ktx"
+  const candidates = [
+    process.env.LECODES_KTX,
+    process.env.KTX_CLI,
+    process.env.KTX_TOKTX?.replace(/toktx(\.exe)?$/i, exe),
+    process.platform === "win32" ? join(process.env.LOCALAPPDATA ?? "", "Programs", "KTX-Software", "bin", exe) : null,
+    process.platform === "win32" ? join(process.env.ProgramFiles ?? "", "KTX-Software", "bin", exe) : null,
+    "/usr/local/bin/ktx",
+    "/opt/homebrew/bin/ktx",
+  ].filter((p): p is string => !!p)
+  for (const path of candidates) { if (existsSync(path)) return path }
+  try {
+    execFileSync(exe, [ "--version" ], { stdio: "ignore" })
+    return exe
+  } catch { return null }
+}
+
+type Resizer = (file: string, size: number) => Promise<Uint8Array>
+
+/** sharp through the `lecodes-assets` peer (it declares it optional), or null when neither is
+ *  installed — jimp then covers everything but webp. */
+const sharpResizer = (): Resizer | null => {
+  try {
+    const req = createRequire(import.meta.url)
+    const sharp = createRequire(req.resolve("lecodes-assets/cli"))("sharp")
+    return async (file, size) =>
+      sharp(file).resize({ width: size, height: size, fit: "inside", withoutEnlargement: true }).png().toBuffer()
+  } catch { return null }
+}
+
+const jimpResizer = (): Resizer => async (file, size) => {
+  const { Jimp } = await import("jimp")
+  const img = await Jimp.read(file)
+  if (Math.max(img.width, img.height) > size) img.scaleToFit({ w: size, h: size })
+  return await img.getBuffer("image/png")
+}
+
+/** KTX2 → a temporary PNG (level 0, transcoded to RGBA8 when the payload is Basis-compressed). */
+const ktxToPng = (ktx: string, file: string, out: string): void => {
+  const run = (args: string[]) => execFileSync(ktx, args, { stdio: [ "ignore", "ignore", "pipe" ], encoding: "utf8" })
+  try {
+    run([ "extract", "--transcode", "rgba8", "--level", "0", file, out ])
+  } catch (e: any) {
+    // Only Basis (ETC1S/UASTC) payloads are transcodable; a plain uncompressed KTX2 extracts as-is
+    run([ "extract", "--level", "0", file, out ])
+    if (!existsSync(out)) throw e
+  }
+}
+
+/** Every previewable file under a folder — the SAME sweep the editor's asset panel lists with
+ *  (node_modules + dotfiles out, nothing else): what this command doesn't cover, the browser would
+ *  end up rendering itself. */
+const collect = (dir: string): string[] => {
+  const out: string[] = []
+  for (const name of readdirSync(dir)) {
+    if (name === "node_modules" || name.startsWith(".")) continue
+    const full = join(dir, name)
+    if (statSync(full).isDirectory()) out.push(...collect(full))
+    else if (IMAGE_EXT.test(name)) out.push(full)
+  }
+  return out
+}
+
+export default defineCommand({
+  name: "thumbs",
+  summary: "Asset thumbnails for the scene editor, without a browser",
+  usage: "[path…]",
+  description: "Decodes the project's images (KTX2 too, via KTX-Software's ktx tool) into the editor's preview cache. Incremental: the cached name carries the asset's content hash, so unchanged files are skipped. Models, materials and prefabs are rendered by the editor, not here.",
+  flags: {
+    force: bool("redo even the up-to-date ones"),
+    size: num("longest edge, px", { default: DEFAULT_SIZE }),
+  },
+  run: ({ args, flags }) => thumbs(args, flags.size, flags.force),
+})
+
+const thumbs = async (targets: string[], size: number, force: boolean): Promise<void> => {
+  const root = projectRootOf(process.cwd())
+
+  // The scene editor owns the preview cache — installed into ~/.lecodes/peers on first use.
+  const sceneServer = await loadPeer<typeof import("lecodes-3d-editor/server")>("lecodes-3d-editor", "server", { for: "lecodes thumbs" })
+
+  // Targets: the paths given (a file or a folder each), else the whole project.
+  let files: string[] = []
+  const rendered: string[] = []
+  if (targets.length > 0) {
+    for (const arg of targets) {
+      const abs = resolve(process.cwd(), arg)
+      if (!existsSync(abs)) throw new CliError(`No such file or folder: ${arg}`)
+      if (statSync(abs).isDirectory()) files.push(...collect(abs))
+      else if (IMAGE_EXT.test(abs)) files.push(abs)
+      else if (RENDERED_EXT.test(abs)) rendered.push(arg)
+      else throw new CliError(`Not a previewable asset: ${arg}`)
+    }
+  } else {
+    files = collect(root)
+  }
+  files = [ ...new Set(files) ]
+
+  if (files.length === 0 && rendered.length === 0) {
+    log("No images to thumbnail.")
+    return
+  }
+
+  const ktx = files.some((f) => f.toLowerCase().endsWith(".ktx2")) ? findKtx() : null
+  const sharp = sharpResizer()
+  const resize = sharp ?? jimpResizer()
+  const tmp = mkdtempSync(join(tmpdir(), "lecodes-thumbs-"))
+
+  let made = 0, fresh = 0
+  const skipped: string[] = []
+  try {
+    for (const [ i, file ] of files.entries()) {
+      const asset = "./" + toKey(relative(root, file))
+      progress(i, files.length, asset)
+      const hash = sceneServer.hashAsset(root, asset)
+      if (!hash) continue
+      if (!force && sceneServer.previewIsCurrent(root, asset, hash)) { fresh++; continue }
+
+      const ext = extname(file).toLowerCase()
+      if (ext === ".webp" && !sharp) { skipped.push(`${asset} (webp needs sharp — npm install -g lecodes-assets)`); continue }
+      try {
+        let source = file
+        if (ext === ".ktx2") {
+          if (!ktx) { skipped.push(`${asset} (KTX2 needs KTX-Software's \`ktx\` — set LECODES_KTX or put it on PATH)`); continue }
+          source = join(tmp, `${i}.png`)
+          ktxToPng(ktx, file, source)
+        }
+        sceneServer.writePreviewFile(root, asset, await resize(source, size))
+        made++
+      } catch (e: any) {
+        skipped.push(`${asset} (${(e?.message ?? String(e)).split("\n")[0]})`)
+      }
+    }
+  } finally {
+    endProgress()
+    rmSync(tmp, { recursive: true, force: true })
+  }
+
+  log(`${c.bold(String(made))} generated · ${fresh} already current${skipped.length > 0 ? ` · ${skipped.length} skipped` : ""}`)
+  for (const s of skipped) warnErr(s)
+  if (rendered.length > 0) {
+    warnErr(`Models, materials and prefabs are RENDERED, not decoded — the scene editor does those: ${rendered.join(", ")}`)
+  }
+  note(`Cache: ${join(root, ".lecodes", "preview")}  (re-runs skip everything unchanged)`)
+}