akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/common/index.ts

@@ -1,4 +1,4 @@
-export { applyMixins } from "./applyMixins";
+export { applyMixins, getAllPropertyDescriptors } from "./applyMixins";
 export {
   authTokenKey,
   cookieHeaderHasAuthToken,
@@ -7,7 +7,9 @@ export {
   legacyAuthTokenKey,
   readAuthToken,
 } from "./authToken";
-export { capitalize } from "./capitalize";
+export { CodeAgentClient, type CodeAgentTransport } from "./CodeAgentClient";
+export { CodeTranscript, type CodeTranscriptPart } from "./CodeTranscript";
+export { capitalize, lowerlize } from "./capitalize";
 export { clamp } from "./clamp";
 export {
   clientAddressFromHeaders,
@@ -15,22 +17,70 @@ export {
   forwardedHeaders,
   normalizeIpAddress,
 } from "./clientAddress";
-export { deepObjectify } from "./deepObjectify";
-export type { DynamicRecord } from "./dynamicRecord";
+export {
+  type CodeAgentApprovalPolicy,
+  type CodeAgentBuiltinTool,
+  type CodeAgentInteractionMode,
+  type CodeAgentMcpAuthState,
+  type CodeAgentMcpServerRef,
+  type CodeAgentMcpStatus,
+  type CodeAgentModelInfo,
+  type CodeAgentPresetName,
+  type CodeAgentProfile,
+  type CodeAgentProviderInfo,
+  type CodeAgentSubagentBudget,
+  codeAgentDeniedPaths,
+  codeAgentPresets,
+  codeAgentReadOnlyBuiltins,
+  isCodeAgentPresetName,
+} from "./codeAgentProfile";
+export {
+  type CodeAgentAnswer,
+  type CodeAgentApprovalRequest,
+  type CodeAgentCommand,
+  type CodeAgentCommandType,
+  type CodeAgentEffort,
+  type CodeAgentEvent,
+  type CodeAgentEventBody,
+  type CodeAgentEventType,
+  type CodeAgentFrame,
+  type CodeAgentImage,
+  type CodeAgentQuestion,
+  type CodeAgentQuestionOption,
+  type CodeAgentReply,
+  type CodeAgentRequest,
+  type CodeAgentSessionInfo,
+  type CodeAgentStartOptions,
+  type CodeAgentState,
+  type CodeAgentStopReason,
+  type CodeAgentSubagent,
+  type CodeAgentToolOp,
+  type CodeAgentToolOutcome,
+  type CodeAgentToolSummary,
+  codeAgentClip,
+  codeAgentEventLabel,
+  codeAgentEventPersistence,
+  codeAgentLabelChars,
+  codeAgentOutputChars,
+  codeAgentRenderAnswer,
+  codeAgentSessionName,
+  codeAgentShouldPersist,
+  codeAgentWireVersion,
+  isCodeAgentReply,
+} from "./codeAgentWire";
+export { EventStream, type EventStreamOptions } from "./eventStream";
 export {
   type FileUploadCapability,
   fileUploadContract,
   resolveFileUploadCapability,
 } from "./fileUpload";
 export { formatNumber } from "./formatNumber";
-export { formatPhone } from "./formatPhone";
-export { getAllPropertyDescriptors } from "./getAllPropertyDescriptors";
 export { type AkanHmrPhase, getAkanHmrPhase, isAkanHmrApplying } from "./hmrPhase";
 export { interpolateTranslation } from "./interpolateTranslation";
 export { isDayjs } from "./isDayjs";
 export { isEmail } from "./isEmail";
-export { isPhoneNumber } from "./isPhoneNumber";
 export { isQueryEqual } from "./isQueryEqual";
+export { isRecord } from "./isRecord";
 export { isThenable } from "./isThenable";
 export { isValidDate } from "./isValidDate";
 export { decodeJwtPayload } from "./jwtDecode";
@@ -64,7 +114,9 @@ export {
   readLogContext,
   registerLogContextReader,
 } from "./logContext";
-export { lowerlize } from "./lowerlize";
+export { type MarkdownBlock, MarkdownBlocks, type MarkdownItem } from "./markdownBlocks";
+export { type MarkdownSpan, MarkdownSpans } from "./markdownSpans";
+export { type Align, MarkdownTable, type TableBlock } from "./markdownTable";
 export {
   isMcpDescribableArg,
   type McpExposureEndpoint,
@@ -73,16 +125,13 @@ export {
   mcpHintsOf,
   mcpRefusalOf,
 } from "./mcpExposure";
-export { mergeVersion } from "./mergeVersion";
-export { objectify } from "./objectify";
-export { pathGet } from "./pathGet";
-export { pathGetLoose } from "./pathGetLoose";
-export { pathSet } from "./pathSet";
-export { plainFieldsOf } from "./plainFieldsOf";
-export { randomPick } from "./randomPick";
-export { randomPicks } from "./randomPicks";
+export { deepObjectify, objectify, plainFieldsOf } from "./objectify";
+export { pathGet, pathGetLoose, pathSet, toPathSegments } from "./objectPath";
+export { formatPhone, isPhoneNumber } from "./phone";
+export { randomPick, randomPicks } from "./randomPick";
 export { hostFromRequest, isJsonContentType, originFromRequest } from "./requestOrigin";
 export { RestClient, type RestClientOptions, type RestRequestOptions } from "./restClient";
+export { round } from "./round";
 export {
   assertUniqueRoutePatterns,
   compareRouteSpecificity,
@@ -108,13 +157,49 @@ export {
   validateSubRoutePageKey,
 } from "./routeConvention";
 export { sleep } from "./sleep";
-export { splitVersion } from "./splitVersion";
 export { getBasePathFromPathname, parseBasePaths, parseSubRouteHosts, resolveSubRouteHosts } from "./subRoute";
 export { TrustedProxy } from "./TrustedProxy";
+export { toError } from "./toError";
+export {
+  type TunnelAgentIdentity,
+  type TunnelAttachedFrame,
+  type TunnelAttachFrame,
+  type TunnelByeFrame,
+  type TunnelCloseCode,
+  type TunnelControlFromAgent,
+  type TunnelControlFromGateway,
+  type TunnelDataFromAgent,
+  type TunnelDataFromGateway,
+  type TunnelDemandFrame,
+  type TunnelEndFrame,
+  type TunnelFrame,
+  type TunnelHeaderList,
+  type TunnelHeadFrame,
+  type TunnelHelloFrame,
+  type TunnelOpenFrame,
+  type TunnelPingFrame,
+  type TunnelPongFrame,
+  type TunnelReadyFrame,
+  type TunnelReleaseFrame,
+  type TunnelResetCode,
+  type TunnelResetFrame,
+  type TunnelStreamKind,
+  type TunnelWsPayloadKind,
+  tunnelCloseCode,
+  tunnelForwardedHeaders,
+  tunnelHopByHopHeaders,
+  tunnelWireContract,
+  tunnelWsPayload,
+} from "./tunnelWire";
 export type * from "./types";
+export { mergeVersion, splitVersion } from "./version";
 export {
   type WebsocketAuthAckData,
   type WebsocketAuthRequest,
+  type WebsocketBinaryFrame,
+  type WebsocketHeartbeatAckData,
+  type WebsocketHeartbeatRequest,
   websocketAuthContract,
-} from "./websocketAuth";
-export { type WebsocketBinaryFrame, websocketBinaryFrameContract } from "./websocketBinaryFrame";
+  websocketBinaryFrameContract,
+  websocketHeartbeatContract,
+} from "./websocketContract";

package/common/interpolateTranslation.ts

@@ -1,9 +1,4 @@
-/**
- * Fills `{name}` placeholders in a translated string.
- *
- * A placeholder whose value is absent is left as written: the author's `{name}` reads as a bug in the UI, while
- * the string "undefined" reads as content, and a partially supplied `data` must not corrupt the rest of the line.
- */
+/** A `{name}` placeholder whose value is absent is left as written, never replaced by "undefined". */
 export const interpolateTranslation = (message: string, data: Record<string, unknown> | undefined) => {
   if (!data) return message;
   return message.replace(/{([^}]+)}/g, (placeholder, name: string) =>

package/common/isEmail.ts

@@ -1,2 +1 @@
-/** Returns true when the value matches the email format accepted by Akan forms. */
 export const isEmail = (email?: string | null) => !!email && /^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,8})+$/.test(email);

package/common/isRecord.ts

@@ -0,0 +1,2 @@
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);

package/common/isThenable.ts

@@ -1,11 +1,4 @@
-/**
- * Whether a value is awaitable. Duck-typed rather than `instanceof Promise` so a thenable produced by a
- * different realm or promise implementation still counts — a same-realm check silently misses those.
- *
- * `<Button>` uses this to decide whether a click handler is asynchronous: a handler that returns a
- * thenable gets the pending/success states, a plain one renders as an ordinary button. That makes the
- * distinction impossible to forget, unlike an explicit flag.
- */
+
 export const isThenable = (value: unknown): value is PromiseLike<unknown> =>
   !!value &&
   (typeof value === "object" || typeof value === "function") &&

package/common/isValidDate.ts

@@ -6,9 +6,7 @@ import { isDayjs } from "./isDayjs";
 dayjs.extend(customParseFormat);
 
 export const isValidDate = (d: string | Date | Dayjs) => {
-  const format = "YYYY-MM-DD";
-  if (typeof d === "string") {
-    return dayjs(d, format).isValid();
-  } else if (isDayjs(d)) return d.isValid();
-  else return d instanceof Date && !Number.isNaN(d.getTime());
+  if (typeof d === "string") return dayjs(d, "YYYY-MM-DD").isValid();
+  if (isDayjs(d)) return d.isValid();
+  return d instanceof Date && !Number.isNaN(d.getTime());
 };

package/common/logContext.ts

@@ -1,6 +1,6 @@
 import type { LogRecord } from "./Logger";
 
-/** A per-request ring the Logger hands every record to; the trace decides at its end whether any of it is shown. */
+/** A per-request ring of every record; the trace decides at its end whether any of it is shown. */
 export interface LogFlightRecorder {
   minSev: number;
   capture(record: LogRecord, written: boolean): void;

package/{ui/Agent → common}/markdownBlocks.ts

@@ -24,9 +24,6 @@ const bullet = /^(\s*)[-*+]\s+(.*)$/;
 const ordered = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
 const lazyLine = /^\s+\S/;
 
-/**
- * Block scanner for assistant chat text — the CommonMark subset a model actually emits over this wire.
- */
 export class MarkdownBlocks {
   static of(source: string): MarkdownBlock[] {
     return new MarkdownBlocks(source).#run();

package/common/markdownSpans.ts

@@ -0,0 +1,47 @@
+export type MarkdownSpan =
+  | { kind: "text"; text: string }
+  | { kind: "code"; text: string }
+  | { kind: "strong"; text: string }
+  | { kind: "em"; text: string }
+  | { kind: "del"; text: string }
+  | { kind: "link"; text: string; href: string }
+  /** A link whose href was refused, or an image: rendered as its label, by every host. */
+  | { kind: "plain"; text: string };
+
+const inline =
+  /(!?)\[([^\]]*)\]\(((?:[^\s()]|\([^\s()]*\))+)\)|`([^`]+)`|\*\*([\s\S]+?)\*\*|\*([^*\n]+?)\*|~~([\s\S]+?)~~/g;
+
+export class MarkdownSpans {
+  static of(text: string): MarkdownSpan[] {
+    const spans: MarkdownSpan[] = [];
+    let cut = 0;
+    for (const match of text.matchAll(inline)) {
+      const at = match.index;
+      const [, image, label, href, code, strong, em, del] = match;
+      if (at > cut) spans.push({ kind: "text", text: text.slice(cut, at) });
+      cut = at + match[0].length;
+      if (href !== undefined)
+        spans.push(
+          image || !MarkdownSpans.isSafeHref(href)
+            ? { kind: "plain", text: label ?? "" }
+            : { kind: "link", text: label ?? "", href },
+        );
+      else if (code !== undefined) spans.push({ kind: "code", text: code });
+      else if (strong !== undefined) spans.push({ kind: "strong", text: strong });
+      else if (em !== undefined) spans.push({ kind: "em", text: em });
+      else if (del !== undefined) spans.push({ kind: "del", text: del });
+    }
+    if (cut < text.length) spans.push({ kind: "text", text: text.slice(cut) });
+    return spans;
+  }
+
+  static isSafeHref(href: string) {
+    return !/^[a-z][a-z0-9+.-]*:/i.test(href) || /^(?:https?|mailto|tel):/i.test(href);
+  }
+
+  static plain(text: string): string {
+    return MarkdownSpans.of(text)
+      .map((span) => span.text)
+      .join("");
+  }
+}

package/{ui/Agent → common}/markdownTable.ts

@@ -10,8 +10,6 @@ export interface TableBlock {
 const cellSplit = /(?<!\\)\|/;
 const delimiter = /^:?-+:?$/;
 
-/** GFM table scan, kept out of the block scanner because the delimiter row makes it the one shape that has to
- *  read the line after the one it starts on. */
 export class MarkdownTable {
   static at(lines: string[], at: number): { block: TableBlock; next: number } | null {
     const header = lines[at];
@@ -24,7 +22,7 @@ export class MarkdownTable {
       const line = lines[next];
       if (!line.trim() || !line.includes("|")) break;
       const cells = MarkdownTable.#cells(line);
-
+      
       rows.push(head.map((_, idx) => cells[idx] ?? ""));
     }
     return { block: { kind: "table", aligns, head, rows }, next };
@@ -39,8 +37,6 @@ export class MarkdownTable {
       .map((cell) => cell.trim().replace(/\\\|/g, "|"));
   }
 
-  /** The delimiter row is what separates a table from a paragraph that merely contains a pipe, and from the
-   *  `---` of a rule — which is why the pipe is required of it rather than of the header. */
   static #aligns(line: string | undefined): (Align | null)[] | null {
     if (!line?.includes("|")) return null;
     const cells = MarkdownTable.#cells(line);

package/common/mcpExposure.ts

@@ -1,15 +1,5 @@
 import { capitalize } from "./capitalize";
 
-/**
- * What MCP says about one endpoint: whether it is published, why it is not, and the hints it carries.
- *
- * Structurally typed like the rest of `common/` so the same rules answer on both sides — the server builds its
- * catalogue from them and the browser API explorer badges an endpoint from them. A second implementation would
- * eventually disagree, and an audit surface that disagrees with the catalogue is worse than none.
- *
- * Every rejection returns the sentence an author reads, at boot in the server log and in the explorer. Fail-closed
- * with no reason leaves an author whose endpoint is missing from the catalogue nowhere to look but the source.
- */
 export interface McpExposureEndpoint {
   type: string;
   returns: { refName: string };
@@ -22,20 +12,15 @@ export interface McpExposureEndpoint {
 }
 
 export interface McpExposureOption {
-  /** The model the endpoint belongs to and the name it is published under: one rule reads the key, not the shape. */
   refName: string;
   key: string;
-  /**
-   * The read-only deployment valve, which is server configuration. The browser explorer cannot know it and so
-   * badges what the code decided; the boot log is where a read-only deployment says what it dropped.
-   */
+  /** The read-only deployment valve: server configuration the browser explorer cannot know. */
   readOnly?: boolean;
 }
 
-/** `Any` publishes as the empty schema, which tells a model nothing — so it is left out rather than described. */
+/** `Any` publishes as the empty schema, which tells a model nothing, so it is left out. */
 export const isMcpDescribableArg = (arg: { refName: string }) => arg.refName !== "Any";
 
-/** Which CRUD verb a generated endpoint key is, or `null` when the key is not one of the five. */
 export const mcpBaseVerbOf = (refName: string, key: string) => {
   const cap = capitalize(refName);
   if (key === refName || key === `light${cap}`) return "get" as const;
@@ -45,11 +30,7 @@ export const mcpBaseVerbOf = (refName: string, key: string) => {
   return null;
 };
 
-/**
- * The hints a client renders beside a tool. Hints only — clients are told to distrust them, so they inform a UI
- * and never stand in for a guard. `openWorldHint` is always false: every endpoint reaches this app's own
- * database, not the wider internet.
- */
+/** Hints never stand in for a guard; `openWorldHint` is false: every endpoint reaches this app's own database. */
 export const mcpHintsOf = (key: string, endpoint: { type: string }) => {
   const readOnly = endpoint.type === "query";
   const destructive = !readOnly && /^(remove|delete)/.test(key);
@@ -61,21 +42,17 @@ export const mcpHintsOf = (key: string, endpoint: { type: string }) => {
   };
 };
 
-/** The sentence explaining why this endpoint is not in the catalogue, or `null` when it is. */
 export const mcpRefusalOf = (
   endpoint: McpExposureEndpoint,
   { refName, key, readOnly }: McpExposureOption,
 ): string | null => {
-
   if (endpoint.mcp === false)
     return "it declares `mcp: false`, so it is deliberately off the agent shelf. HTTP still serves it.";
-
+  
   if (endpoint.agents === false)
     return `its guards (${(endpoint.guards ?? []).join(", ")}) admit no agent — an act reserved for a person, so it is off the agent shelf. HTTP still serves it.`;
-
   if (!endpoint.guards?.length)
     return "it declares no guards, and exposure follows them — write `guards: [Public]` if anonymous access is the intent.";
-
   if (key === `light${capitalize(refName)}`)
     return `it reads the same document as \`${refName}\` in a smaller shape — call \`${refName}\` instead.`;
   if (endpoint.type === "pubsub" || endpoint.type === "message")

package/common/objectPath.ts

@@ -0,0 +1,67 @@
+type PathSegment = string | number;
+type Indexable = Record<PathSegment, unknown>;
+type Container = Indexable | Map<PathSegment, unknown>;
+
+export const isIndexable = (value: unknown): value is Indexable => Object(value) === value;
+
+const readChild = (container: Container, key: PathSegment) =>
+  container instanceof Map ? container.get(key) : container[key];
+
+const writeChild = (container: Container, key: PathSegment, value: unknown) => {
+  if (container instanceof Map) container.set(key, value);
+  else container[key] = value;
+};
+
+/** `a.0.b` and `a[0].b` are the same segments, for writes and reads alike. */
+export const toPathSegments = (path: string | readonly PathSegment[]) =>
+  Array.isArray(path) ? [...path] : path.toString().match(/[^.[\]]+/g) || [];
+
+export const pathGet = (
+  path: string | (string | number)[],
+  obj: unknown,
+  separator = ".",
+  fallback: unknown = null,
+): unknown => {
+  
+  const properties = separator === "." ? toPathSegments(path) : Array.isArray(path) ? [...path] : path.split(separator);
+  return properties.reduce<unknown>(
+    (prev, curr) => (isIndexable(prev) ? (readChild(prev, curr) ?? fallback) : fallback),
+    obj,
+  );
+};
+
+export const pathSet = <T>(obj: T, path: string | readonly PathSegment[], value: unknown): T => {
+  if (Object(obj) !== obj) return obj;
+  const pathSegments = toPathSegments(path);
+  const parent = pathSegments.slice(0, -1).reduce<Container>((a, c, i) => {
+    const child = readChild(a, c);
+    if (Object(child) === child) return child as Container;
+    const created = Math.abs(Number(pathSegments[i + 1])) >> 0 === +pathSegments[i + 1] ? [] : {};
+    writeChild(a, c, created);
+    return created as unknown as Container;
+  }, obj as Container);
+  writeChild(parent, pathSegments[pathSegments.length - 1], value);
+  return obj;
+};
+
+/** Also tries joined prefixes, for keys whose segments contain the separator (an enum value like `gpt-5.6-terra`). */
+export const pathGetLoose = (
+  path: string | readonly string[],
+  obj: unknown,
+  separator = ".",
+  fallback: unknown = null,
+): unknown => {
+  const walk = (node: unknown, rest: readonly string[]): unknown => {
+    if (!rest.length) return node;
+    if (!isIndexable(node)) return undefined;
+    
+    for (let take = 1; take <= rest.length; take += 1) {
+      const child = node[rest.slice(0, take).join(separator)];
+      if (child === undefined) continue;
+      const found = walk(child, rest.slice(take));
+      if (found !== undefined) return found;
+    }
+    return undefined;
+  };
+  return walk(obj, Array.isArray(path) ? [...path] : (path as string).split(separator)) ?? fallback;
+};

package/common/objectify.ts

@@ -1,3 +1,5 @@
+import { isDayjs } from "./isDayjs";
+
 export const objectify = <T extends object>(obj: T, keys = Object.keys(obj) as (keyof T)[]): Partial<T> => {
   const val: Partial<T> = {};
   keys.forEach((key) => {
@@ -5,3 +7,53 @@ export const objectify = <T extends object>(obj: T, keys = Object.keys(obj) as (
   });
   return val;
 };
+
+export const plainFieldsOf = (source: object): Record<string, unknown> => {
+  const out: Record<string, unknown> = {};
+  for (const key in source) {
+    const value = (source as Record<string, unknown>)[key];
+    if (typeof value !== "function") out[key] = value;
+  }
+  return out;
+};
+
+interface DeepObjectifyOption {
+  serializable?: boolean;
+  convertDate?: "string" | "number";
+}
+
+const objectifyChild = (value: unknown, option: DeepObjectifyOption): unknown => {
+  const modelValue = value as { __ModelType__?: string } | null | undefined;
+  return modelValue?.__ModelType__ && !option.serializable ? value : deepObjectify(value, option);
+};
+
+export const deepObjectify = <T = unknown>(obj: T | null | undefined, option: DeepObjectifyOption = {}): T => {
+  if (isDayjs(obj) || obj?.constructor === Date) {
+    if (!option.serializable && !option.convertDate) return obj as T;
+    if (option.convertDate === "string") return obj.toISOString() as T;
+    else if (option.convertDate === "number")
+      return (isDayjs(obj) ? obj.toDate().getTime() : (obj as Date).getTime()) as T;
+    else return (isDayjs(obj) ? obj.toDate() : obj) as T;
+  } else if (Array.isArray(obj)) {
+    return obj.map((o: unknown) => deepObjectify(o, option)) as T;
+  } else if (obj instanceof Map) {
+    
+    const entries = [...obj.entries()].map(
+      ([key, value]: [string, unknown]) => [key, objectifyChild(value, option)] as const,
+    );
+    return (option.serializable ? Object.fromEntries(entries) : new Map(entries)) as T;
+  } else if (obj instanceof Set) {
+    const values = [...obj.values()].map((value: unknown) => objectifyChild(value, option));
+    return (option.serializable ? values : new Set(values)) as T;
+  } else if (obj && typeof obj === "object") {
+    const val: Record<string, unknown> = {};
+    const objRecord = obj as Record<string, unknown>;
+    
+    for (const key in objRecord) {
+      if (typeof objRecord[key] !== "function") val[key] = objectifyChild(objRecord[key], option);
+    }
+    return val as T;
+  } else {
+    return obj as unknown as T;
+  }
+};

package/common/{isPhoneNumber.ts → phone.ts}

@@ -1,4 +1,3 @@
-/** Returns true when the value matches Akan's supported dashed phone-number format. */
 export const isPhoneNumber = (phone?: string | null) => {
   if (!phone) return false;
   const comp = phone.startsWith("0") ? phone.slice(1) : phone;
@@ -6,3 +5,10 @@ export const isPhoneNumber = (phone?: string | null) => {
   const regExp2 = /^\(?([0-9]{2})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/;
   return (regExp1.test(comp) || regExp2.test(comp)) && phone.split("-").length === 3;
 };
+
+export const formatPhone = (value: string) => {
+  if (!value) return "";
+  if (value.length === 10) return value.replace(/(\d{3})(\d{3})(\d{4})/, "$1-$2-$3");
+  else if (value.length === 13) return value.replace(/-/g, "").replace(/(\d{3})(\d{4})(\d{4})/, "$1-$2-$3");
+  else return value;
+};

package/common/randomPick.ts

@@ -1 +1,14 @@
 export const randomPick = <T = unknown>(arr: T[] | readonly T[]): T => arr[Math.floor(Math.random() * arr.length)];
+
+export const randomPicks = <T>(arr: T[] | readonly T[], count = 1, allowDuplicate = false): T[] => {
+  if (!allowDuplicate && arr.length <= count) return arr as T[];
+  const idxs: number[] = [];
+  let pickIdx: number;
+  for (let i = 0; i < count; i++) {
+    do {
+      pickIdx = Math.floor(Math.random() * arr.length);
+    } while (!allowDuplicate && idxs.includes(pickIdx));
+    idxs.push(pickIdx);
+  }
+  return idxs.map((idx) => arr[idx]);
+};

package/common/requestOrigin.ts

@@ -1,7 +1,3 @@
-/**
- * The origin a caller actually saw, and whether a body claims to be JSON. Both read only headers and a URL, so
- * they answer the same way for the cache layer, the CSRF gate, and anything else that has to compare origins.
- */
 export const originFromRequest = (headers: Headers, url: URL): string => {
   
   const forwardedProto = headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
@@ -16,22 +12,9 @@ export const originFromRequest = (headers: Headers, url: URL): string => {
   return url.origin;
 };
 
-/**
- * The host a caller addressed, which — unlike the scheme — every proxy that rewrites the request still reports.
- * `Host` is set by the browser from the URL it was told to open, so it names *this* deployment even for a
- * request some other page initiated.
- */
 export const hostFromRequest = (headers: Headers, url: URL): string =>
   headers.get("x-forwarded-host")?.split(",")[0]?.trim() ?? headers.get("host")?.split(",")[0]?.trim() ?? url.host;
 
-/**
- * Whether a request body may be read as JSON.
- *
- * `Request.json()` parses whatever bytes it holds regardless of this header, and the three content types a
- * cross-site form can send — `text/plain`, `application/x-www-form-urlencoded`, `multipart/form-data` — are
- * exactly the ones a browser sends with **no preflight**. Requiring the JSON type is therefore what puts a
- * preflight in front of every mutation that carries a body.
- */
 export const isJsonContentType = (contentType: string | null): boolean => {
   if (!contentType) return false;
   const essence = contentType.split(";")[0]?.trim().toLowerCase() ?? "";

package/common/restClient.ts

@@ -1,10 +1,3 @@
-/**
- * A plain REST client for a service that is not an Akan API: base url, headers, timeout, JSON in and out.
- *
- * Not `akanjs/fetch`'s `HttpClient`, which builds an Akan endpoint's path from its serialized args and restores
- * an `Err` from the response. Two classes of the same name in one package meant an app importing both barrels
- * got a collision, so this one is named for what it is.
- */
 export interface RestClientOptions {
   baseUrl?: string;
   headers?: HeadersInit;
@@ -94,12 +87,14 @@ export class RestClient {
 
   #makeBody(data: unknown): { body?: BodyInit; headers?: HeadersInit } {
     if (data === undefined) return {};
-    if (data instanceof FormData) return { body: data };
-    if (typeof data === "string") return { body: data };
-    if (data instanceof URLSearchParams) return { body: data };
-    if (data instanceof Blob) return { body: data };
-    if (data instanceof ArrayBuffer) return { body: data };
-
+    if (
+      typeof data === "string" ||
+      data instanceof FormData ||
+      data instanceof URLSearchParams ||
+      data instanceof Blob ||
+      data instanceof ArrayBuffer
+    )
+      return { body: data };
     return {
       body: JSON.stringify(data),
       headers: { "Content-Type": "application/json" },

package/common/round.ts

@@ -0,0 +1,4 @@
+export const round = (value: number, digits = 3): number => {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};