akanjs 2.1.1 → 2.1.2-rc.0

package/server/systemPages.tsx

@@ -0,0 +1,165 @@
+import type { AkanI18nConfig } from "akanjs/common";
+import { DEFAULT_AKAN_I18N, getBasePathFromPathname } from "akanjs/common";
+import type { ReactNode } from "react";
+
+export type SystemPageKind = "not-found" | "error";
+
+export interface SystemPageOptions {
+  kind: SystemPageKind;
+  pathname: string;
+  homeHref: string;
+  lang?: string;
+  stylesheetHref?: string | null;
+  showDetails?: boolean;
+  error?: unknown;
+}
+
+export interface SystemPageResponseOptions extends SystemPageOptions {
+  method?: string;
+}
+
+export interface SystemPageHomeHrefOptions {
+  pathname: string;
+  i18n?: AkanI18nConfig;
+  basePaths?: Iterable<string>;
+  headerBasePath?: string | null;
+}
+
+const STATUS_COPY = {
+  "not-found": {
+    status: 404,
+    eyebrow: "Page not found",
+    title: "This page is off the flight path.",
+    description: "The route you requested does not exist, or it may have moved to a different address.",
+    actionLabel: "Go home",
+  },
+  error: {
+    status: 500,
+    eyebrow: "Server error",
+    title: "Something broke on the server.",
+    description: "The app could not finish rendering this page. Please try again in a moment.",
+    actionLabel: "Back to safety",
+  },
+} as const;
+
+const FALLBACK_STYLE = `
+:root { color-scheme: dark; --akan-primary: #ff493b; --akan-secondary: #2b2e33; --akan-accent: #d1a23b; --akan-base-content: #ffffff; --akan-base-100: #1a1a1a; --akan-base-200: #2a2a2a; --akan-error: #f02020; }
+body { margin: 0; min-height: 100vh; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: var(--akan-base-100); color: var(--akan-base-content); }
+a { color: inherit; }
+.akan-system-page { min-height: 100vh; display: grid; place-items: center; padding: 32px 18px; box-sizing: border-box; background: radial-gradient(circle at top left, rgba(255, 73, 59, 0.16), transparent 34%), linear-gradient(135deg, var(--akan-base-100), #111); }
+.akan-system-card { width: min(720px, 100%); border: 1px solid rgba(255, 255, 255, 0.12); border-radius: 32px; background: linear-gradient(145deg, rgba(42, 42, 42, 0.96), rgba(43, 46, 51, 0.78)); box-shadow: 0 24px 80px rgba(0, 0, 0, 0.36); padding: clamp(28px, 6vw, 56px); }
+.akan-system-status { margin: 0 0 18px; font-weight: 800; font-size: clamp(4rem, 18vw, 8rem); line-height: 0.85; letter-spacing: -0.08em; color: var(--akan-primary); }
+.akan-system-eyebrow { margin: 0 0 10px; color: var(--akan-accent); font-size: 0.78rem; font-weight: 800; letter-spacing: 0.18em; text-transform: uppercase; }
+.akan-system-title { margin: 0; max-width: 12ch; font-size: clamp(2rem, 7vw, 4rem); line-height: 0.95; letter-spacing: -0.055em; color: var(--akan-base-content); }
+.akan-system-description { margin: 22px 0 0; max-width: 56ch; color: rgba(255, 255, 255, 0.76); font-size: 1.05rem; line-height: 1.75; }
+.akan-system-path { margin: 22px 0 0; overflow-wrap: anywhere; border: 1px solid rgba(255, 255, 255, 0.1); border-radius: 16px; background: rgba(26, 26, 26, 0.72); padding: 12px 14px; color: rgba(255, 255, 255, 0.72); font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; font-size: 0.88rem; }
+.akan-system-actions { margin-top: 30px; display: flex; flex-wrap: wrap; gap: 12px; }
+.akan-system-action { display: inline-flex; min-height: 44px; align-items: center; justify-content: center; border: 1px solid var(--akan-primary); border-radius: 999px; background: var(--akan-primary); box-shadow: 0 12px 34px rgba(255, 73, 59, 0.26); color: var(--akan-base-content); padding: 0 18px; font-weight: 800; text-decoration: none; }
+.akan-system-secondary { border: 1px solid rgba(255, 255, 255, 0.12); background: var(--akan-secondary); color: var(--akan-base-content); }
+.akan-system-details { margin-top: 28px; max-height: 260px; overflow: auto; border-radius: 18px; background: rgba(26, 26, 26, 0.82); border: 1px solid rgba(240, 32, 32, 0.22); padding: 16px; color: rgba(255, 255, 255, 0.78); font-size: 0.82rem; line-height: 1.55; white-space: pre-wrap; }
+`;
+
+export function createSystemPageDocument(options: SystemPageOptions): ReactNode {
+  const copy = STATUS_COPY[options.kind];
+  const details = options.showDetails ? getSystemPageErrorDetails(options.error) : null;
+  const title = `${copy.status} - ${copy.eyebrow}`;
+
+  return (
+    <html lang={options.lang ?? DEFAULT_AKAN_I18N.defaultLocale}>
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta name="robots" content="noindex" />
+        <title>{title}</title>
+        {options.stylesheetHref ? (
+          <link rel="stylesheet" href={options.stylesheetHref} precedence="default" data-akan-css="active" />
+        ) : null}
+        <style data-akan-system-page>{FALLBACK_STYLE}</style>
+      </head>
+      <body>
+        <main className="akan-system-page min-h-screen bg-base-100 text-base-content">
+          <section
+            className="akan-system-card rounded-3xl border border-base-content/10 bg-base-content/4 p-8 shadow-2xl backdrop-blur-xl"
+            aria-labelledby="akan-system-title"
+          >
+            <p className="akan-system-status text-primary">{copy.status}</p>
+            <p className="akan-system-eyebrow text-primary">{copy.eyebrow}</p>
+            <h1 id="akan-system-title" className="akan-system-title font-black">
+              {copy.title}
+            </h1>
+            <p className="akan-system-description text-base-content/70">{copy.description}</p>
+            <p className="akan-system-path border border-base-content/10 bg-base-200/50" aria-label="Requested path">
+              {options.pathname}
+            </p>
+            <div className="akan-system-actions">
+              <a className="akan-system-action btn btn-primary" href={options.homeHref}>
+                {copy.actionLabel}
+              </a>
+              <a className="akan-system-action akan-system-secondary btn" href={options.pathname}>
+                Try again
+              </a>
+            </div>
+            {details ? (
+              <pre className="akan-system-details" aria-label="Development error details">
+                {details}
+              </pre>
+            ) : null}
+          </section>
+        </main>
+      </body>
+    </html>
+  );
+}
+
+export async function createSystemPageResponse(options: SystemPageResponseOptions): Promise<Response> {
+  const status = STATUS_COPY[options.kind].status;
+  const headers = createSystemPageHeaders();
+  if (options.method === "HEAD") return new Response(null, { status, headers });
+
+  try {
+    const { renderToReadableStream } = await import("react-dom/server.browser");
+    const stream = await renderToReadableStream(createSystemPageDocument(options));
+    return new Response(stream, { status, headers });
+  } catch {
+    return new Response(createSystemPageFallbackText(options.kind), {
+      status,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "no-store",
+      },
+    });
+  }
+}
+
+export function createSystemPageHeaders(): Headers {
+  return new Headers({
+    "Content-Type": "text/html; charset=utf-8",
+    "Cache-Control": "no-store",
+  });
+}
+
+export function createSystemPageFallbackText(kind: SystemPageKind): string {
+  const copy = STATUS_COPY[kind];
+  return `${copy.status} ${copy.eyebrow}`;
+}
+
+export function getSystemPageErrorDetails(error: unknown): string {
+  if (error instanceof Error) return error.stack ?? error.message;
+  return String(error);
+}
+
+export function getSystemPageHomeHref({
+  pathname,
+  i18n = DEFAULT_AKAN_I18N,
+  basePaths = [],
+  headerBasePath,
+}: SystemPageHomeHrefOptions): string {
+  const segments = pathname.split("/").filter(Boolean);
+  const locale = i18n.locales.includes(segments[0] ?? "") ? segments[0] : i18n.defaultLocale;
+  const basePath = getBasePathFromPathname(pathname, {
+    basePaths,
+    i18n,
+    headerBasePath,
+  });
+  return `/${[locale, basePath].filter(Boolean).join("/")}`;
+}

package/server/webRouter.ts

@@ -25,6 +25,7 @@ import { createDefaultRobotsTxt } from "./robots";
 import { RscWorker } from "./rscWorkerHost";
 import { createDefaultSitemapXml, getSitemapBasePath } from "./sitemap";
 import { SsrFromRscRenderer } from "./ssrFromRscRenderer";
+import { createSystemPageResponse, getSystemPageHomeHref } from "./systemPages";
 import type { BaseBuildArtifact, HttpRoutes, RenderState } from "./types";
 
 const RESERVED_BASE_PATHS = new Set(["admin"]);
@@ -176,7 +177,9 @@ export class WebRouter {
     <script type="module" src="/csr.js"></script>
   </body>
 </html>`;
-        return new Response(this.#withCsrHmr(htmlText), { headers: { "Content-Type": "text/html; charset=utf-8" } });
+        return new Response(this.#withCsrHmr(htmlText), {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
       },
       [`${clientServePrefix}/*`]: async (req) => {
         this.#requestStats.staticAsset += 1;
@@ -252,15 +255,26 @@ export class WebRouter {
           const manifest = await this.#ensureRoute(targetUrl);
           const rscHeaders = new Headers(req.headers);
           if (normalizedTarget.basePath) rscHeaders.set("x-base-path", normalizedTarget.basePath);
-          const rscReq = new Request(targetUrl, { method: "GET", headers: rscHeaders });
-          const result = await this.#rsc.renderWithMeta(rscReq, { clientManifest: manifest.clientManifest });
+          const rscReq = new Request(targetUrl, {
+            method: "GET",
+            headers: rscHeaders,
+          });
+          const result = await this.#rsc.renderWithMeta(rscReq, {
+            clientManifest: manifest.clientManifest,
+          });
           if (result.type === "redirect") return WebRouter.#rscRedirectResponse(result.location, result.method);
           if (result.type === "not-found") return WebRouter.#rscRedirectResponse("/404", "replace");
+          if (result.status === 404) return WebRouter.#rscRedirectResponse("/404", "replace");
+          if (result.status && result.status >= 500)
+            return this.#renderRscErrorResponse("__rsc", "Internal Server Error");
           return new Response(result.stream, {
-            headers: { "Content-Type": "text/x-component; charset=utf-8", "Cache-Control": "no-store" },
+            headers: {
+              "Content-Type": "text/x-component; charset=utf-8",
+              "Cache-Control": "no-store",
+            },
           });
         } catch (err) {
-          return this.#renderErrorResponse("__rsc", err);
+          return this.#renderRscErrorResponse("__rsc", err);
         }
       },
       "/__rsc/manifest": () =>
@@ -280,7 +294,9 @@ export class WebRouter {
           const csrHtml = WebRouter.#resolveCsrHtmlPath(csrOutputDir, url.pathname, this.#artifact);
           if (!csrHtml) return new Response("Not Found", { status: 404 });
           const html = await Bun.file(csrHtml).text();
-          return new Response(this.#withCsrHmr(html), { headers: { "Content-Type": "text/html; charset=utf-8" } });
+          return new Response(this.#withCsrHmr(html), {
+            headers: { "Content-Type": "text/html; charset=utf-8" },
+          });
         }
 
         const csrAssetPath = path.extname(url.pathname) ? WebRouter.#safeResolve(csrOutputDir, url.pathname) : null;
@@ -300,7 +316,7 @@ export class WebRouter {
             this.#requestStats.staticAsset += 1;
             return WebRouter.#fileResponse(req, filePath, {
               contentType: Bun.file(filePath).type || "application/octet-stream",
-              cacheControl: this.#prodMode ? "public, max-age=0" : "no-store",
+              cacheControl: this.#prodMode ? "public, max-age=300" : "no-store",
             });
           }
         }
@@ -343,12 +359,17 @@ export class WebRouter {
           const cachedHtml = htmlCacheKey ? this.#getCachedHtml(htmlCacheKey) : null;
           if (cachedHtml) {
             return new Response(cachedHtml, {
-              headers: { "Content-Type": "text/html; charset=utf-8", "X-Akan-Cache": "HIT" },
+              headers: {
+                "Content-Type": "text/html; charset=utf-8",
+                "X-Akan-Cache": "HIT",
+              },
             });
           }
-          const rscResult = await this.#rsc.renderWithMeta(req, { clientManifest: manifest.clientManifest });
+          const rscResult = await this.#rsc.renderWithMeta(req, {
+            clientManifest: manifest.clientManifest,
+          });
           if (rscResult.type === "redirect") return Response.redirect(new URL(rscResult.location, url.origin), 307);
-          if (rscResult.type === "not-found") return Response.redirect(new URL("/404", url.origin), 307);
+          if (rscResult.type === "not-found") return this.#renderNotFoundResponse(req, url);
           const themeCookieExists = WebRouter.#hasCookie(req, "theme");
           const htmlStream = await new SsrFromRscRenderer().render({
             request: req,
@@ -359,16 +380,24 @@ export class WebRouter {
             importmap: this.#artifact.vendorMap,
             theme: themeCookieExists ? undefined : (rscResult.theme ?? "system"),
           });
-          if (htmlCacheKey) {
+          const responseStatus = rscResult.status ?? 200;
+          const responseHeaders = WebRouter.#htmlResponseHeaders(responseStatus);
+          if (htmlCacheKey && responseStatus === 200) {
             const html = await new Response(htmlStream).text();
             this.#setCachedHtml(htmlCacheKey, html);
             return new Response(html, {
-              headers: { "Content-Type": "text/html; charset=utf-8", "X-Akan-Cache": "MISS" },
+              headers: {
+                "Content-Type": "text/html; charset=utf-8",
+                "X-Akan-Cache": "MISS",
+              },
             });
           }
-          return new Response(htmlStream, { headers: { "Content-Type": "text/html; charset=utf-8" } });
+          return new Response(req.method === "HEAD" ? null : htmlStream, {
+            status: responseStatus,
+            headers: responseHeaders,
+          });
         } catch (err) {
-          return this.#renderErrorResponse(url.pathname, err);
+          return this.#renderErrorResponse(req, url.pathname, err);
         }
       },
     };
@@ -535,18 +564,81 @@ export class WebRouter {
 
   async #ensureRoute(url: URL) {
     const started = Date.now();
-    const matched = RouteSeedIndexStore.match(url.pathname, this.#seedIndex.entries);
+    const matched =
+      RouteSeedIndexStore.match(url.pathname, this.#seedIndex.entries) ??
+      RouteSeedIndexStore.matchPrefix(url.pathname, this.#seedIndex.entries);
     if (matched) await this.#routeCache.ensure(matched.entry.routeId, matched.entry.seeds);
     this.#logger.verbose(
       `[route-cache] ensure pathname=${url.pathname} routeId=${matched?.entry.routeId ?? "(none)"} in ${Date.now() - started}ms`,
     );
     return this.#routeCache.snapshot();
   }
-  #renderErrorResponse(scope: string, err: unknown): Response {
+  #renderNotFoundResponse(req: Request, url: URL): Promise<Response> {
+    return createSystemPageResponse({
+      kind: "not-found",
+      method: req.method,
+      pathname: url.pathname,
+      lang: WebRouter.#getLocale(url.pathname, this.#artifact.i18n),
+      homeHref: this.#getSystemPageHomeHref(req, url.pathname),
+      stylesheetHref: this.#getStylesheetHref(req, url.pathname),
+    });
+  }
+
+  #renderErrorResponse(req: Request, scope: string, err: unknown): Promise<Response> {
+    const message = err instanceof Error ? err.message : String(err);
+    this.#logger.error(`[SSR] render failed scope=${scope}: ${message}`);
+    this.#hub?.broadcast({ type: "error", message });
+    return createSystemPageResponse({
+      kind: "error",
+      method: req.method,
+      pathname: scope,
+      lang: WebRouter.#getLocale(new URL(req.url).pathname, this.#artifact.i18n),
+      homeHref: this.#getSystemPageHomeHref(req, new URL(req.url).pathname),
+      stylesheetHref: this.#getStylesheetHref(req, new URL(req.url).pathname),
+      showDetails: !this.#prodMode,
+      error: err,
+    });
+  }
+
+  #renderRscErrorResponse(scope: string, err: unknown): Response {
     const message = err instanceof Error ? err.message : String(err);
     this.#logger.error(`[SSR] render failed scope=${scope}: ${message}`);
     this.#hub?.broadcast({ type: "error", message });
-    return new Response("Internal Server Error", { status: 500 });
+    return new Response("Internal Server Error", {
+      status: 500,
+      headers: { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" },
+    });
+  }
+
+  #getSystemPageHomeHref(req: Request, pathname: string): string {
+    return getSystemPageHomeHref({
+      pathname,
+      i18n: this.#artifact.i18n,
+      basePaths: this.#artifact.basePaths,
+      headerBasePath:
+        req.headers.get("x-base-path") ?? WebRouter.#basePathForRequestHost(req, this.#artifact.subRoutes),
+    });
+  }
+
+  #getStylesheetHref(req: Request, pathname: string): string | null {
+    const basePath = getBasePathFromPathname(pathname, {
+      basePaths: Object.keys(this.renderState.cssAssets),
+      i18n: this.#artifact.i18n,
+      headerBasePath:
+        req.headers.get("x-base-path") ?? WebRouter.#basePathForRequestHost(req, this.#artifact.subRoutes),
+    });
+    return this.renderState.cssAssets[basePath ?? ""]?.cssUrl ?? null;
+  }
+
+  static #getLocale(pathname: string, i18n: AkanI18nConfig): string {
+    const [segment] = pathname.split("/").filter(Boolean);
+    return segment && i18n.locales.includes(segment) ? segment : i18n.defaultLocale;
+  }
+
+  static #htmlResponseHeaders(status: number): Headers {
+    const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
+    if (status >= 400) headers.set("Cache-Control", "no-store");
+    return headers;
   }
   #withCsrHmr(html: string): string {
     if (this.#prodMode) return html;
@@ -589,7 +681,13 @@ export class WebRouter {
     const rsc = new RscWorker(artifact);
     await rsc.ready;
     const seedIndex = await RouteSeedIndexStore.load(artifactDir);
-    return new WebRouter({ artifact, cssBytesByUrl, rsc, seedIndex, upgradeHmrWs });
+    return new WebRouter({
+      artifact,
+      cssBytesByUrl,
+      rsc,
+      seedIndex,
+      upgradeHmrWs,
+    });
   }
 
   static #resolveArtifactDir() {

package/service/predefinedAdaptor/database.adaptor.ts

@@ -1094,6 +1094,7 @@ export class SqliteDatabase
         appName,
         fileName: `${appName}-${environment}.db`,
         isProduction: process.env.NODE_ENV === "production",
+        operationMode: env.operationMode,
         workspaceRoot: env.workspaceRoot,
       });
       return {
@@ -1204,6 +1205,7 @@ export class LibsqlDatabase
         appName,
         fileName: `${appName}-${environment}.db`,
         isProduction: process.env.NODE_ENV === "production",
+        operationMode: env.operationMode,
         workspaceRoot: env.workspaceRoot,
       });
       return {

package/service/predefinedAdaptor/solidSqlite.ts

@@ -30,6 +30,7 @@ export const getSolidConfig = (env: SolidEnv): Required<SolidConfig> => {
     appName,
     fileName: `${appName}-${environment}_solid.db`,
     isProduction: process.env.NODE_ENV === "production",
+    operationMode: env.operationMode,
     workspaceRoot: env.workspaceRoot,
   });
   return {

package/service/predefinedAdaptor/sqlitePath.ts

@@ -4,6 +4,7 @@ interface ResolveDefaultSqliteFileOptions {
   appName: string;
   fileName: string;
   isProduction: boolean;
+  operationMode?: string;
   workspaceRoot?: string;
 }
 
@@ -11,10 +12,12 @@ export const resolveDefaultSqliteFile = ({
   appName,
   fileName,
   isProduction,
+  operationMode,
   workspaceRoot,
 }: ResolveDefaultSqliteFileOptions) => {
   const sqliteDir = process.env.AKAN_SQLITE_DIR;
   if (sqliteDir) return path.join(sqliteDir, fileName);
-  if (isProduction) return path.join(process.cwd(), "sqlite", fileName);
+  const isLocalOperation = (operationMode ?? process.env.AKAN_PUBLIC_OPERATION_MODE) === "local";
+  if (isProduction && !isLocalOperation) return path.join(process.cwd(), "sqlite", fileName);
   return path.join(workspaceRoot ?? process.cwd(), "local", "apps", appName, fileName);
 };

package/service/predefinedAdaptor/storage.adaptor.ts

@@ -59,7 +59,7 @@ export interface BlobStorageOptions extends BaseEnv {
 export class BlobStorage
   extends adapt("blobStorage", ({ env }) => ({
     root: env(
-      ({ appName, blobStorage = { baseDir: "local", urlPrefix: "/backend/localFile/getBlob" } }: BlobStorageOptions) =>
+      ({ appName, blobStorage = { baseDir: "local", urlPrefix: "/api/localFile/getBlob" } }: BlobStorageOptions) =>
         `${process.env.AKAN_WORKSPACE_ROOT ?? "."}/${blobStorage.baseDir ?? "local"}/${appName}/backend`,
     ),
     privateRoot: env(
@@ -67,7 +67,7 @@ export class BlobStorage
         `${process.env.AKAN_WORKSPACE_ROOT ?? "."}/${blobStorage.privateBaseDir ?? "local"}/${appName}/server-private`,
     ),
     urlPrefix: env(
-      ({ blobStorage = { urlPrefix: "/backend/localFile/getBlob" } }: BlobStorageOptions) => blobStorage.urlPrefix,
+      ({ blobStorage = { urlPrefix: "/api/localFile/getBlob" } }: BlobStorageOptions) => blobStorage.urlPrefix,
     ),
   }))
   implements StorageAdaptor

package/types/client/csrTypes.d.ts

@@ -54,6 +54,13 @@ export interface PageLoadingProps {
 export interface LayoutLoadingProps extends PageLoadingProps {
     children: ReactNode;
 }
+export interface LayoutNotFoundProps extends PageProps {
+    pathname: string;
+}
+export interface LayoutErrorProps extends LayoutNotFoundProps {
+    error?: unknown;
+    digest?: string;
+}
 export type Head = ReactNode;
 export type GenerateHead = (props: PageProps) => PromiseOrObject<Head | null | undefined>;
 export type ResolveHead = (props: PageProps) => PromiseOrObject<Head | null | undefined>;
@@ -62,9 +69,15 @@ export type PageRender = (props: PageProps) => PromiseOrObject<ReactNode>;
 export type LayoutRender = (props: LayoutProps) => PromiseOrObject<ReactNode>;
 export type PageLoadingRender = (props: PageLoadingProps) => PromiseOrObject<ReactNode>;
 export type LayoutLoadingRender = (props: LayoutLoadingProps) => PromiseOrObject<ReactNode>;
+export type LayoutNotFoundRender = (props: LayoutNotFoundProps) => PromiseOrObject<ReactNode>;
+export type LayoutErrorRender = (props: LayoutErrorProps) => PromiseOrObject<ReactNode>;
 export interface RouteRender {
     render: LayoutRender | PageRender;
     Loading?: LayoutLoadingRender | PageLoadingRender;
+    NotFound?: LayoutNotFoundRender;
+    Error?: LayoutErrorRender;
+    resolveNotFound?: () => PromiseOrObject<LayoutNotFoundRender | undefined>;
+    resolveError?: () => PromiseOrObject<LayoutErrorRender | undefined>;
     resolveHead?: ResolveHead;
     getPageConfig?: () => PromiseOrObject<PageConfig | undefined>;
 }
@@ -111,6 +124,8 @@ export interface LayoutModule {
     layoutStyle?: "mobile" | "web";
     gaTrackingId?: string;
     Loading?: LayoutLoadingRender;
+    NotFound?: LayoutNotFoundRender;
+    Error?: LayoutErrorRender;
 }
 export type RouteModule = PageModule | LayoutModule;
 export interface Route {
@@ -231,6 +246,12 @@ export interface PathRoute {
     resolveHead?: ResolveHead;
     isSpecialRoute?: boolean;
 }
+export interface LayoutFallbackRoute {
+    path: string;
+    pathSegments: string[];
+    renderRootLayouts: RouteRender[];
+    renderLayouts: RouteRender[];
+}
 export interface RouteGuide {
     pathSegment: string;
     pathRoute?: PathRoute;

package/types/client/translator.d.ts

@@ -10,6 +10,7 @@ export declare class Translator {
     #private;
     constructor(dictionary: Record<string, Record<string, Record<string, unknown>>>);
     hasDictionary(lang: string): boolean;
+    static seed(lang: string, dict: Dictionary | undefined): void;
     translate(lang: string, key: string, param?: Record<string, string | number>): string;
     getDictionary(lang: string): Promise<Dictionary>;
 }

package/types/server/artifact/routeSeedIndexStore.d.ts

@@ -38,5 +38,6 @@ export declare class RouteSeedIndexStore {
      * matches, along with the extracted parameters.
      */
     static match(pathname: string, entries: RouteSeedEntry[]): MatchedRoute | null;
+    static matchPrefix(pathname: string, entries: RouteSeedEntry[]): MatchedRoute | null;
 }
 export {};

package/types/server/routeElementComposer.d.ts

@@ -1,4 +1,4 @@
-import type { Head, PathRoute, RouteRender } from "akanjs/client";
+import type { Head, LayoutFallbackRoute, PathRoute, RouteRender } from "akanjs/client";
 import { type ReactElement, type ReactNode } from "react";
 export declare class RouteElementComposer {
     #private;
@@ -12,6 +12,20 @@ export declare class RouteElementComposer {
         params: Record<string, string>;
         searchParams: Record<string, string | string[]>;
     }): Promise<Head | null | undefined>;
+    static composeFallback({ kind, route, params, searchParams, pathname, error, digest, }: {
+        kind: "not-found" | "error";
+        route: PathRoute | LayoutFallbackRoute;
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+        pathname: string;
+        error?: unknown;
+        digest?: string;
+    }): Promise<ReactNode | null>;
+    static composeRenders({ renders, params, searchParams, }: {
+        renders: RouteRender[];
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+    }): ReactNode;
     static renderAsync({ routeRender, children, params, searchParams, }: {
         routeRender: RouteRender;
         children: ReactNode;

package/types/server/routeTreeBuilder.d.ts

@@ -1,4 +1,4 @@
-import type { PageState, PathRoute, RouteModule } from "akanjs/client";
+import type { LayoutFallbackRoute, PageState, PathRoute, RouteModule } from "akanjs/client";
 export type PagesContext = Record<string, () => Promise<RouteModule>>;
 export declare const defaultPageState: PageState;
 export interface RouteModuleCacheStats {
@@ -13,11 +13,16 @@ export declare class RouteTreeBuilder {
     #private;
     constructor(context: PagesContext);
     build(): PathRoute[];
+    getFallbackRoutes(): LayoutFallbackRoute[];
     static getCacheStats(): RouteModuleCacheStats;
     static resetCacheStats(): void;
     static match(pathname: string, pathRoutes: PathRoute[]): {
         pathRoute: PathRoute;
         params: Record<string, string>;
     } | null;
+    static matchFallback(pathname: string, fallbackRoutes: LayoutFallbackRoute[]): {
+        fallbackRoute: LayoutFallbackRoute;
+        params: Record<string, string>;
+    } | null;
     static parseSearchParams(search: string): Record<string, string | string[]>;
 }

package/types/server/rscWorkerHost.d.ts

@@ -8,6 +8,7 @@ export type RscRenderResult = {
     type: "stream";
     stream: ReadableStream<Uint8Array>;
     theme?: AkanTheme;
+    status?: number;
 } | {
     type: "redirect";
     location: string;

package/types/server/systemPages.d.ts

@@ -0,0 +1,27 @@
+import type { AkanI18nConfig } from "akanjs/common";
+import type { ReactNode } from "react";
+export type SystemPageKind = "not-found" | "error";
+export interface SystemPageOptions {
+    kind: SystemPageKind;
+    pathname: string;
+    homeHref: string;
+    lang?: string;
+    stylesheetHref?: string | null;
+    showDetails?: boolean;
+    error?: unknown;
+}
+export interface SystemPageResponseOptions extends SystemPageOptions {
+    method?: string;
+}
+export interface SystemPageHomeHrefOptions {
+    pathname: string;
+    i18n?: AkanI18nConfig;
+    basePaths?: Iterable<string>;
+    headerBasePath?: string | null;
+}
+export declare function createSystemPageDocument(options: SystemPageOptions): ReactNode;
+export declare function createSystemPageResponse(options: SystemPageResponseOptions): Promise<Response>;
+export declare function createSystemPageHeaders(): Headers;
+export declare function createSystemPageFallbackText(kind: SystemPageKind): string;
+export declare function getSystemPageErrorDetails(error: unknown): string;
+export declare function getSystemPageHomeHref({ pathname, i18n, basePaths, headerBasePath, }: SystemPageHomeHrefOptions): string;

package/types/service/predefinedAdaptor/sqlitePath.d.ts

@@ -2,7 +2,8 @@ interface ResolveDefaultSqliteFileOptions {
     appName: string;
     fileName: string;
     isProduction: boolean;
+    operationMode?: string;
     workspaceRoot?: string;
 }
-export declare const resolveDefaultSqliteFile: ({ appName, fileName, isProduction, workspaceRoot, }: ResolveDefaultSqliteFileOptions) => string;
+export declare const resolveDefaultSqliteFile: ({ appName, fileName, isProduction, operationMode, workspaceRoot, }: ResolveDefaultSqliteFileOptions) => string;
 export {};

package/types/ui/System/Client.d.ts

@@ -6,19 +6,15 @@ import { type HTMLAttributes, type ReactNode, type RefObject } from "react";
 export declare const Client: {
     (): import("react/jsx-runtime").JSX.Element;
     Wrapper: ({ children, theme, lang, dictionary, signals, reconnect, }: ClientWrapperProps) => import("react/jsx-runtime").JSX.Element;
-    Bridge: ({ env, lang, theme, prefix, gaTrackingId }: ClientBridgeProps) => "" | import("react/jsx-runtime").JSX.Element | undefined;
+    Bridge: ({ env, lang, theme, prefix, gaTrackingId, }: ClientBridgeProps) => "" | import("react/jsx-runtime").JSX.Element | undefined;
     Inner: () => import("react/jsx-runtime").JSX.Element;
-    SsrBridge: ({ lang, prefix }: ClientSsrBridgeProps) => null;
+    SsrBridge: ({ lang, prefix, }: ClientSsrBridgeProps) => null;
 };
 interface ClientWrapperProps {
     children: ReactNode;
     theme?: AkanTheme;
     lang?: string;
-    dictionary?: {
-        [key: string]: {
-            [key: string]: string;
-        };
-    };
+    dictionary?: Record<string, Record<string, unknown>>;
     signals?: SerializedSignal[];
     reconnect?: boolean;
 }
@@ -41,11 +37,11 @@ interface ClientBridgeProps {
     prefix?: string;
     gaTrackingId?: string;
 }
-export declare const ClientBridge: ({ env, lang, theme, prefix, gaTrackingId }: ClientBridgeProps) => "" | import("react/jsx-runtime").JSX.Element | undefined;
+export declare const ClientBridge: ({ env, lang, theme, prefix, gaTrackingId, }: ClientBridgeProps) => "" | import("react/jsx-runtime").JSX.Element | undefined;
 export declare const ClientInner: () => import("react/jsx-runtime").JSX.Element;
 interface ClientSsrBridgeProps {
     lang: string;
     prefix?: string;
 }
-export declare const ClientSsrBridge: ({ lang, prefix }: ClientSsrBridgeProps) => null;
+export declare const ClientSsrBridge: ({ lang, prefix, }: ClientSsrBridgeProps) => null;
 export {};