akanjs 3.0.0-beta.9 → 3.0.0

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,14 @@ 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 { type RouteLayer, RouteLayering } from "./RouteLayering";
+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,14 +158,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 { toPathSegments } from "./toPathSegments";
+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/common/markdownBlocks.ts

@@ -0,0 +1,134 @@
+import { MarkdownTable, type TableBlock } from "./markdownTable";
+
+export interface MarkdownItem {
+  depth: number;
+  ordered: boolean;
+  num: number;
+  text: string;
+}
+
+export type MarkdownBlock =
+  | { kind: "code"; lang?: string; text: string }
+  | { kind: "heading"; level: number; text: string }
+  | { kind: "list"; items: MarkdownItem[] }
+  | { kind: "quote"; text: string }
+  | { kind: "rule" }
+  | { kind: "para"; text: string }
+  | TableBlock;
+
+const fence = /^ {0,3}(```|~~~)(.*)$/;
+const heading = /^ {0,3}(#{1,6})\s+(.*)$/;
+const rule = /^ {0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/;
+const quote = /^ {0,3}> ?(.*)$/;
+const bullet = /^(\s*)[-*+]\s+(.*)$/;
+const ordered = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+const lazyLine = /^\s+\S/;
+
+export class MarkdownBlocks {
+  static of(source: string): MarkdownBlock[] {
+    return new MarkdownBlocks(source).#run();
+  }
+
+  readonly #lines: string[];
+  readonly #blocks: MarkdownBlock[] = [];
+  #at = 0;
+
+  constructor(source: string) {
+    this.#lines = source.replace(/\r\n?/g, "\n").split("\n");
+  }
+
+  #run() {
+    while (this.#at < this.#lines.length) {
+      const line = this.#lines[this.#at];
+      const head = heading.exec(line);
+      const fenced = fence.exec(line);
+      const table = MarkdownTable.at(this.#lines, this.#at);
+      if (!line.trim()) this.#at += 1;
+      else if (fenced) this.#code(fenced[1], fenced[2]);
+      else if (rule.test(line)) this.#take({ kind: "rule" });
+      else if (head) this.#take({ kind: "heading", level: head[1].length, text: head[2] });
+      else if (quote.test(line)) this.#quote();
+      else if (ordered.test(line)) this.#list(true);
+      else if (bullet.test(line)) this.#list(false);
+      else if (table) {
+        this.#blocks.push(table.block);
+        this.#at = table.next;
+      } else this.#para();
+    }
+    return this.#blocks;
+  }
+
+  #take(block: MarkdownBlock) {
+    this.#blocks.push(block);
+    this.#at += 1;
+  }
+
+  #code(marker: string, info: string) {
+    
+    const lang = info.trim().split(/\s+/)[0];
+    this.#at += 1;
+    const body: string[] = [];
+    while (this.#at < this.#lines.length) {
+      const line = this.#lines[this.#at];
+      this.#at += 1;
+      if (line.trimStart().startsWith(marker)) break;
+      body.push(line);
+    }
+    this.#blocks.push({ kind: "code", ...(lang ? { lang } : {}), text: body.join("\n") });
+  }
+
+  #quote() {
+    const lines: string[] = [];
+    while (this.#at < this.#lines.length) {
+      const match = quote.exec(this.#lines[this.#at]);
+      if (!match) break;
+      lines.push(match[1]);
+      this.#at += 1;
+    }
+    this.#blocks.push({ kind: "quote", text: lines.join(" ").trim() });
+  }
+
+  #list(isOrdered: boolean) {
+    const items: MarkdownItem[] = [];
+    while (this.#at < this.#lines.length) {
+      const line = this.#lines[this.#at];
+      const item = MarkdownBlocks.#item(line, isOrdered);
+      const open = items.at(-1);
+      if (item) items.push(item);
+      else if (open && lazyLine.test(line)) open.text += ` ${line.trim()}`;
+      else break;
+      this.#at += 1;
+    }
+    this.#blocks.push({ kind: "list", items });
+  }
+
+  static #item(line: string, isOrdered: boolean): MarkdownItem | null {
+    const numbered = ordered.exec(line);
+    const bulleted = bullet.exec(line);
+    const other = isOrdered ? bulleted : numbered;
+    const match = (isOrdered ? numbered : bulleted) ?? (other?.[1].length ? other : null);
+    if (!match) return null;
+    const carriesNum = match === numbered;
+    return {
+      depth: Math.floor(match[1].length / 2),
+      ordered: carriesNum,
+      num: carriesNum ? Number(match[2]) : 0,
+      text: carriesNum ? match[3] : match[2],
+    };
+  }
+
+  #para() {
+    const lines: string[] = [];
+    while (this.#at < this.#lines.length) {
+      const line = this.#lines[this.#at];
+      if (!line.trim() || this.#opensBlock(line) || MarkdownTable.at(this.#lines, this.#at)) break;
+      lines.push(line.trim());
+      this.#at += 1;
+    }
+    this.#blocks.push({ kind: "para", text: lines.join(" ") });
+  }
+
+  #opensBlock(line: string) {
+    return [fence, heading, rule, quote, bullet, ordered].some((pattern) => pattern.test(line));
+  }
+}

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/common/markdownTable.ts

@@ -0,0 +1,50 @@
+export type Align = "left" | "center" | "right";
+
+export interface TableBlock {
+  kind: "table";
+  aligns: (Align | null)[];
+  head: string[];
+  rows: string[][];
+}
+
+const cellSplit = /(?<!\\)\|/;
+const delimiter = /^:?-+:?$/;
+
+export class MarkdownTable {
+  static at(lines: string[], at: number): { block: TableBlock; next: number } | null {
+    const header = lines[at];
+    const aligns = MarkdownTable.#aligns(lines[at + 1]);
+    if (!header?.includes("|") || !aligns) return null;
+    const head = MarkdownTable.#cells(header);
+    const rows: string[][] = [];
+    let next = at + 2;
+    for (; next < lines.length; next += 1) {
+      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 };
+  }
+
+  static #cells(line: string): string[] {
+    return line
+      .trim()
+      .replace(/^\|/, "")
+      .replace(/(?<!\\)\|$/, "")
+      .split(cellSplit)
+      .map((cell) => cell.trim().replace(/\\\|/g, "|"));
+  }
+
+  static #aligns(line: string | undefined): (Align | null)[] | null {
+    if (!line?.includes("|")) return null;
+    const cells = MarkdownTable.#cells(line);
+    if (!cells.every((cell) => delimiter.test(cell))) return null;
+    return cells.map((cell) => {
+      const closed = cell.endsWith(":");
+      if (cell.startsWith(":")) return closed ? "center" : "left";
+      return closed ? "right" : null;
+    });
+  }
+}

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;
+  }
+};