akanjs 3.0.1 → 3.0.2

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

@@ -0,0 +1,101 @@
+
+
+export interface AliasTarget {
+  /** The HFS+ volume name (the disk image's label). */
+  volumeName: string;
+  /**
+   * The volume header's createDate as it stands, in HFS seconds. HFS+ writes it on the local clock of whatever formatted
+   * the volume (TN1150), unlike every other date, so it is read off the image rather than computed here.
+   */
+  volumeCreated: number;
+  /** Where the volume mounts: /Volumes/<name>. */
+  volumePath: string;
+  kind: "file" | "folder";
+  name: string;
+  cnid: number;
+  created: Date;
+  parentName: string;
+  parentCnid: number;
+  /** The CNIDs of the folders above the target, nearest first, the volume's root left out. */
+  cnidPath: number[];
+  /** From the volume's root, starting with "/". */
+  posixPath: string;
+}
+
+/** Seconds since 1904-01-01 UTC, the HFS epoch. */
+export function hfsTime(date: Date): number {
+  return Math.max(0, Math.floor(date.getTime() / 1000) + 2_082_844_800) >>> 0;
+}
+
+const EJECTABLE_DISK = 5;
+
+/** A Carbon name: ':' is the path separator there, so a name spells it '/'. */
+function pascal(text: string, size: number): Uint8Array {
+  const bytes = new TextEncoder().encode(text.replaceAll(":", "/")).subarray(0, size - 1);
+  const out = new Uint8Array(size);
+  out[0] = bytes.length;
+  out.set(bytes, 1);
+  return out;
+}
+
+function utf16WithLength(text: string): Uint8Array {
+  const out = new Uint8Array(2 + text.length * 2);
+  const view = new DataView(out.buffer);
+  view.setUint16(0, text.length);
+  for (let i = 0; i < text.length; i++) view.setUint16(2 + i * 2, text.charCodeAt(i));
+  return out;
+}
+
+export function aliasRecord(target: AliasTarget): Uint8Array {
+  const fixed = new Uint8Array(150);
+  const view = new DataView(fixed.buffer);
+  view.setUint16(6, 2);
+  view.setUint16(8, target.kind === "folder" ? 1 : 0);
+  fixed.set(pascal(target.volumeName, 28), 10);
+
+  view.setUint32(38, target.volumeCreated);
+  fixed.set(new TextEncoder().encode("H+"), 42);
+  view.setUint16(44, EJECTABLE_DISK);
+  view.setUint32(46, target.parentCnid);
+  fixed.set(pascal(target.name, 64), 50);
+  view.setUint32(114, target.cnid);
+  view.setUint32(118, hfsTime(target.created));
+  view.setInt16(130, -1);
+  view.setInt16(132, -1);
+
+  const encoder = new TextEncoder();
+  const cnids = new Uint8Array(target.cnidPath.length * 4);
+  for (const [idx, cnid] of target.cnidPath.entries()) new DataView(cnids.buffer).setUint32(idx * 4, cnid);
+  const carbonPath = [target.volumeName, ...target.posixPath.split("/").filter(Boolean)]
+    .map((part) => part.replaceAll(":", "/"))
+    .join(":");
+  const extras: [number, Uint8Array][] = [
+    [0, encoder.encode(target.parentName.replaceAll(":", "/"))],
+    [1, cnids],
+    [2, encoder.encode(carbonPath)],
+    [14, utf16WithLength(target.name)],
+    [15, utf16WithLength(target.volumeName)],
+    [18, encoder.encode(target.posixPath)],
+    [19, encoder.encode(target.volumePath)],
+  ];
+  const parts: Uint8Array[] = [fixed];
+  for (const [tag, data] of extras) {
+    const head = new Uint8Array(4);
+    new DataView(head.buffer).setInt16(0, tag);
+    new DataView(head.buffer).setUint16(2, data.length);
+    parts.push(head, data, ...(data.length % 2 ? [new Uint8Array(1)] : []));
+  }
+  const end = new Uint8Array(4);
+  new DataView(end.buffer).setInt16(0, -1);
+  parts.push(end);
+
+  const length = parts.reduce((sum, part) => sum + part.length, 0);
+  const record = new Uint8Array(length);
+  let at = 0;
+  for (const part of parts) {
+    record.set(part, at);
+    at += part.length;
+  }
+  new DataView(record.buffer).setUint16(4, length);
+  return record;
+}

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

@@ -1,7 +1,7 @@
 
 
 import { randomBytes } from "node:crypto";
-import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { exec, execOrThrow } from "./exec.ts";
@@ -283,33 +283,6 @@ export async function zipForNotary(appPath: string, zip: string): Promise<void>
 }
 
 /** A compressed disk image of the app beside a link to /Applications, the window people drag it into. */
-export async function buildDmg(appPath: string, dmgPath: string, volumeName: string, workDir: string): Promise<void> {
-  const staging = join(workDir, "dmg");
-  rmSync(staging, { recursive: true, force: true });
-  mkdirSync(staging, { recursive: true });
-  await execOrThrow(["ditto", appPath, join(staging, basename(appPath))], { echo: false });
-  symlinkSync("/Applications", join(staging, "Applications"));
-  rmSync(dmgPath, { force: true });
-  await execOrThrow(
-    [
-      "hdiutil",
-      "create",
-      "-volname",
-      volumeName,
-      "-srcfolder",
-      staging,
-      "-ov",
-      "-fs",
-      "HFS+",
-      "-format",
-      "UDZO",
-      dmgPath,
-    ],
-    { echo: false },
-  );
-  rmSync(staging, { recursive: true, force: true });
-}
-
 /** What Gatekeeper says of a notarized app or disk image, as a downloaded copy would be judged. */
 export async function assessGatekeeper(file: string, type: "execute" | "open"): Promise<void> {
   const args =

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

@@ -8,6 +8,7 @@ import { manifestPermissionProblems, type PermissionSet, resolveAcl } from "./ac
 import { unknownConfigKeys } from "./configkeys.ts";
 import { validateCsp, validateExternalSchemes } from "./csp.ts";
 import { type DesktopServerConfig, validateDesktopServer } from "./desktop-server.ts";
+import { type ResolvedDmg, validateDmg } from "./dmg.ts";
 import { type EnvConfig, validateEnvConfig } from "./env.ts";
 import { CliError } from "./log.ts";
 import { type PermissionsConfig, validatePermissions } from "./permissions.ts";
@@ -18,7 +19,8 @@ import { type UpdatesConfig, validateUpdates } from "./updates.ts";
 
 const CONFIG_FILES = ["akan-native.config.ts", "akan-native.config.js", "akan-native.config.mjs"];
 
-export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash" | "permissions" | "updates"> {
+export interface ResolvedConfig
+  extends Omit<AkanNativeConfig, "icon" | "splash" | "permissions" | "updates" | "desktop"> {
   app: Required<AkanNativeConfig["app"]>;
   web: Required<Pick<AkanNativeConfig["web"], "dir" | "base">> & { build?: string; devEntry?: string };
   plugins: string[];
@@ -35,6 +37,7 @@ export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash"
     server?: DesktopServerConfig;
     /** Absolute. */
     bin?: string;
+    dmg: ResolvedDmg;
   };
   updates: UpdatesConfig | null;
   /** Absolute image path. */
@@ -212,6 +215,7 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
   if (bin !== undefined && !(binDir && existsSync(binDir) && statSync(binDir).isDirectory()))
     problems.push(`desktop.bin must be a folder (got ${JSON.stringify(bin)})`);
   const desktopServer = validateDesktopServer(raw.desktop, appDir, problems);
+  const dmg = validateDmg(raw.desktop?.dmg, appDir, problems);
   if (raw.keyboard?.resize !== undefined && raw.keyboard.resize !== "resize" && raw.keyboard.resize !== "none") {
     problems.push(`keyboard.resize must be "resize" or "none" (got ${JSON.stringify(raw.keyboard.resize)})`);
   }
@@ -281,6 +285,7 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
       },
       ...(desktopServer ? { server: desktopServer } : {}),
       ...(binDir ? { bin: binDir } : {}),
+      dmg,
     },
     updates,
     icon: icon ? { ...icon, image: resolve(appDir, icon.image) } : null,

package/vendor/@akanjs/native/packages/cli/src/platforms/linux-appimage.ts

@@ -11,15 +11,20 @@ import type { BuildContext } from "../lib/prepare.ts";
 import { ensureInstalled, TOOLCHAIN } from "../lib/toolchains.ts";
 import { targetArch } from "./desktop.ts";
 
-/** The launcher entry (freedesktop Desktop Entry): what a menu shows and which link schemes open the app. */
-export function desktopEntry(input: { name: string; fileName: string; schemes: string[] }): string {
+/**
+ * The launcher entry (freedesktop Desktop Entry): what a menu shows and which link schemes open the app. Named and
+ * matched by the app id, the window's program name (native/desktop lib.rs): AppImageLauncher and appimaged rename the
+ * file they install, so StartupWMClass is what still ties the window to it.
+ */
+export function desktopEntry(input: { id: string; name: string; fileName: string; schemes: string[] }): string {
   const escape = (value: string) => value.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
   return [
     "[Desktop Entry]",
     "Type=Application",
     `Name=${escape(input.name)}`,
     `Exec=${input.fileName} %u`,
-    `Icon=${input.fileName}`,
+    `Icon=${input.id}`,
+    `StartupWMClass=${input.id}`,
     "Terminal=false",
     "Categories=Utility;",
     ...(input.schemes.length ? [`MimeType=${input.schemes.map((s) => `x-scheme-handler/${s};`).join("")}`] : []),
@@ -59,13 +64,18 @@ export async function buildAppImage(ctx: BuildContext, folder: string): Promise<
   writeFileSync(join(appDir, "AppRun"), appRun(config.app.fileName));
   chmodSync(join(appDir, "AppRun"), 0o755);
   writeFileSync(
-    join(appDir, `${config.app.fileName}.desktop`),
-    desktopEntry({ name: config.app.name, fileName: config.app.fileName, schemes: config.deepLinks.schemes }),
+    join(appDir, `${config.app.id}.desktop`),
+    desktopEntry({
+      id: config.app.id,
+      name: config.app.name,
+      fileName: config.app.fileName,
+      schemes: config.deepLinks.schemes,
+    }),
   );
   const art = iconArt(config);
   if (art) {
-    writeFileSync(join(appDir, `${config.app.fileName}.png`), encodePng(resize(art.master, 256, 256)));
-    symlinkSync(`${config.app.fileName}.png`, join(appDir, ".DirIcon"));
+    writeFileSync(join(appDir, `${config.app.id}.png`), encodePng(resize(art.master, 256, 256)));
+    symlinkSync(`${config.app.id}.png`, join(appDir, ".DirIcon"));
   }
 
   log.step("installer: AppImage");

package/vendor/@akanjs/native/packages/cli/src/platforms/linux.ts

@@ -4,8 +4,10 @@ import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { ParsedArgs } from "../lib/args.ts";
 import { iconArt, windowIcon } from "../lib/icons.ts";
+import { resize } from "../lib/image.ts";
 import type { Launched, LaunchOptions } from "../lib/launch.ts";
 import { dim, log } from "../lib/log.ts";
+import { encodePng } from "../lib/png.ts";
 import type { BuildContext } from "../lib/prepare.ts";
 import {
   buildNativeLibrary,
@@ -39,7 +41,10 @@ export async function buildLinux(ctx: BuildContext): Promise<string> {
   const resources = resourcesOf("linux", dir);
   writeDesktopResources(ctx, resources, "linux");
   const art = iconArt(config);
-  if (art) writeFileSync(join(resources, "icon.rgba"), windowIcon(art.master));
+  if (art) {
+    writeFileSync(join(resources, "icon.rgba"), windowIcon(art.master));
+    writeFileSync(join(resources, "icon.png"), encodePng(resize(art.master, 256, 256)));
+  }
   if (ctx.linux?.appImage) ctx.artifacts.push({ kind: "installer", path: await buildAppImage(ctx, dir) });
   const size = await folderSize(dir);
   if (size) log.info(dim(`size ${size}`));

package/vendor/@akanjs/native/packages/cli/src/platforms/macos.ts

@@ -14,6 +14,7 @@ import {
 } from "node:fs";
 import { basename, join } from "node:path";
 import type { ParsedArgs } from "../lib/args.ts";
+import { buildDmg } from "../lib/dmg.ts";
 import { execOrThrow } from "../lib/exec.ts";
 import { icns, iconArt, macosIconImage } from "../lib/icons.ts";
 import type { Launched, LaunchOptions } from "../lib/launch.ts";
@@ -21,7 +22,6 @@ import { dim, log } from "../lib/log.ts";
 import {
   appEntitlements,
   assessGatekeeper,
-  buildDmg,
   codesign,
   notarize,
   type ResolvedMacosIdentity,
@@ -144,7 +144,10 @@ export async function buildMacos(ctx: BuildContext): Promise<string> {
       if (ctx.macos?.dmg) {
         const dmg = join(outDir, `${config.app.fileName}-${config.app.version}-${ctx.arch ?? hostArch()}.dmg`);
         log.step(`dmg: ${basename(dmg)}`);
-        await buildDmg(appPath, dmg, config.app.name, join(outDir, "gen"));
+        await buildDmg(appPath, dmg, config.app.name, join(outDir, "gen"), {
+          layout: config.desktop.dmg,
+          volumeIcon: join(resources, "AppIcon.icns"),
+        });
         
         if (identity.sign !== "-") await codesign(identity, dmg, { hardened: false, timestamp: team });
         if (notarization) {

package/vendor/@akanjs/native/packages/desktop/src/deeplinks.ts

@@ -25,12 +25,19 @@ export function desktopExec(exe: string): string {
   return `"${exe.replace(/[\\"`$]/g, (c) => `\\${c}`)}" %u`;
 }
 
-export function desktopEntry(name: string, exe: string, schemes: readonly string[]): string {
+export function desktopEntry(
+  name: string,
+  exe: string,
+  schemes: readonly string[],
+  { id, icon = false }: { id?: string; icon?: boolean } = {},
+): string {
   return [
     "[Desktop Entry]",
     "Type=Application",
     `Name=${name.replace(/[\r\n]/g, " ")}`,
     `Exec=${desktopExec(exe)}`,
+    ...(id && icon ? [`Icon=${id}`] : []),
+    ...(id ? [`StartupWMClass=${id}`] : []),
     "Terminal=false",
     
     "NoDisplay=true",
@@ -69,17 +76,28 @@ function writeIfChanged(path: string, text: string): boolean {
   return true;
 }
 
+/** Copies the app's icon into the user's hicolor theme as <app id>.png; false without one. */
+function installIcon(dataHome: string, id: string, icon: string | undefined): boolean {
+  if (!icon || !existsSync(icon)) return false;
+  const target = join(dataHome, "icons", "hicolor", "256x256", "apps", `${id}.png`);
+  const bytes = readFileSync(icon);
+  if (existsSync(target) && readFileSync(target).equals(bytes)) return true;
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, bytes);
+  return true;
+}
+
 async function registerLinux(
   app: { id: string; name: string },
   exe: string,
   schemes: readonly string[],
-  env: Env,
-  home: string,
-  runner: Runner,
+  { env, home, runner, icon }: { env: Env; home: string; runner: Runner; icon?: string },
 ): Promise<void> {
   const file = `${app.id}.desktop`;
-  const applications = join(xdg(env.XDG_DATA_HOME, join(home, ".local", "share")), "applications");
-  const entryChanged = writeIfChanged(join(applications, file), desktopEntry(app.name, exe, schemes));
+  const dataHome = xdg(env.XDG_DATA_HOME, join(home, ".local", "share"));
+  const applications = join(dataHome, "applications");
+  const entry = desktopEntry(app.name, exe, schemes, { id: app.id, icon: installIcon(dataHome, app.id, icon) });
+  const entryChanged = writeIfChanged(join(applications, file), entry);
   const listPath = join(xdg(env.XDG_CONFIG_HOME, join(home, ".config")), "mimeapps.list");
   const list = existsSync(listPath) ? readFileSync(listPath, "utf8") : "";
   writeIfChanged(listPath, withDefaults(list, file, schemes));
@@ -128,16 +146,21 @@ async function registerWindows(
   }
 }
 
-/** Makes this executable the current user's handler of the app's schemes (Windows, Linux). */
+/**
+ * Makes this executable the current user's handler of the app's schemes (Windows, Linux). `icon`: a 256 px PNG the
+ * Linux entry shows (resources/icon.png).
+ */
 export async function registerDeepLinks(
   app: { id: string; name: string },
   schemes: readonly string[],
-  options: { exe?: string; platform?: NodeJS.Platform; env?: Env; home?: string; run?: Runner } = {},
+  options: { exe?: string; platform?: NodeJS.Platform; env?: Env; home?: string; run?: Runner; icon?: string } = {},
 ): Promise<void> {
   const platform = options.platform ?? process.platform;
   if (!schemes.length || (platform !== "win32" && platform !== "linux")) return;
-  const exe = options.exe ?? process.execPath;
+  const env = options.env ?? process.env;
+  
+  const exe = options.exe ?? (env.APPIMAGE || process.execPath);
   const runner = options.run ?? run;
   if (platform === "win32") await registerWindows(app, exe, schemes, runner);
-  else await registerLinux(app, exe, schemes, options.env ?? process.env, options.home ?? homedir(), runner);
+  else await registerLinux(app, exe, schemes, { env, home: options.home ?? homedir(), runner, icon: options.icon });
 }

package/vendor/@akanjs/native/packages/desktop/src/host.ts

@@ -447,7 +447,7 @@ export function startHost(plugins: DesktopPlugin[]): void {
       if (typeof launch.exit === "number") return;
       
       openLinks(process.argv.slice(2));
-      registerDeepLinks(boot.app, deepLinkSchemes).catch((error) =>
+      registerDeepLinks(boot.app, deepLinkSchemes, { icon: join(paths.resources, "icon.png") }).catch((error) =>
         console.warn("[akan-native] cannot register the deep link schemes", error),
       );
     })

package/webkit/RenderFailure.tsx

@@ -0,0 +1,32 @@
+"use client";
+import { Translator } from "akanjs/client";
+import { parseAkanI18nEnv } from "akanjs/common";
+
+const errorKeyPattern = /^[a-zA-Z][A-Za-z0-9]*\.error\.[A-Za-z0-9_]+$/;
+
+const messageOf = (error: unknown, lang: string) => {
+  if (!(error instanceof Error) || !errorKeyPattern.test(error.message))
+    return Translator.translateByLocale(lang, "base.pageLoadFailed");
+  const { data } = error as { data?: Record<string, string | number> };
+  return Translator.translateByLocale(lang, error.message, data);
+};
+
+interface RenderFailureProps {
+  error: unknown;
+  onRetry: () => void;
+}
+export const RenderFailure = ({ error, onRetry }: RenderFailureProps) => {
+  const lang = Translator.getActiveLocale() ?? parseAkanI18nEnv().defaultLocale;
+  return (
+    <div role="alert" className="flex min-h-[60vh] flex-col items-center justify-center gap-4 p-6 text-center">
+      <p className="max-w-sm text-foreground/70 text-sm">{messageOf(error, lang)}</p>
+      <button
+        type="button"
+        onClick={onRetry}
+        className="rounded-field bg-primary px-4 py-2 font-medium text-primary-foreground text-sm"
+      >
+        {Translator.translateByLocale(lang, "base.retry")}
+      </button>
+    </div>
+  );
+};

package/webkit/RenderLayer.tsx

@@ -1,8 +1,9 @@
 "use client";
 import { debugFrame, RouteDefinition, type RouteRender, router, usePathCtx } from "akanjs/client";
 import { isThenable, Logger } from "akanjs/common";
-import { createContext, createElement, memo, type ReactNode, useContext, useEffect, useRef } from "react";
+import { createContext, createElement, memo, type ReactNode, useContext, useEffect, useRef, useState } from "react";
 import { CsrFrameDump } from "./csrFrameDump";
+import { RenderFailure } from "./RenderFailure";
 import { useFetch } from "./useFetch";
 import { usePageActivity } from "./usePageActivity";
 
@@ -17,6 +18,8 @@ interface RenderedRoute {
   record: ReturnType<typeof CsrFrameDump.track> | null;
   /** A redirect was issued while the render ran, so what it drew is not the page. */
   redirected: boolean;
+  /** The render rejected while its page stayed: what the layer draws instead, with a retry. */
+  failure: { error: unknown } | null;
 }
 
 interface RenderLayerProps {
@@ -36,6 +39,7 @@ export const RenderLayer = memo(({ renders, index, params, searchParams, leaf =
   const routeRender = renders[index];
   const isAsyncRender = isAsyncRouteRender(routeRender);
   const renderedRef = useRef<RenderedRoute | null>(null);
+  const [, setFailures] = useState(0);
   const activity = usePageActivity();
   
   const onScreenRef = useRef(activity === "current");
@@ -75,13 +79,18 @@ export const RenderLayer = memo(({ renders, index, params, searchParams, leaf =
         result,
         record: isThenable(result) ? CsrFrameDump.track(layer, result as Promise<ReactNode>) : null,
         redirected: false,
+        failure: null,
       };
       if (isThenable(result))
         (result as Promise<ReactNode>).then(
           () => {
             next.redirected = router.redirectCount() !== redirectsBefore;
           },
-          () => undefined,
+          (error: unknown) => {
+            if (router.redirectCount() !== redirectsBefore || renderedRef.current !== next) return;
+            next.failure = { error };
+            setFailures((count) => count + 1);
+          },
         );
       renderedRef.current = next;
     }
@@ -98,6 +107,17 @@ export const RenderLayer = memo(({ renders, index, params, searchParams, leaf =
   }, [record]);
   if (!routeRender) return null;
   if (!isAsyncRender) return createElement(routeRender.render as never, { children, params, searchParams } as never);
+  const failure = renderedRef.current?.failure;
+  if (failure)
+    return (
+      <RenderFailure
+        error={failure.error}
+        onRetry={() => {
+          renderedRef.current = null;
+          setFailures((count) => count + 1);
+        }}
+      />
+    );
   if (!value) return <>{composeLoadingFallback(renders.slice(index), params)}</>;
   return <layerChildContext.Provider value={children}>{value}</layerChildContext.Provider>;
 });