akanjs 3.0.2 → 3.1.0-rc.0

package/vendor/@akanjs/native/packages/cli/src/config.ts

@@ -86,6 +86,8 @@ export interface AkanNativeConfig {
     /** Painted before the page loads, to avoid a white flash (SH-3). */
     backgroundColor?: string;
     backgroundColorDark?: string;
+    /** The web inspector in a release build too (a debug build always has it): internal test builds only. */
+    devtools?: boolean;
   };
   /** Overrides for permission usage texts, e.g. { NSCameraUsageDescription: "..." }. */
   usageDescriptions?: Record<string, string>;
@@ -112,10 +114,20 @@ export interface AkanNativeConfig {
   permissions?: { camera?: string | true; microphone?: string | true; location?: string | true };
   /**
    * Over-the-air updates (UP-2 web bundles on iOS / Android, UP-1 app updates on macOS), used by
-   * @akanjs/native/plugins/updates. `akan-native update keygen` makes the signing key and prints `publicKey`;
-   * `akan-native update publish <platform>` writes signed releases for `url`.
+   * @akanjs/native/plugins/updates. `akan-native update keygen` makes the signing key and prints its public key;
+   * `akan-native update publish <platform>` writes signed releases for `url`. `publicKeys` lists the keys a phone
+   * trusts, the online signing key first and offline spares after (a key revokes only keys before it); `publicKey` is
+   * the one-key form, and a desktop app trusts the first. `report.url` is where a phone posts what became of each
+   * release, at its next launch or return to the foreground.
    */
-  updates?: { url: string; publicKey: string; channel?: string; readyTimeout?: number };
+  updates?: {
+    url: string;
+    publicKey?: string;
+    publicKeys?: string[];
+    channel?: string;
+    readyTimeout?: number;
+    report?: { url: string };
+  };
   /** Links that open the app, delivered through the app plugin's urlOpen (and getLaunchUrl). */
   deepLinks?: {
     /** Custom URL schemes (myapp://...). */
@@ -250,10 +262,10 @@ export interface AkanNativeConfig {
     recovery?: "errorPage" | "reload";
     /**
      * The main window from its first frame: `fullscreen` (borderless, on the display the window opens on)
-     * and `skipTaskbar` (no taskbar button; Windows and Linux). A plugin's launch phase may still decide
-     * otherwise (DesktopContext.launch.setWindow). Default false for both.
+     * `skipTaskbar` (no taskbar button; Windows and Linux) and `frameless` (no title bar or border). A plugin's
+     * launch phase may still decide otherwise (DesktopContext.launch.setWindow). Default false for all three.
      */
-    window?: { fullscreen?: boolean; skipTaskbar?: boolean };
+    window?: { fullscreen?: boolean; skipTaskbar?: boolean; frameless?: boolean };
     /**
      * Windows: "auto" answers the page's getDisplayMedia() with the first screen at once, without the picker or a
      * user gesture: a remote-support session on an unattended screen. It is Chromium's switch for automated media
@@ -262,13 +274,29 @@ export interface AkanNativeConfig {
      * offered. macOS and Linux ignore it.
      */
     screenCapture?: "picker" | "auto";
+    /**
+     * Windows installer: "bootstrapper" (default) carries Microsoft's 2 MB setup that downloads the WebView2
+     * Runtime when the PC has none; "standalone" carries the whole runtime (~200 MB), for a PC that is offline or
+     * behind a proxy at install. Either runs only where no runtime is installed.
+     */
+    webview2?: "bootstrapper" | "standalone";
+    /** Windows: the installed app's Publisher (Apps & features) and its executable's company name (default: the app name). */
+    publisher?: string;
     /**
      * A server the app starts beside its window (akanjs `native.desktop.server`). `dir` is copied to
      * the app's resources (`server/`), and `entry` there runs on the app's own Bun with `env`, bound to
      * a loopback port picked at launch; the page reads its URL as PUBLIC_AKAN_SERVER_URL. The launcher
      * sets PORT, JWT_SECRET, the data folders (`<app local data>/server`) and the listen host itself.
+     * `restart`: crashes in a row before it gives up (5), or "forever"; `watchdog`: its health route asked every
+     * `intervalMs`, `failures` missed in a row restarting it.
      */
-    server?: { dir: string; entry: string; env?: Record<string, string> };
+    server?: {
+      dir: string;
+      entry: string;
+      env?: Record<string, string>;
+      restart?: number | "forever";
+      watchdog?: { intervalMs: number; failures: number };
+    };
     /**
      * A folder of executables the app carries (akanjs `bin`): copied to the app's resources (`bin/`) and put
      * first on the app's PATH at launch, so its plugins and its server find them by name before the computer's.

package/vendor/@akanjs/native/packages/cli/src/lib/compat.ts

@@ -35,6 +35,8 @@ export interface BundleInfo {
   nativeApi: { hash: string; inputs: NativeApi };
   /** sha256 of the web files (index.html as served and public/), for update integrity later. */
   web: { hash: string; files: number };
+  /** A phone build with updates: what its binary reads (updates.json), the floor of every release's sequence included. */
+  updates?: { protocol: 2; url: string; channel: string; keyIds: string[]; embeddedSequence: number };
 }
 
 /** "0.1.4" → "0.1", "1.2.0" → "1". */

package/vendor/@akanjs/native/packages/cli/src/lib/configkeys.ts

@@ -16,11 +16,11 @@ const KNOWN: Shape = {
     },
   },
   env: { defaults: true, platforms: { web: true, macos: true, windows: true, linux: true, ios: true, android: true } },
-  shell: { backgroundColor: true, backgroundColorDark: true },
+  shell: { backgroundColor: true, backgroundColorDark: true, devtools: true },
   usageDescriptions: true,
   privacy: { tracking: true, trackingDomains: true, collectedDataTypes: true, accessedApis: true },
   permissions: { camera: true, microphone: true, location: true },
-  updates: { url: true, publicKey: true, channel: true, readyTimeout: true },
+  updates: { url: true, publicKey: true, publicKeys: true, channel: true, readyTimeout: true, report: { url: true } },
   deepLinks: { schemes: true, domains: { "[]": { host: true, pathPrefixes: true } } },
   native: {
     ios: { infoPlist: true, entitlements: true },
@@ -33,9 +33,11 @@ const KNOWN: Shape = {
   desktop: {
     quitOnLastWindowClosed: true,
     recovery: true,
-    window: { fullscreen: true, skipTaskbar: true },
+    window: { fullscreen: true, skipTaskbar: true, frameless: true },
     screenCapture: true,
-    server: { dir: true, entry: true, env: true },
+    webview2: true,
+    publisher: true,
+    server: { dir: true, entry: true, env: true, restart: true, watchdog: { intervalMs: true, failures: true } },
     bin: true,
     dmg: {
       background: true,

package/vendor/@akanjs/native/packages/cli/src/lib/desktop-server.ts

@@ -10,6 +10,8 @@ export interface DesktopServerConfig {
   dir: string;
   entry: string;
   env: Record<string, string>;
+  restart?: number | "forever";
+  watchdog?: { intervalMs: number; failures: number };
 }
 
 const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -54,5 +56,13 @@ export function validateDesktopServer(
       else if (typeof value !== "string") problems.push(`desktop.server.env.${key} must be a string`);
       else env[key] = value;
     }
-  return problems.length === before && dir ? { dir, entry, env } : null;
+  const { restart, watchdog } = server;
+  if (restart !== undefined && restart !== "forever" && !(Number.isInteger(restart) && restart > 0))
+    problems.push('desktop.server.restart must be "forever" or a count of crashes in a row from 1');
+  const positive = (value: unknown) => Number.isInteger(value) && (value as number) > 0;
+  if (watchdog !== undefined && !(watchdog && positive(watchdog.intervalMs) && positive(watchdog.failures)))
+    problems.push("desktop.server.watchdog must be { intervalMs, failures }, both whole numbers from 1");
+  return problems.length === before && dir
+    ? { dir, entry, env, ...(restart !== undefined ? { restart } : {}), ...(watchdog ? { watchdog } : {}) }
+    : null;
 }

package/vendor/@akanjs/native/packages/cli/src/lib/distribution.ts

@@ -0,0 +1,73 @@
+import { basename } from "node:path";
+import { CliError } from "./log.ts";
+import { type MacosNotarization, type MacosSigning, macosDistributionFromEnv } from "./macossigning.ts";
+import { type WindowsSigning, windowsSigningFromEnv } from "./windowssigning.ts";
+
+export interface DistributionRequest {
+  /** Sign the app with the identity the env names (Developer ID on macOS, Authenticode on Windows). */
+  sign?: boolean;
+  /** macOS: upload the signed app to Apple's notary service. */
+  notarize?: boolean;
+}
+
+export interface Distribution {
+  macos?: { signing?: MacosSigning; notarize?: MacosNotarization };
+  windows?: { signing?: WindowsSigning };
+  /** One line saying who signs and where the app goes, for before the build; null when nothing is signed. */
+  notice: string | null;
+  /** The env names that configure a signature this build was not asked to make. */
+  unused: string[];
+}
+
+const SIGNING_ENV =
+  /^AKAN_NATIVE_(?:MACOS_(?:IDENTITY|CERTIFICATE|NOTARY_PROFILE|NOTARY_KEY)|WINDOWS_(?:CERTIFICATE|THUMBPRINT|SIGN_COMMAND))$/;
+
+export function requestedDistribution(
+  platform: string,
+  profile: "debug" | "release",
+  { sign = false, notarize = false }: DistributionRequest,
+  env: Record<string, string | undefined> = process.env,
+): Distribution {
+  const unused = Object.keys(env)
+    .filter((name) => SIGNING_ENV.test(name) && env[name]?.trim())
+    .sort();
+  if (!sign && !notarize) return { notice: null, unused };
+  if (platform !== "macos" && platform !== "windows")
+    throw new CliError(`--sign and --notarize are for a macOS or Windows app, not ${platform}`);
+  if (profile !== "release") throw new CliError("--sign and --notarize take a release build");
+  if (notarize && platform !== "macos") throw new CliError("--notarize is Apple's: a Windows app is only signed");
+  if (notarize && !sign) throw new CliError("--notarize takes --sign: Apple notarizes a signed app only");
+  if (platform === "windows") {
+    const signing = windowsSigningFromEnv(env);
+    if (!signing)
+      throw new CliError(
+        "--sign needs the identity: AKAN_NATIVE_WINDOWS_CERTIFICATE (+ _PASSWORD), AKAN_NATIVE_WINDOWS_THUMBPRINT or AKAN_NATIVE_WINDOWS_SIGN_COMMAND",
+      );
+    const by = signing.command
+      ? `the signing command ${basename(signing.command[0] ?? "")}, which may send each file to its signing service`
+      : signing.thumbprint
+        ? `the certificate ${signing.thumbprint}`
+        : `the certificate in ${basename(signing.certificate?.path ?? "")}`;
+    return { windows: { signing }, notice: `Signs the Windows app with ${by}.`, unused: [] };
+  }
+  const { signing, notarize: notarization } = macosDistributionFromEnv(env);
+  if (!signing)
+    throw new CliError(
+      "--sign needs the identity: AKAN_NATIVE_MACOS_IDENTITY, or AKAN_NATIVE_MACOS_CERTIFICATE (+ _PASSWORD)",
+    );
+  if (notarize && !notarization)
+    throw new CliError(
+      "--notarize needs the credentials: AKAN_NATIVE_MACOS_NOTARY_PROFILE, or AKAN_NATIVE_MACOS_NOTARY_KEY + _KEY_ID",
+    );
+  const identity = signing.identity ?? `the certificate in ${basename(signing.certificate?.path ?? "")}`;
+  const notary = notarization?.profile
+    ? `notarytool profile ${notarization.profile}`
+    : `API key ${notarization?.keyId}`;
+  return {
+    macos: { signing, ...(notarize && notarization ? { notarize: notarization } : {}) },
+    notice: notarize
+      ? `Signs the macOS app as ${identity} and uploads it to Apple's notary service (${notary}).`
+      : `Signs the macOS app as ${identity}; nothing is uploaded without --notarize.`,
+    unused: [],
+  };
+}

package/vendor/@akanjs/native/packages/cli/src/lib/project.ts

@@ -25,15 +25,17 @@ export interface ResolvedConfig
   web: Required<Pick<AkanNativeConfig["web"], "dir" | "base">> & { build?: string; devEntry?: string };
   plugins: string[];
   env: EnvConfig;
-  shell: { backgroundColor: string; backgroundColorDark: string };
+  shell: { backgroundColor: string; backgroundColorDark: string; devtools: boolean };
   usageDescriptions: Record<string, string>;
   permissions: PermissionsConfig;
   deepLinks: { schemes: string[]; domains: { host: string; pathPrefixes: string[] }[] };
   desktop: {
     quitOnLastWindowClosed: boolean;
     recovery: "errorPage" | "reload";
-    window: { fullscreen: boolean; skipTaskbar: boolean };
+    window: { fullscreen: boolean; skipTaskbar: boolean; frameless: boolean };
     screenCapture: "picker" | "auto";
+    webview2: "bootstrapper" | "standalone";
+    publisher?: string;
     server?: DesktopServerConfig;
     /** Absolute. */
     bin?: string;
@@ -201,13 +203,19 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
   const recovery = raw.desktop?.recovery;
   if (recovery !== undefined && recovery !== "errorPage" && recovery !== "reload")
     problems.push(`desktop.recovery must be "errorPage" or "reload" (got ${JSON.stringify(recovery)})`);
-  for (const key of ["fullscreen", "skipTaskbar"] as const) {
+  for (const key of ["fullscreen", "skipTaskbar", "frameless"] as const) {
     const value = raw.desktop?.window?.[key];
     if (value !== undefined && typeof value !== "boolean") problems.push(`desktop.window.${key} must be a boolean`);
   }
   const screenCapture = raw.desktop?.screenCapture;
   if (screenCapture !== undefined && screenCapture !== "picker" && screenCapture !== "auto")
     problems.push(`desktop.screenCapture must be "picker" or "auto" (got ${JSON.stringify(screenCapture)})`);
+  const webview2 = raw.desktop?.webview2;
+  if (webview2 !== undefined && webview2 !== "bootstrapper" && webview2 !== "standalone")
+    problems.push(`desktop.webview2 must be "bootstrapper" or "standalone" (got ${JSON.stringify(webview2)})`);
+  const publisher = raw.desktop?.publisher;
+  if (publisher !== undefined && (typeof publisher !== "string" || !publisher.trim() || /["\r\n]/.test(publisher)))
+    problems.push("desktop.publisher must be a name on one line, without a double quote");
   if (raw.android?.autoplay !== undefined && typeof raw.android.autoplay !== "boolean")
     problems.push("android.autoplay must be a boolean");
   const bin = raw.desktop?.bin;
@@ -253,6 +261,7 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
   const shell = {
     backgroundColor: raw.shell?.backgroundColor ?? "#ffffff",
     backgroundColorDark: raw.shell?.backgroundColorDark ?? raw.shell?.backgroundColor ?? "#000000",
+    devtools: raw.shell?.devtools === true,
   };
   const icon = typeof raw.icon === "string" ? { image: raw.icon } : raw.icon;
   const splashColor = raw.splash?.backgroundColor;
@@ -279,9 +288,12 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
       quitOnLastWindowClosed: raw.desktop?.quitOnLastWindowClosed ?? true,
       recovery: raw.desktop?.recovery === "reload" ? "reload" : "errorPage",
       screenCapture: raw.desktop?.screenCapture === "auto" ? "auto" : "picker",
+      webview2: raw.desktop?.webview2 === "standalone" ? "standalone" : "bootstrapper",
+      ...(typeof raw.desktop?.publisher === "string" ? { publisher: raw.desktop.publisher.trim() } : {}),
       window: {
         fullscreen: raw.desktop?.window?.fullscreen === true,
         skipTaskbar: raw.desktop?.window?.skipTaskbar === true,
+        frameless: raw.desktop?.window?.frameless === true,
       },
       ...(desktopServer ? { server: desktopServer } : {}),
       ...(binDir ? { bin: binDir } : {}),

package/vendor/@akanjs/native/packages/cli/src/lib/publish.ts

@@ -1,6 +1,6 @@
 
 
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { assertSameServer, publishAppUpdate } from "../platforms/desktop-update.ts";
 import { BUNDLE_FILE, readBundleInfo } from "./compat.ts";
@@ -8,9 +8,12 @@ import { CliError, log } from "./log.ts";
 import type { BuildContext } from "./prepare.ts";
 import {
   assertChannel,
+  type DesktopArch,
   hostArch,
+  sealManifest,
   signingKey,
   signManifest,
+  type UpdateEnvelope,
   type UpdateManifest,
   updateKeyPath,
   webManifest,
@@ -23,17 +26,34 @@ export interface PublishedRelease {
   /** `<out>/<os>-<arch>` for a desktop app, `<out>/<platform>` for a phone's web bundle. */
   dir: string;
   manifest: UpdateManifest;
+  /** The file installed apps read: `<dir>/<channel>.json`, or a phone's `<dir>/<channel>/<nativeApi>.json`. */
+  file: string;
+}
+
+/** The largest sequence published to `channel` in `dir`: a desktop's `<channel>.json`, every `<channel>/*.json` of a phone. */
+function publishedSequence(dir: string, channel: string): number | null {
+  const sequences: unknown[] = [];
+  const v1 = join(dir, `${channel}.json`);
+  if (existsSync(v1)) sequences.push((JSON.parse(readFileSync(v1, "utf8")) as Partial<UpdateManifest>).sequence);
+  const v2 = join(dir, channel);
+  if (existsSync(v2))
+    for (const name of readdirSync(v2).filter((name) => name.endsWith(".json"))) {
+      const envelope = JSON.parse(readFileSync(join(v2, name), "utf8")) as Partial<UpdateEnvelope>;
+      const manifest = JSON.parse(Buffer.from(envelope.manifest ?? "", "base64").toString("utf8") || "{}");
+      sequences.push((manifest as Partial<UpdateManifest>).sequence);
+    }
+  const numbers = sequences.filter((sequence): sequence is number => typeof sequence === "number");
+  return numbers.length ? Math.max(...numbers) : null;
 }
 
 /**
- * The publish time in seconds, and past the release `<channel>.json` in `dir` already names: apps take only a larger
- * sequence, so a clock behind the last publisher's would make this release look older to every one of them.
+ * The publish time in seconds, and past every release of the channel in `dir`: apps take only a larger sequence, so a
+ * clock behind the last publisher's would make this release look older to every one of them. A phone's native APIs
+ * share one count, so a binary moving to the next generation never meets a smaller number.
  */
 export function nextSequence(dir: string, channel: string, now = Math.floor(Date.now() / 1000)): number {
-  const path = join(dir, `${channel}.json`);
-  if (!existsSync(path)) return now;
-  const previous = (JSON.parse(readFileSync(path, "utf8")) as Partial<UpdateManifest>).sequence;
-  if (typeof previous !== "number" || previous < now) return now;
+  const previous = publishedSequence(dir, channel);
+  if (previous === null || previous < now) return now;
   if (previous > now)
     log.warn(
       `the ${channel} release already here has sequence ${previous}, later than this computer's clock (${now}): publishing as ${previous + 1}. Check the clock of the computer that publishes.`,
@@ -41,10 +61,10 @@ export function nextSequence(dir: string, channel: string, now = Math.floor(Date
   return previous + 1;
 }
 
-/** `<out>/<os>-<arch>` for a desktop release, `<out>/<platform>` for a phone's web bundle. */
-export function releaseDir(out: string, platform: ReleasePlatform): string {
+/** `<out>/<os>-<arch>` for a desktop release (the arch it was built for), `<out>/<platform>` for a phone's web bundle. */
+export function releaseDir(out: string, platform: ReleasePlatform, arch?: DesktopArch): string {
   const desktop = platform === "macos" || platform === "windows" || platform === "linux";
-  return join(out, desktop ? `${platform}-${hostArch()}` : platform);
+  return join(out, desktop ? `${platform}-${arch ?? hostArch()}` : platform);
 }
 
 /** Refuses before the build a desktop release the apps of its channel would refuse for its server (assertSameServer). */
@@ -53,16 +73,25 @@ export function assertServerOfChannel(
   platform: ReleasePlatform,
   out: string,
   channel: string,
+  arch?: DesktopArch,
 ): void {
   if (platform === "macos" || platform === "windows" || platform === "linux")
-    assertSameServer(releaseDir(out, platform), channel, !!config.desktop?.server);
+    assertSameServer(releaseDir(out, platform, arch), channel, !!config.desktop?.server);
 }
 
-/** Refuses before the build a release that could not be signed: no key on this machine, or another app's. */
-export function assertSigningKey(config: { app: { id: string }; updates?: { publicKey: string } | null }): void {
+/**
+ * Refuses before the build a release that could not be signed: no key on this machine, another app's, or for a desktop
+ * app one the app does not trust (it trusts the first of updates.publicKeys).
+ */
+export function assertSigningKey(
+  config: { app: { id: string }; updates?: { publicKeys: string[] } | null },
+  platform?: ReleasePlatform,
+): void {
   if (!config.updates)
-    throw new CliError("akan-native.config.ts has no updates: { url, publicKey } (run `akan-native update keygen`)");
-  signingKey(updateKeyPath(config.app.id), config.updates.publicKey);
+    throw new CliError("akan-native.config.ts has no updates: { url, publicKeys } (run `akan-native update keygen`)");
+  const { index } = signingKey(updateKeyPath(config.app.id), config.updates.publicKeys);
+  if (index !== 0 && (platform === "macos" || platform === "windows" || platform === "linux"))
+    throw new CliError("a desktop app trusts the first of updates.publicKeys only: sign with that key");
 }
 
 /**
@@ -77,7 +106,16 @@ function writeSigned(dir: string, channel: string, bytes: Uint8Array, signature:
   renameSync(`${json}.tmp`, json);
 }
 
-/** Writes the release of `artifact` (the app a release build made) and its signed `<channel>.json` under `out`. */
+/** A phone's envelope replaces the last one in a single rename, so no reader meets half of either. */
+function writeEnvelope(dir: string, channel: string, nativeApi: string, envelope: UpdateEnvelope): string {
+  const file = join(dir, channel, `${nativeApi}.json`);
+  mkdirSync(join(dir, channel), { recursive: true });
+  writeFileSync(`${file}.tmp`, `${JSON.stringify(envelope)}\n`);
+  renameSync(`${file}.tmp`, file);
+  return file;
+}
+
+/** Writes the release of `artifact` (the app a release build made) and its signed manifest under `out`. */
 export async function publishRelease(
   ctx: BuildContext,
   platform: ReleasePlatform,
@@ -87,12 +125,12 @@ export async function publishRelease(
 ): Promise<PublishedRelease> {
   const { config } = ctx.project;
   if (!config.updates)
-    throw new CliError("akan-native.config.ts has no updates: { url, publicKey } (run `akan-native update keygen`)");
+    throw new CliError("akan-native.config.ts has no updates: { url, publicKeys } (run `akan-native update keygen`)");
   const desktop = platform === "macos" || platform === "windows" || platform === "linux" ? platform : null;
   
-  const dir = releaseDir(out, platform);
+  const dir = releaseDir(out, platform, ctx.arch);
   assertChannel(channel);
-  assertSigningKey(config);
+  assertSigningKey(config, platform);
   const keyPath = updateKeyPath(config.app.id);
   const sequence = nextSequence(dir, channel);
 
@@ -113,9 +151,18 @@ export async function publishRelease(
     });
   }
   const bytes = new TextEncoder().encode(`${JSON.stringify(manifest, null, 2)}\n`);
-  const signature = `${signManifest(bytes, keyPath, config.updates.publicKey)}\n`;
   mkdirSync(dir, { recursive: true });
-  writeSigned(dir, channel, bytes, signature);
-  for (const file of leftovers) rmSync(file, { force: true });
-  return { dir, manifest };
+  let file: string;
+  if (desktop) {
+    writeSigned(dir, channel, bytes, `${signManifest(bytes, keyPath, config.updates.publicKeys)}\n`);
+    file = join(dir, `${channel}.json`);
+  } else
+    file = writeEnvelope(
+      dir,
+      channel,
+      manifest.nativeApi ?? "",
+      sealManifest(bytes, keyPath, config.updates.publicKeys),
+    );
+  for (const leftover of leftovers) rmSync(leftover, { force: true });
+  return { dir, manifest, file };
 }