akanjs 3.0.0-beta.9 → 3.0.0

package/vendor/@akanjs/native/packages/core/src/errors.ts

@@ -0,0 +1,95 @@
+import { type BridgeErrorBody, ERROR_CODES, type ErrorCode } from "./protocol.ts";
+
+/**
+ * The web-standard name of each code (bridge v1.1), so `error.name === "AbortError"` works as it does
+ * for fetch; `code` stays the akan-native code.
+ */
+const ERROR_NAMES: Partial<Record<ErrorCode, string>> = {
+  CANCELLED: "AbortError",
+  TIMEOUT: "TimeoutError",
+  PERMISSION_DENIED: "NotAllowedError",
+  NOT_ALLOWED: "NotAllowedError",
+  UNSUPPORTED: "NotSupportedError",
+  NOT_FOUND: "NotFoundError",
+};
+
+export interface AkanNativeErrorOptions {
+  cause?: unknown;
+  /** Details a caller can act on, e.g. `{ reason: "packageManaged" }`. */
+  data?: unknown;
+  /** The same call may work later. */
+  retryable?: boolean;
+  /** Overrides the name derived from the code (DataCloneError for arguments JSON cannot carry). */
+  name?: string;
+}
+
+export class AkanNativeError extends Error {
+  readonly code: ErrorCode;
+  readonly data?: unknown;
+  readonly retryable: boolean;
+
+  constructor(code: ErrorCode, message: string, options?: AkanNativeErrorOptions) {
+    super(message, options?.cause === undefined ? undefined : { cause: options.cause });
+    this.name = options?.name ?? ERROR_NAMES[code] ?? "AkanNativeError";
+    this.code = code;
+    if (options?.data !== undefined) this.data = options.data;
+    this.retryable = options?.retryable === true;
+  }
+
+  /**
+   * Builds a real Error from a wire error so callers get a stack trace
+   * (Capacitor copies native error fields onto an Error for the same reason:
+   * capacitor/core/native-bridge.ts `returnResult`).
+   */
+  static fromBody(body: BridgeErrorBody | undefined, cause?: unknown): AkanNativeError {
+    const code = body && ERROR_CODES.includes(body.code) ? body.code : "INTERNAL";
+    return new AkanNativeError(code, body?.message ?? "unknown error", {
+      data: body?.data,
+      retryable: body?.retryable === true,
+      cause,
+    });
+  }
+
+  /** Normalizes anything thrown by an implementation into an AkanNativeError. */
+  static from(error: unknown): AkanNativeError {
+    if (error instanceof AkanNativeError) return error;
+    if (error instanceof Error || isDomException(error)) {
+      const e = error as Error;
+      const code = FROM_NAMES[e.name];
+      return new AkanNativeError(code ?? "INTERNAL", e.message, { cause: error });
+    }
+    return new AkanNativeError("INTERNAL", String(error));
+  }
+
+  /** The error body a host sends for this error. */
+  toBody(): BridgeErrorBody {
+    const body: BridgeErrorBody = { code: this.code, message: this.message };
+    if (this.data !== undefined) body.data = this.data;
+    if (this.retryable) body.retryable = true;
+    return body;
+  }
+}
+
+/** Web errors thrown by web implementations and the page's own signals. */
+const FROM_NAMES: Record<string, ErrorCode> = {
+  AbortError: "CANCELLED",
+  TimeoutError: "TIMEOUT",
+  NotAllowedError: "PERMISSION_DENIED",
+  SecurityError: "PERMISSION_DENIED",
+  NotSupportedError: "UNSUPPORTED",
+  NotFoundError: "NOT_FOUND",
+};
+
+/** DOMException is not an Error subclass in every engine. */
+function isDomException(value: unknown): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { name?: unknown }).name === "string" &&
+    typeof (value as { message?: unknown }).message === "string"
+  );
+}
+
+export function isAkanNativeError(error: unknown, code?: ErrorCode): error is AkanNativeError {
+  return error instanceof AkanNativeError && (code === undefined || error.code === code);
+}

package/vendor/@akanjs/native/packages/core/src/files.ts

@@ -0,0 +1,105 @@
+
+
+import { AkanNativeError } from "./errors.ts";
+import { BRIDGE_PLUGIN, type FileRef, RELEASE } from "./protocol.ts";
+import { runtime } from "./runtime.ts";
+
+/**
+ * Stops serving a FileRef. FileRefs live for the app session (architecture review, 2026-09-26), so
+ * release the ones the page no longer shows: photos, picked files, downloads. The host forgets the
+ * URL and deletes akan-native's own copy of the file; files that belong to the user (a document served in
+ * place) stay. Holding the URL is the permission, as for any follow-up on what a call handed out.
+ * Resolves whether it was served. On the web, a blob: URL is revoked.
+ */
+export async function releaseFile(file: FileRef | string): Promise<boolean> {
+  const url = typeof file === "string" ? file : file?.url;
+  if (typeof url !== "string") throw new AkanNativeError("INVALID_ARGS", "releaseFile needs a FileRef or its url");
+  const rt = runtime();
+  if (!rt.transport) {
+    if (!url.startsWith("blob:")) return false;
+    URL.revokeObjectURL(url);
+    return true;
+  }
+  const response = await rt.transport.send({
+    v: 1,
+    id: ++rt.nextId,
+    plugin: BRIDGE_PLUGIN,
+    method: RELEASE,
+    args: { url },
+  });
+  if (!response.ok) throw AkanNativeError.fromBody(response.error);
+  return (response.result as { released?: unknown } | undefined)?.released === true;
+}
+
+export interface FileReadOptions {
+  /** Bytes per Range request. Default 4 MiB. */
+  chunkSize?: number;
+  signal?: AbortSignal;
+}
+
+const CONTENT_RANGE = /^bytes (\d+)-(\d+)\/(\d+|\*)$/;
+
+/**
+ * Reads a FileRef (or any same-origin URL) in pieces with HTTP Range requests, so a big file never
+ * has to be one response: the desktop shell answers without streaming (WRY), reading a whole
+ * response into memory (architecture review stage 4). Every host serves FileRefs with
+ * `Accept-Ranges: bytes`. A server that ignores Range (200) is streamed as it answers.
+ */
+export function fileStream(file: FileRef | string, options: FileReadOptions = {}): ReadableStream<Uint8Array> {
+  const url = typeof file === "string" ? file : file.url;
+  const chunk = Math.max(1, Math.floor(options.chunkSize ?? 4 << 20));
+  let offset = 0;
+  let total: number | null = typeof file === "object" && Number.isFinite(file.size) ? file.size : null;
+  let whole: ReadableStreamDefaultReader<Uint8Array> | null = null;
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        if (whole) {
+          const { done, value } = await whole.read();
+          if (done) controller.close();
+          else controller.enqueue(value);
+          return;
+        }
+        if (total !== null && offset >= total) return controller.close();
+        const response = await fetch(url, {
+          headers: { range: `bytes=${offset}-${offset + chunk - 1}` },
+          ...(options.signal ? { signal: options.signal } : {}),
+        });
+        if (response.status === 416 && total === null) return controller.close(); 
+        if (response.status === 200) {
+          
+          whole = response.body!.getReader();
+          return this.pull!(controller);
+        }
+        if (response.status !== 206)
+          throw new AkanNativeError(
+            response.status === 404 ? "NOT_FOUND" : "INTERNAL",
+            `${url}: HTTP ${response.status}`,
+          );
+        const range = CONTENT_RANGE.exec(response.headers.get("content-range") ?? "");
+        if (range && range[3] !== "*") total = Number(range[3]);
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        offset += bytes.length;
+        if (bytes.length) controller.enqueue(bytes);
+        if (bytes.length === 0 || (total !== null && offset >= total)) controller.close();
+      } catch (error) {
+        controller.error(AkanNativeError.from(error));
+      }
+    },
+    cancel() {
+      void whole?.cancel();
+    },
+  });
+}
+
+/** A FileRef as a Blob, read in Range pieces (see fileStream); `type` is the FileRef's MIME type. */
+export async function fileBlob(file: FileRef | string, options: FileReadOptions = {}): Promise<Blob> {
+  const parts: Uint8Array[] = [];
+  const reader = fileStream(file, options).getReader();
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    parts.push(value);
+  }
+  return new Blob(parts as BlobPart[], typeof file === "object" && file.mime ? { type: file.mime } : {});
+}

package/vendor/@akanjs/native/packages/core/src/index.ts

@@ -0,0 +1,35 @@
+export type { Access, AclGrant, CallScope, ResolvedAcl, ScopeEntry } from "./acl.ts";
+export { aclCheck, aclProblem, DENY_ALL, globMatch, listenItem, loadAcl, scopePermits, urlMatch } from "./acl.ts";
+export type { AkanNativeBoot, AppInfo, Platform, PluginDecl } from "./boot.ts";
+export { AkanNativeError, type AkanNativeErrorOptions, isAkanNativeError } from "./errors.ts";
+export { type FileReadOptions, fileBlob, fileStream, releaseFile } from "./files.ts";
+export type { LiveValue } from "./live.ts";
+export { createLiveValue, shallowEqual } from "./live.ts";
+export { mimeFor } from "./mime.ts";
+export type {
+  CallOptions,
+  Implementation,
+  ListenOptions,
+  Plugin,
+  PluginHandle,
+  PluginMethods,
+  PluginOptions,
+  WebCallContext,
+  WebPlugin,
+} from "./plugin.ts";
+export { definePlugin, defineWebPlugin } from "./plugin.ts";
+export type { CancelReason, ErrorCode, FileRef } from "./protocol.ts";
+export {
+  type AkanNativeEnv,
+  app,
+  type Env,
+  env,
+  isDev,
+  isNative,
+  nativeApi,
+  platform,
+  runtimeVersion,
+  windowId,
+} from "./state.ts";
+export type { VetoEvent, VetoHandler } from "./veto.ts";
+export { vetoable } from "./veto.ts";

package/vendor/@akanjs/native/packages/core/src/kernel.ts

@@ -0,0 +1,281 @@
+
+
+import {
+  EXTERNAL_SCHEMES,
+  FRAME_SCHEMES,
+  ID_BUNDLE,
+  ID_DOCUMENT,
+  ID_FILE_REF,
+  ID_NAME,
+  type IdSpec,
+  MAX_RANGE_BYTES,
+  MAX_RETAINED_EVENTS,
+  MIME,
+  MIME_UTF8,
+  NEVER_EXTERNAL_SCHEMES,
+  ROUTES,
+} from "./contract.ts";
+
+/** Whether `s` follows an id grammar: its characters and length, and an optional ".ext" after the first dot. */
+export function idValid(spec: IdSpec, s: string): boolean {
+  if (spec.extMax > 0) {
+    const dot = s.indexOf(".");
+    if (dot < 0) return run(s, spec.chars, spec.min, spec.max);
+    return run(s.slice(0, dot), spec.chars, spec.min, spec.max) && run(s.slice(dot + 1), spec.extChars, 1, spec.extMax);
+  }
+  if (s.length < spec.min || s.length > spec.max) return false;
+  if (!(spec.first || spec.chars).includes(s[0]!) || spec.notFirst.includes(s[0]!)) return false;
+  for (let i = 1; i < s.length; i++) if (!spec.chars.includes(s[i]!)) return false;
+  return true;
+}
+
+function run(s: string, chars: string, min: number, max: number): boolean {
+  if (s.length < min || s.length > max) return false;
+  for (const c of s) if (c.length !== 1 || !chars.includes(c)) return false;
+  return true;
+}
+
+export const isFileRefId = (s: string) => idValid(ID_FILE_REF, s);
+export const isBundleId = (s: string) => idValid(ID_BUNDLE, s);
+export const isDocumentId = (s: string) => idValid(ID_DOCUMENT, s);
+export const isName = (s: string) => idValid(ID_NAME, s);
+
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+const encoder = new TextEncoder();
+
+/** Strict percent-decoding: "%" and two hex digits, and the result must be UTF-8; otherwise null. */
+export function decodePath(s: string): string | null {
+  const bytes: number[] = [];
+  for (let i = 0; i < s.length; ) {
+    if (s[i] === "%") {
+      const hex = s.slice(i + 1, i + 3);
+      if (!/^[0-9A-Fa-f]{2}$/.test(hex)) return null;
+      bytes.push(parseInt(hex, 16));
+      i += 3;
+    } else {
+      const c = s.codePointAt(i)!;
+      const ch = String.fromCodePoint(c);
+      bytes.push(...encoder.encode(ch));
+      i += ch.length;
+    }
+  }
+  try {
+    return utf8.decode(new Uint8Array(bytes));
+  } catch {
+    return null;
+  }
+}
+
+export type Route =
+  | { kind: "init" }
+  | { kind: "ipc" }
+  | { kind: "hello" }
+  | { kind: "file"; id: string }
+  | { kind: "asset"; path: string }
+  | { kind: "not-found" };
+
+/**
+ * Maps a URL pathname (still percent-encoded) to a route. `exists` tells whether a relative asset
+ * path exists. Every host routes /__akan_native/ipc and /__akan_native/hello; the ones that do not serve them
+ * answer 404.
+ *
+ *   /__akan_native/init.js · /__akan_native/ipc · /__akan_native/hello · /__akan_native/file/<id>   the host's own
+ *   /__akan_native/<anything else>                                             404
+ *   existing file                                                       the file
+ *   missing, no extension                                               index.html (SPA route)
+ *   missing, with extension                                             404 (a missing asset should not turn into HTML)
+ *
+ * Traversal is refused, not normalized. A path with ":" is never looked up as a file: on Windows
+ * "C:" makes the joined path absolute (the host would read outside the app folder) and "a:b" names
+ * an alternate data stream. It can still be an SPA route ("/at/12:30").
+ */
+export function route(pathname: string, exists: (relativePath: string) => boolean): Route {
+  const decoded = decodePath(pathname);
+  if (decoded === null) return { kind: "not-found" };
+  const segments = decoded.split("/").filter((s) => s.length > 0);
+  if (segments.some((s) => s === ".." || s === "." || s.includes("\\") || s.includes("\0")))
+    return { kind: "not-found" };
+
+  if (segments[0] === ROUTES.root) {
+    if (segments.length === 2 && segments[1] === ROUTES.init) return { kind: "init" };
+    if (segments.length === 2 && segments[1] === ROUTES.ipc) return { kind: "ipc" };
+    if (segments.length === 2 && segments[1] === ROUTES.hello) return { kind: "hello" };
+    if (segments.length === 3 && segments[1] === ROUTES.file && isFileRefId(segments[2]!))
+      return { kind: "file", id: segments[2]! };
+    return { kind: "not-found" };
+  }
+  const relative = segments.join("/");
+  if (relative === "" || relative === "index.html") return { kind: "asset", path: "index.html" };
+  if (!relative.includes(":") && exists(relative)) return { kind: "asset", path: relative };
+  return segments[segments.length - 1]!.includes(".") ? { kind: "not-found" } : { kind: "asset", path: "index.html" };
+}
+
+/** Paths a host answers itself even when its pages come from a dev server: /__akan_native/*, and paths that do not decode. */
+export function isHostPath(pathname: string): boolean {
+  const decoded = decodePath(pathname);
+  return decoded === null || decoded.split("/").find((s) => s.length > 0) === ROUTES.root;
+}
+
+function extension(path: string): string | null {
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? null : base.slice(dot + 1).toLowerCase(); 
+}
+
+/** The MIME type for a file name (FileRefs): application/octet-stream when unknown. */
+export function fileMime(path: string): string {
+  const ext = extension(path);
+  return ext !== null && Object.hasOwn(MIME, ext) ? MIME[ext]! : "application/octet-stream";
+}
+
+/** The Content-Type an asset is served with: text types carry charset=utf-8. */
+export function assetMime(path: string): string {
+  const mime = fileMime(path);
+  return mime.startsWith("text/") || MIME_UTF8.includes(mime) ? `${mime}; charset=utf-8` : mime;
+}
+
+/**
+ * Whether a FileRef of this type is served with `Content-Security-Policy: sandbox`: everything but
+ * images other than SVG, audio, video, fonts and PDF. A sandboxed document has an opaque origin, so
+ * an HTML or SVG file a plugin serves (a picked or downloaded file) cannot reach the bridge or the
+ * page even when it is opened as a document; <img>, <video> and <audio> are unaffected. PDF is left
+ * out because macOS WebKit draws nothing for a sandboxed PDF (iOS and WebView2 do; checked
+ * 2026-09-26); its viewer runs no page script, and nosniff keeps HTML named .pdf a PDF.
+ */
+export function fileRefSandboxed(mime: string): boolean {
+  const type = mime.split(";")[0]!.trim().toLowerCase();
+  return type === "image/svg+xml" || !(/^(image|audio|video|font)\//.test(type) || type === "application/pdf");
+}
+
+export type RangeAnswer = { status: 200 } | { status: 206; start: number; end: number } | { status: 416 };
+
+/**
+ * A Range header (IN-5, RFC 9110 §14) for a file of `size` bytes. One "bytes=" range is supported:
+ * a header that is not one (another unit, several ranges, bad syntax, last before first) is ignored
+ * and the whole file is sent. A valid range the file cannot satisfy is 416. A response carries at
+ * most MAX_RANGE_BYTES, from the range's start.
+ */
+export function parseRange(header: string | null, size: number): RangeAnswer {
+  const m = header === null ? null : /^bytes=([0-9]{0,18})-([0-9]{0,18})$/.exec(header);
+  if (!m || (m[1] === "" && m[2] === "")) return { status: 200 };
+  let start: number;
+  let end: number;
+  if (m[1] === "") {
+    const suffix = Number(m[2]);
+    if (suffix === 0 || size === 0) return { status: 416 };
+    start = Math.max(0, size - suffix);
+    end = size - 1;
+  } else {
+    start = Number(m[1]);
+    const last = m[2] === "" ? Infinity : Number(m[2]);
+    if (last < start) return { status: 200 };
+    if (start >= size) return { status: 416 };
+    end = Math.min(last, size - 1);
+  }
+  return { status: 206, start, end: Math.min(end, start + MAX_RANGE_BYTES - 1) };
+}
+
+export type Admission = "current" | "new" | "ended" | "no-doc";
+
+/**
+ * What a host does with a request of document `requested` (null: none) while `current` is the
+ * window's document (null: none; "": one without an id): join the current one, start a new one
+ * (ending the current), refuse it because that document ended, or refuse it because it has no id
+ * while the current document has one (its answer would take a number the page never sees).
+ */
+export function admitDocument(current: string | null, ended: readonly string[], requested: string | null): Admission {
+  if (requested === null) return current === null ? "new" : current === "" ? "current" : "no-doc";
+  if (requested === current) return "current";
+  return ended.includes(requested) ? "ended" : "new";
+}
+
+/**
+ * Events that can come before the page listens (links, notification taps; plugins.md C2, Capacitor
+ * retainUntilConsumed). A live event goes to every listener; one that no listener accepted is kept
+ * when `retain` (at most MAX_RETAINED_EVENTS, the oldest go) and replayed, in order, to the next
+ * listener, once. A listener returns false when it is gone (its window ended): it is dropped and the
+ * event counts as not delivered.
+ */
+export class RetainedEvents<T> {
+  private readonly listeners = new Map<string, (event: T) => boolean>();
+  private readonly queue: T[] = [];
+
+  listen(key: string, listener: (event: T) => boolean): void {
+    this.listeners.set(key, listener);
+    while (this.queue.length) {
+      if (!listener(this.queue[0]!)) return void this.listeners.delete(key);
+      this.queue.shift();
+    }
+  }
+
+  unlisten(key: string): void {
+    this.listeners.delete(key);
+  }
+
+  emit(event: T, retain: boolean): void {
+    let delivered = false;
+    for (const [key, listener] of [...this.listeners]) {
+      if (listener(event)) delivered = true;
+      else this.listeners.delete(key);
+    }
+    if (!delivered && retain && this.queue.push(event) > MAX_RETAINED_EVENTS) this.queue.shift();
+  }
+}
+
+/**
+ * Whether a plugin's declaration in boot.json (`plugins[id]`: "web", or its native methods and
+ * events on this platform) lets a call through: hosts refuse undeclared methods and events with
+ * NOT_FOUND before the ACL and the plugin, whatever the plugin's code implements.
+ */
+export function declares(decl: unknown, method: string, event: string | null): boolean {
+  if (typeof decl !== "object" || decl === null) return false;
+  const list =
+    (method === "$listen" || method === "$unlisten"
+      ? (decl as { events?: unknown }).events
+      : (decl as { methods?: unknown }).methods) ?? [];
+  const name = method === "$listen" || method === "$unlisten" ? event : method;
+  return Array.isArray(list) && name !== null && list.includes(name);
+}
+
+/** The lowercase scheme of a URL, or null when it has none. */
+export function schemeOf(url: string): string | null {
+  const m = /^([A-Za-z][A-Za-z0-9+.-]*):/.exec(url);
+  return m ? m[1]!.toLowerCase() : null;
+}
+
+/** The schemes the shell hands to the OS: the contract's, and what the app added (never the forbidden ones). */
+export function externalSchemes(extra: readonly string[] = []): string[] {
+  return [
+    ...EXTERNAL_SCHEMES,
+    ...extra
+      .map((s) => s.toLowerCase())
+      .filter((s) => !NEVER_EXTERNAL_SCHEMES.includes(s) && !EXTERNAL_SCHEMES.includes(s)),
+  ];
+}
+
+/**
+ * Where a navigation goes. The app's own pages (and about:) load, but its /__akan_native/* paths never
+ * become a document of the app's origin: a FileRef holding someone's HTML would run with the
+ * bridge (Capacitor GHSA-rvm3-566m-v7fv); a frame may show a FileRef, which is served sandboxed
+ * (fileRefSandboxed). Otherwise a top-level navigation is handed to the OS when its scheme is an
+ * external one and dropped when not; a frame may load http, https, data, blob and about pages but
+ * never opens anything.
+ */
+export function decideNavigation(
+  url: string,
+  topLevel: boolean,
+  origin: string,
+  extra: readonly string[] = [],
+): "load" | "open" | "drop" {
+  const scheme = schemeOf(url);
+  const inApp = url === origin || (url.startsWith(origin) && "/?#".includes(url[origin.length]!));
+  if (inApp) {
+    const path = url.slice(origin.length).replace(/[?#][\s\S]*$/, "") || "/";
+    if (!isHostPath(path)) return "load";
+    return !topLevel && route(path, () => false).kind === "file" ? "load" : "drop";
+  }
+  if (scheme === "about") return "load";
+  if (scheme === null) return "drop";
+  if (!topLevel) return FRAME_SCHEMES.includes(scheme) ? "load" : "drop";
+  return externalSchemes(extra).includes(scheme) ? "open" : "drop";
+}

package/vendor/@akanjs/native/packages/core/src/live.ts

@@ -0,0 +1,62 @@
+
+
+export interface LiveValue<T> {
+  get(): T;
+  set(value: T): void;
+  subscribe(onChange: () => void): () => void;
+}
+
+/**
+ * `start` runs when the first subscriber arrives and may return a stop function,
+ * which runs one microtask after the last subscriber leaves (StrictMode safe).
+ */
+export function createLiveValue<T>(
+  initial: T,
+  start?: (set: (value: T) => void) => (() => void) | void,
+  equals: (a: T, b: T) => boolean = Object.is,
+): LiveValue<T> {
+  let value = initial;
+  const subscribers = new Set<() => void>();
+  let stop: (() => void) | null = null;
+  let running = false;
+  let stopScheduled = false;
+
+  const set = (next: T) => {
+    if (equals(value, next)) return;
+    value = next;
+    for (const fn of [...subscribers]) fn();
+  };
+
+  return {
+    get: () => value,
+    set,
+    subscribe(onChange) {
+      subscribers.add(onChange);
+      stopScheduled = false;
+      if (!running && start) {
+        running = true;
+        stop = start(set) ?? null;
+      }
+      return () => {
+        if (!subscribers.delete(onChange) || subscribers.size > 0) return;
+        stopScheduled = true;
+        queueMicrotask(() => {
+          if (!stopScheduled || subscribers.size > 0) return;
+          stopScheduled = false;
+          running = false;
+          const fn = stop;
+          stop = null;
+          fn?.();
+        });
+      };
+    },
+  };
+}
+
+/** Shallow equality for plain state objects. */
+export function shallowEqual<T extends object>(a: T, b: T): boolean {
+  if (a === b) return true;
+  const ka = Object.keys(a) as (keyof T)[];
+  const kb = Object.keys(b);
+  return ka.length === kb.length && ka.every((k) => Object.is(a[k], b[k]));
+}

package/vendor/@akanjs/native/packages/core/src/mime.ts

@@ -0,0 +1,8 @@
+
+
+import { fileMime } from "./kernel.ts";
+
+/** MIME type from the file name's extension; application/octet-stream when unknown. */
+export function mimeFor(name: string): string {
+  return fileMime(name);
+}