akanjs 2.0.5 → 2.0.6

package/server/akanApp.ts

@@ -17,6 +17,13 @@ interface ChildState {
   healthPath?: string;
   metrics: AkanMetricsReport;
   lastPongAt?: number;
+  restartAttempts: number;
+  restartCount: number;
+  restartTimer: Timer | null;
+  restartPending: boolean;
+  lastExitCode?: number | null;
+  lastRestartAt?: number;
+  lastRestartReason?: string;
 }
 
 interface GatewayWsData {
@@ -49,6 +56,9 @@ interface AkanReplicaConfig {
 
 /** Gateway/orchestrator that starts Akan child servers and proxies HTTP/WebSocket traffic. */
 export class AkanApp {
+  static readonly #childRestartBaseDelayMs = 1_000;
+  static readonly #childRestartMaxDelayMs = 30_000;
+  static readonly #childRestartGraceMs = 5_000;
   static readonly #hopByHopHeaders = new Set([
     "connection",
     "keep-alive",
@@ -171,7 +181,11 @@ export class AkanApp {
     this.#server?.stop(true);
     this.#server = null;
     for (const child of this.#children.values()) {
-      if (!child.proc.killed) child.proc.send({ type: "shutdown", signal } satisfies AkanIpcMessage);
+      if (child.restartTimer) {
+        clearTimeout(child.restartTimer);
+        child.restartTimer = null;
+      }
+      this.#sendToChild(child, { type: "shutdown", signal } satisfies AkanIpcMessage);
     }
     await Promise.race([
       Promise.all([...this.#children.values()].map((child) => child.proc.exited.catch(() => undefined))),
@@ -200,7 +214,8 @@ export class AkanApp {
     const role = this.#getRole(idx);
     const upstream = this.#getChildUpstream(idx, role);
     const childCode = `import(${JSON.stringify(path.resolve(this.#serverPath))}).then((mod)=>{ const server = mod.server ?? mod.app; if (!server?.start) throw new Error("server.ts must export server or app with start()"); return server.start({ listen: process.env.SERVER_MODE !== "batch" }); }).catch((error)=>{ process.send?.({ type: "error", message: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : undefined, pid: process.pid }); process.exit(1); });`;
-    const proc = Bun.spawn(["bun", "-e", childCode], {
+    let proc!: Bun.Subprocess<"ignore", "pipe", "pipe">;
+    proc = Bun.spawn(["bun", "-e", childCode], {
       cwd: process.cwd(),
       env: {
         ...process.env,
@@ -212,32 +227,140 @@ export class AkanApp {
         AKAN_CHILD_SOCKET: upstream.http.socketPath,
         AKAN_CHILD_WS_PORT: upstream.ws ? String(upstream.ws.port) : "",
       },
-      ipc: (message) => this.#handleMessage(idx, message as AkanIpcMessage),
+      ipc: (message) => this.#handleMessage(idx, message as AkanIpcMessage, proc),
       stdout: "pipe",
       stderr: "pipe",
       stdin: "ignore",
     });
-    this.#children.set(idx, { idx, role, proc, ready: false, status: "starting", metrics: {} });
+    const previous = this.#children.get(idx);
+    this.#children.set(idx, {
+      idx,
+      role,
+      proc,
+      ready: false,
+      status: "starting",
+      metrics: {},
+      restartAttempts: previous?.restartAttempts ?? 0,
+      restartCount: previous?.restartCount ?? 0,
+      restartTimer: null,
+      restartPending: false,
+      lastExitCode: previous?.lastExitCode,
+      lastRestartAt: previous?.lastRestartAt,
+      lastRestartReason: previous?.lastRestartReason,
+    });
     this.#pipeOutput(idx, role, proc.stdout, "stdout");
     this.#pipeOutput(idx, role, proc.stderr, "stderr");
-    proc.exited.then((code) => {
-      const child = this.#children.get(idx);
-      if (child) child.status = "exited";
-      this.#removeChildRooms(idx);
-      if (this.#stopping) return;
-      this.logger.error(`Child ${idx}/${role} exited with code ${code}; shutting down all children`);
-      void this.stop("child-exit");
+    proc.exited.then((code) => this.#handleChildExit(idx, proc, code));
+  }
+
+  #handleChildExit(idx: number, proc: Bun.Subprocess<"ignore", "pipe", "pipe">, code: number | null) {
+    const child = this.#children.get(idx);
+    if (!child || child.proc !== proc) return;
+    child.status = "exited";
+    child.lastExitCode = code;
+    this.#removeChildRooms(idx);
+    if (this.#stopping) return;
+    void this.#scheduleChildRestart(child, proc, `exit:${code ?? "unknown"}`);
+  }
+
+  #scheduleChildRestart(child: ChildState, proc: Bun.Subprocess<"ignore", "pipe", "pipe">, reason: string): void {
+    if (this.#stopping) return;
+    if (child.proc !== proc) return;
+    if (child.restartPending || child.restartTimer) {
+      child.lastRestartReason = reason;
+      return;
+    }
+
+    child.restartPending = true;
+    child.ready = false;
+    child.status = reason === "health-timeout" ? "unhealthy" : "exited";
+    child.upstream = undefined;
+    child.healthPath = undefined;
+    child.lastRestartReason = reason;
+    child.lastRestartAt = Date.now();
+    this.#removeChildRooms(child.idx);
+
+    const attempt = child.restartAttempts;
+    const delay = Math.min(AkanApp.#childRestartBaseDelayMs * 2 ** attempt, AkanApp.#childRestartMaxDelayMs);
+    child.restartAttempts = attempt + 1;
+    child.restartCount += 1;
+    this.logger.error(
+      `Child ${child.idx}/${child.role} failed (${reason}); restarting in ${delay}ms (attempt ${child.restartAttempts})`,
+    );
+
+    void this.#restartChildAfterDelay(child.idx, proc, reason, delay).catch((error) => {
+      const current = this.#children.get(child.idx);
+      if (!current || current.proc !== proc || this.#stopping) return;
+      current.restartPending = false;
+      this.logger.error(
+        `Failed to restart child ${child.idx}/${child.role}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      this.#scheduleChildRestart(current, proc, "restart-failed");
     });
   }
 
+  async #restartChildAfterDelay(
+    idx: number,
+    proc: Bun.Subprocess<"ignore", "pipe", "pipe">,
+    reason: string,
+    delay: number,
+  ) {
+    const child = this.#children.get(idx);
+    if (!child || child.proc !== proc || this.#stopping) return;
+    await this.#stopChildForRestart(child, proc, reason);
+    if (this.#stopping) return;
+    const current = this.#children.get(idx);
+    if (!current || current.proc !== proc) return;
+    current.restartTimer = setTimeout(() => {
+      current.restartTimer = null;
+      void this.#respawnChild(idx, proc).catch((error) => {
+        const latest = this.#children.get(idx);
+        if (!latest || latest.proc !== proc || this.#stopping) return;
+        latest.restartPending = false;
+        this.logger.error(
+          `Failed to respawn child ${idx}/${latest.role}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        this.#scheduleChildRestart(latest, proc, "respawn-failed");
+      });
+    }, delay);
+  }
+
+  async #respawnChild(idx: number, proc: Bun.Subprocess<"ignore", "pipe", "pipe">) {
+    if (this.#stopping) return;
+    const current = this.#children.get(idx);
+    if (!current || current.proc !== proc) return;
+    await this.#removeChildSocket(idx, current.role);
+    current.restartPending = false;
+    this.#spawn(idx);
+  }
+
+  async #stopChildForRestart(child: ChildState, proc: Bun.Subprocess<"ignore", "pipe", "pipe">, reason: string) {
+    if (!proc.killed) {
+      this.#sendToChild(child, { type: "shutdown", signal: reason } satisfies AkanIpcMessage);
+    }
+    const result = await Promise.race([
+      proc.exited.then(() => "exited" as const).catch(() => "exited" as const),
+      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), AkanApp.#childRestartGraceMs)),
+    ]);
+    if (result === "timeout" && !proc.killed) {
+      this.logger.warn(`Child ${child.idx}/${child.role} did not stop in ${AkanApp.#childRestartGraceMs}ms; killing`);
+      proc.kill();
+      await proc.exited.catch(() => undefined);
+    }
+  }
+
   async #prepareRuntimeDir() {
     await mkdir(this.#runtimeDir, { recursive: true });
     for (let idx = 0; idx < this.#replica.total; idx++) {
-      const socketPath = this.#getChildUpstream(idx, this.#getRole(idx)).http.socketPath;
-      try {
-        await rm(socketPath, { force: true });
-      } catch {
-      }
+      await this.#removeChildSocket(idx, this.#getRole(idx));
+    }
+  }
+
+  async #removeChildSocket(idx: number, role: AkanChildRole) {
+    const socketPath = this.#getChildUpstream(idx, role).http.socketPath;
+    try {
+      await rm(socketPath, { force: true });
+    } catch {
     }
   }
 
@@ -388,6 +511,12 @@ export class AkanApp {
         ready: child.ready,
         pid: child.pid,
         upstream: child.upstream,
+        restartAttempts: child.restartAttempts,
+        restartCount: child.restartCount,
+        restartPending: child.restartPending,
+        lastExitCode: child.lastExitCode,
+        lastRestartAt: child.lastRestartAt,
+        lastRestartReason: child.lastRestartReason,
       })),
     };
   }
@@ -402,6 +531,12 @@ export class AkanApp {
         role: child.role,
         metrics: child.metrics,
         rooms: this.#childRooms.get(child.idx)?.size ?? 0,
+        restartAttempts: child.restartAttempts,
+        restartCount: child.restartCount,
+        restartPending: child.restartPending,
+        lastExitCode: child.lastExitCode,
+        lastRestartAt: child.lastRestartAt,
+        lastRestartReason: child.lastRestartReason,
       })),
     };
   }
@@ -557,7 +692,13 @@ export class AkanApp {
     };
   }
 
-  #handleMessage(idx: number, message: AkanIpcMessage | BuilderMessage) {
+  #handleMessage(
+    idx: number,
+    message: AkanIpcMessage | BuilderMessage,
+    proc?: Bun.Subprocess<"ignore", "pipe", "pipe">,
+  ) {
+    const child = this.#children.get(idx);
+    if (proc && (!child || child.proc !== proc)) return;
     if (!message || typeof message !== "object") return;
     switch (message.type) {
       case "ready":
@@ -586,7 +727,7 @@ export class AkanApp {
         return;
       case "error":
         this.logger.error(message.message);
-        void this.stop("child-error");
+        if (child && proc) void this.#scheduleChildRestart(child, proc, "child-error");
         return;
       case "build-route":
         this.#forwardBuildRoute(idx, message);
@@ -618,6 +759,8 @@ export class AkanApp {
     child.upstream = message.upstream;
     child.healthPath = message.healthPath;
     child.lastPongAt = Date.now();
+    child.restartAttempts = 0;
+    child.restartPending = false;
     if ([...this.#children.values()].every((item) => item.ready)) {
       process.send?.({ type: "backend-ready", pid: process.pid } satisfies AkanIpcMessage);
       this.logger.verbose(`All ${this.#children.size} child process(es) are ready`);
@@ -643,12 +786,15 @@ export class AkanApp {
       if (childIdx === originIdx) continue;
       const child = this.#children.get(childIdx);
       if (!child || child.proc.killed || child.status === "exited") continue;
-      child.proc.send({
-        type: "pubsub.deliver",
-        roomId: message.roomId,
-        data: message.data,
-        origin: message.origin,
-      } satisfies AkanIpcMessage);
+      if (
+        !this.#sendToChild(child, {
+          type: "pubsub.deliver",
+          roomId: message.roomId,
+          data: message.data,
+          origin: message.origin,
+        } satisfies AkanIpcMessage)
+      )
+        continue;
       child.metrics.pubsubDeliverCount = (child.metrics.pubsubDeliverCount ?? 0) + 1;
     }
   }
@@ -747,7 +893,7 @@ export class AkanApp {
   #requestRoomSnapshots() {
     for (const child of this.#children.values()) {
       if (child.proc.killed || child.status === "exited") continue;
-      child.proc.send({ type: "pubsub.snapshot.request" } satisfies AkanIpcMessage);
+      this.#sendToChild(child, { type: "pubsub.snapshot.request" } satisfies AkanIpcMessage);
     }
   }
 
@@ -757,11 +903,14 @@ export class AkanApp {
       if (child.proc.killed || child.status === "exited") continue;
       if (child.lastPongAt && now - child.lastPongAt > 5_000) {
         child.status = "unhealthy";
-        this.logger.error(`Child ${child.idx}/${child.role} health check timed out; shutting down all children`);
-        void this.stop("health-timeout");
+        void this.#scheduleChildRestart(child, child.proc, "health-timeout");
         return;
       }
-      child.proc.send({ type: "health.ping", nonce: crypto.randomUUID(), sentAt: now } satisfies AkanIpcMessage);
+      this.#sendToChild(child, {
+        type: "health.ping",
+        nonce: crypto.randomUUID(),
+        sentAt: now,
+      } satisfies AkanIpcMessage);
     }
   }
 
@@ -780,25 +929,41 @@ export class AkanApp {
     this.#builderReqMap.delete(message.id);
     const child = this.#children.get(request.childIdx);
     if (!child || child.proc.killed) return;
-    child.proc.send({ ...message, id: request.childLocalId } satisfies BuilderRes);
+    this.#sendToChild(child, { ...message, id: request.childLocalId } satisfies BuilderRes);
   }
 
   #fanoutToFederation(message: AkanIpcMessage | BuilderMessage, exceptIdx?: number) {
     for (const child of this.#children.values()) {
       if (child.idx === exceptIdx) continue;
-      if (child.role === "federation" || child.role === "all") child.proc.send(message);
+      if (child.role === "federation" || child.role === "all") this.#sendToChild(child, message);
     }
   }
 
   #fanoutToBatch(message: AkanIpcMessage) {
     for (const child of this.#children.values()) {
       if (child.role === "batch" || child.role === "all") {
-        child.proc.send(message);
-        if (message.type === "queue.wake") child.metrics.queueWakeCount = (child.metrics.queueWakeCount ?? 0) + 1;
+        if (this.#sendToChild(child, message) && message.type === "queue.wake") {
+          child.metrics.queueWakeCount = (child.metrics.queueWakeCount ?? 0) + 1;
+        }
       }
     }
   }
 
+  #sendToChild(child: ChildState, message: AkanIpcMessage | BuilderMessage): boolean {
+    if (child.proc.killed || child.status === "exited") return false;
+    try {
+      child.proc.send(message);
+      return true;
+    } catch (error) {
+      this.logger.warn(
+        `Failed to send ${message.type} to child ${child.idx}/${child.role}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+      return false;
+    }
+  }
+
   async #pipeOutput(
     idx: number,
     role: AkanChildRole,

package/server/di/diLifecycle.ts

@@ -80,7 +80,7 @@ export class DiLifecycle {
     this.#libs = libs;
     this.#service.set("base", {
       service: srv.base,
-      signal: SignalRegistry.registerService(BaseInternal, BaseEndpoint, Base),
+      signal: SignalRegistry.registerService("base" as const, BaseInternal, BaseEndpoint, Base),
     });
     this.#middleware.set(Logging.refName, Logging);
     const defaultOption = createDefaultAkanOption();

package/server/proxy/localeWebProxy.ts

@@ -1,22 +1,39 @@
-import { match as matchLocale } from "@formatjs/intl-localematcher";
 import { parseAkanI18nEnv } from "akanjs/common";
-import Negotiator from "negotiator";
 import { AkanResponse } from "./akanResponse";
 import type { WebProxy } from "./types";
 
 function getLocale(request: Bun.BunRequest): string {
   const i18n = parseAkanI18nEnv();
-  if (!request.headers.get("accept-language")) return i18n.defaultLocale;
-  const negotiatorHeaders: Record<string, string> = {};
-  request.headers.forEach((value, key) => {
-    negotiatorHeaders[key] = value;
-  });
-  try {
-    const languages = new Negotiator({ headers: negotiatorHeaders }).languages();
-    return matchLocale(languages, i18n.locales, i18n.defaultLocale);
-  } catch {
-    return i18n.defaultLocale;
+  const acceptLanguage = request.headers.get("accept-language");
+  if (!acceptLanguage) return i18n.defaultLocale;
+  return matchAcceptedLocale(acceptLanguage, i18n.locales, i18n.defaultLocale);
+}
+
+function matchAcceptedLocale(acceptLanguage: string, locales: string[], defaultLocale: string): string {
+  const localeByLower = new Map(locales.map((locale) => [locale.toLowerCase(), locale]));
+  const acceptedLanguages = acceptLanguage
+    .split(",")
+    .map((part, index) => {
+      const [tag = "", ...params] = part.trim().split(";");
+      const quality = params
+        .map((param) => param.trim())
+        .find((param) => param.startsWith("q="))
+        ?.slice(2);
+      const q = quality === undefined ? 1 : Number(quality);
+      return { tag: tag.trim().toLowerCase(), q: Number.isFinite(q) ? q : 0, index };
+    })
+    .filter(({ tag, q }) => tag.length > 0 && q > 0)
+    .sort((a, b) => b.q - a.q || a.index - b.index);
+
+  for (const { tag } of acceptedLanguages) {
+    if (tag === "*") return defaultLocale;
+    const exact = localeByLower.get(tag);
+    if (exact) return exact;
+    const [language] = tag.split("-");
+    const baseMatch = locales.find((locale) => locale.toLowerCase().split("-")[0] === language);
+    if (baseMatch) return baseMatch;
   }
+  return defaultLocale;
 }
 
 export class LocaleWebProxy implements WebProxy {

package/service/serviceModule.ts

@@ -45,12 +45,7 @@ export class ServiceModel<
       this.cnst,
       this.db,
       Object.assign({}, this.srvMap, ...srvs.map((srv) => srv.srvMap)),
-    ) as unknown as ServiceModel<
-      Srv & MergeAllKeyOfObjects<SrvModules, "srv">,
-      CnstModel,
-      DbModel,
-      SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">
-    >;
+    ) as unknown as ServiceModel<Srv, CnstModel, DbModel, SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">>;
   }
 
   static getDefaultDbServiceMethods(className: string) {

package/signal/base.signal.ts

@@ -31,7 +31,7 @@ export class BaseEndpoint extends endpoint(srv.base, ({ query, mutation, message
 })) {}
 
 export class Base extends serverSignal(BaseEndpoint, BaseInternal) {}
-export const base = SignalRegistry.registerService(BaseInternal, BaseEndpoint, Base);
+export const base = SignalRegistry.registerService("base" as const, BaseInternal, BaseEndpoint, Base);
 
 const createBaseFetch = () => FetchClient.from(base);
 type BaseFetch = ReturnType<typeof createBaseFetch>;

package/signal/signalRegistry.ts

@@ -5,6 +5,18 @@ import type { ServerSignalCls } from "./serverSignal";
 import type { SliceCls } from "./slice";
 import type { SerializedSignal } from "./types";
 
+type SignalBaseRef<SigCls> = SigCls extends { srv: { srv: { refName: infer RefName } } } ? RefName : never;
+type SignalWithBase<RefName extends string, SigCls> = SignalBaseRef<SigCls> extends RefName ? SigCls : never;
+
+function assertSignalBase(refName: string, signalKind: string, signalCls: { srv?: { srv?: { refName?: unknown } } }) {
+  const signalRefName = signalCls.srv?.srv?.refName;
+  if (signalRefName !== refName) {
+    throw new Error(
+      `Signal base mismatch: ${signalKind} uses "${String(signalRefName)}", but registry expected "${refName}". Use srv.${refName}.with(...) when the signal needs another service.`,
+    );
+  }
+}
+
 export class DatabaseSignal<
   IntlCls extends InternalCls = InternalCls,
   EndpCls extends EndpointCls = EndpointCls,
@@ -46,34 +58,47 @@ export class ServiceSignal<
 
 /** Registry for database and service signals used by routing and fetch serialization. */
 export class SignalRegistry {
-  static readonly #database = new Map<string, DatabaseSignal<any, any, any, any>>();
-  static readonly #service = new Map<string, ServiceSignal<any, any, any>>();
+  static readonly #database = new Map<string, DatabaseSignal<InternalCls, EndpointCls, SliceCls, ServerSignalCls>>();
+  static readonly #service = new Map<string, ServiceSignal<InternalCls, EndpointCls, ServerSignalCls>>();
 
   static registerDatabase<
+    RefName extends string,
     IntlCls extends InternalCls,
     EndpCls extends EndpointCls,
     SlceCls extends SliceCls,
     SrvrCls extends ServerSignalCls,
   >(
-    internal: IntlCls,
-    endpoint: EndpCls,
-    slice: SlceCls,
+    refName: RefName,
+    internal: SignalWithBase<RefName, IntlCls>,
+    endpoint: SignalWithBase<RefName, EndpCls>,
+    slice: SignalWithBase<RefName, SlceCls>,
     server: SrvrCls,
   ): DatabaseSignal<IntlCls, EndpCls, SlceCls, SrvrCls> {
+    assertSignalBase(refName, "internal", internal);
+    assertSignalBase(refName, "endpoint", endpoint);
+    assertSignalBase(refName, "slice", slice);
     const databaseSignal = new DatabaseSignal(internal, endpoint, slice, server);
-    SignalRegistry.#database.set(internal.refName, databaseSignal);
+    SignalRegistry.#database.set(refName, databaseSignal);
     return databaseSignal;
   }
   static getDatabase(refName: string) {
     return SignalRegistry.#database.get(refName);
   }
-  static registerService<IntlCls extends InternalCls, EndpCls extends EndpointCls, SrvrCls extends ServerSignalCls>(
-    internal: IntlCls,
-    endpoint: EndpCls,
+  static registerService<
+    RefName extends string,
+    IntlCls extends InternalCls,
+    EndpCls extends EndpointCls,
+    SrvrCls extends ServerSignalCls,
+  >(
+    refName: RefName,
+    internal: SignalWithBase<RefName, IntlCls>,
+    endpoint: SignalWithBase<RefName, EndpCls>,
     server: SrvrCls,
   ): ServiceSignal<IntlCls, EndpCls, SrvrCls> {
+    assertSignalBase(refName, "internal", internal);
+    assertSignalBase(refName, "endpoint", endpoint);
     const serviceSignal = new ServiceSignal(internal, endpoint, server);
-    SignalRegistry.#service.set(internal.refName, serviceSignal);
+    SignalRegistry.#service.set(refName, serviceSignal);
     return serviceSignal;
   }
   static getService(refName: string) {

package/types/cli/npmRegistry.d.ts

@@ -0,0 +1 @@
+export declare function getLatestPackageVersion(packageName: string, tag?: string): Promise<string>;

package/types/cli/openBrowser.d.ts

@@ -0,0 +1 @@
+export declare function openBrowser(url: string): Promise<void>;

package/types/cli/pluralizeName.d.ts

@@ -0,0 +1 @@
+export declare function pluralizeName(name: string): string;

package/types/cli/semver.d.ts

@@ -0,0 +1 @@
+export declare function compareSemver(a: string, b: string): number;

package/types/client/cookie.d.ts

@@ -1,9 +1,14 @@
 import type { Account } from "akanjs/fetch";
+interface CookieOptions {
+    path?: string;
+    sameSite?: "strict" | "lax" | "none";
+    secure?: boolean;
+}
 export declare const cookies: () => Map<string, {
     name: string;
     value: string;
 }>;
-export declare const setCookie: (key: string, value: string, options?: Cookies.CookieAttributes) => void;
+export declare const setCookie: (key: string, value: string, options?: CookieOptions) => void;
 export declare const getCookie: (key: string) => string | undefined;
 export declare const removeCookie: (key: string, options?: {
     path: string;

package/types/common/index.d.ts

@@ -11,6 +11,7 @@ export { isEmail } from "./isEmail.d.ts";
 export { isPhoneNumber } from "./isPhoneNumber.d.ts";
 export { isQueryEqual } from "./isQueryEqual.d.ts";
 export { isValidDate } from "./isValidDate.d.ts";
+export { decodeJwtPayload } from "./jwtDecode.d.ts";
 export { Logger, type LoggerSink, type LoggerSinkEntry, type LogLevel } from "./Logger.d.ts";
 export { type AkanI18nConfig, type AkanI18nConfigInput, DEFAULT_AKAN_I18N, parseAkanI18nEnv, resolveAkanI18nConfig, } from "./localeConfig.d.ts";
 export { lowerlize } from "./lowerlize.d.ts";

package/types/common/jwtDecode.d.ts

@@ -0,0 +1,2 @@
+/** Decodes a JWT payload without validating its signature. */
+export declare function decodeJwtPayload<T = unknown>(jwt: string): T;

package/types/devkit/incrementalBuilder/incrementalBuilder.host.d.ts

@@ -7,6 +7,12 @@ interface IncrementalBuilderHostOptions {
     env: Record<string, string>;
     onMessage: (message: BuilderMessage) => void;
 }
+type IncrementalBuilderStatus = "starting" | "ready" | "restarting" | "stopped";
+interface IncrementalBuilderStartOptions {
+    onExit?: () => void;
+    onReady?: () => void;
+    onRestartReady?: () => void;
+}
 export declare class IncrementalBuilderHost {
     #private;
     logger: Logger;
@@ -15,11 +21,9 @@ export declare class IncrementalBuilderHost {
     app: App;
     ready: boolean;
     constructor({ app, entry, env, onMessage }: IncrementalBuilderHostOptions);
-    start({ onExit, onReady }: {
-        onExit?: () => void;
-        onReady?: () => void;
-    }): this;
-    send(message: BuilderMessage): void;
+    get status(): IncrementalBuilderStatus;
+    start(options?: IncrementalBuilderStartOptions): this;
+    send(message: BuilderMessage): boolean;
     stop(): void;
     static create(app: App, env: Record<string, string>, onMessage: (message: BuilderMessage) => void): Promise<IncrementalBuilderHost>;
 }

package/types/document/dataLoader.d.ts

@@ -1,17 +1,36 @@
 import type { QueryOf } from "akanjs/constant";
-import DataLoader from "dataloader";
 export declare const Id: StringConstructor;
 export declare const ObjectId: StringConstructor;
 export declare const Mixed: ObjectConstructor;
-export { DataLoader };
 type LoaderItem = Record<string, unknown>;
 type LoaderModel = {
     find: (query: QueryOf<unknown>) => Promise<LoaderItem[]> | {
         then: Promise<LoaderItem[]>["then"];
     };
 };
+type BatchLoadFn<Key, Value> = (keys: readonly Key[]) => PromiseLike<ReadonlyArray<Value | Error>> | ReadonlyArray<Value | Error>;
+interface DataLoaderOptions<Key, CacheKey> {
+    cache?: boolean;
+    cacheKeyFn?: (key: Key) => CacheKey;
+    batch?: boolean;
+    batchScheduleFn?: (callback: () => void) => void;
+    maxBatchSize?: number;
+    name?: string;
+}
+/** Minimal DataLoader-compatible batch loader used by Akan document resolvers. */
+export declare class DataLoader<Key, Value, CacheKey = Key> {
+    #private;
+    readonly name?: string;
+    constructor(batchLoadFn: BatchLoadFn<Key, Value>, options?: DataLoaderOptions<Key, CacheKey>);
+    load(key: Key): Promise<Value>;
+    loadMany(keys: readonly Key[]): Promise<Array<Value | Error>>;
+    clear(key: Key): this;
+    clearAll(): this;
+    prime(key: Key, value: Value | Error): this;
+}
 export declare const createLoader: <Key, Value>(model: LoaderModel, fieldName?: string, defaultQuery?: QueryOf<unknown>) => DataLoader<Key, Value, Key>;
 export declare const createArrayLoader: <K, V>(model: LoaderModel, fieldName?: string, defaultQuery?: QueryOf<unknown>) => DataLoader<K, V, K>;
 export declare const createArrayElementLoader: <K, V>(model: LoaderModel, fieldName?: string, defaultQuery?: QueryOf<unknown>) => DataLoader<K, V, K>;
 export declare const createQueryLoader: <Key, Value>(model: LoaderModel, queryKeys: string[], defaultQuery?: QueryOf<unknown>) => DataLoader<Key, Value, Key>;
 export type Loader<Field, Value> = DataLoader<Field, Value | null>;
+export {};

package/types/document/database.d.ts

@@ -2,7 +2,7 @@ import type { Dayjs, MergedValues, PromiseOrObject } from "akanjs/base";
 import { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor } from "akanjs/service";
-import type DataLoader from "dataloader";
+import type { DataLoader } from "./dataLoader.d.ts";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta.d.ts";
 import type { CRUDEventType, Mdl, SaveEventType } from "./into.d.ts";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types.d.ts";

package/types/service/serviceModule.d.ts

@@ -17,7 +17,7 @@ export declare class ServiceModel<Srv extends ServiceCls = ServiceCls, CnstModel
     });
     static fromModel<Srv extends ServiceCls, CnstModel extends ConstantModel, DbModel extends DatabaseModel>(srv: Srv, cnst: CnstModel, db: DbModel): ServiceModel<Srv, CnstModel, DbModel>;
     static from<Srv extends ServiceCls>(srv: Srv): ServiceModel<Srv, never, never, { [K in `${Uncapitalize<Srv["refName"]>}Service`]: UnCls<Srv>; }>;
-    with<SrvModules extends ServiceModel[]>(...srvs: SrvModules): ServiceModel<Srv & MergeAllKeyOfObjects<SrvModules, "srv">, CnstModel, DbModel, SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">>;
+    with<SrvModules extends ServiceModel[]>(...srvs: SrvModules): ServiceModel<Srv, CnstModel, DbModel, SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">>;
     static getDefaultDbServiceMethods(className: string): {
         [x: string]: ((this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) => Promise<any>) | ((this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) => Promise<any>) | ((this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => any) | ((this: DatabaseService, id: string, data: DataInputOf) => Promise<any>);
         __get(this: DatabaseService, id: string): Promise<any>;