akanjs 3.0.0-beta.16 → 3.0.0-beta.18

package/fetch/client/httpClient.ts

@@ -207,7 +207,7 @@ export class HttpClient {
     const searchPath = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
     const paramedPath = path.replace(/:(\w+)/g, (match, p1) => {
       const value = argMap.get(p1);
-      return value === null || value === undefined ? match : String(value);
+      return value === null || value === undefined ? match : encodeURIComponent(String(value));
     });
     return `${paramedPath}${searchPath}`;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.18",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanServer.ts

@@ -268,7 +268,9 @@ export class AkanServer {
   }
   setMcp(mcp: boolean | McpServerOption = true) {
     if (this.status !== "stopped") throw new Error("MCP config must be set before app initialization.");
-    this.mcp = typeof mcp === "boolean" ? mcp : (mcp.enabled ?? true);
+
+    const requested = typeof mcp === "boolean" ? mcp : (mcp.enabled ?? this.mcp);
+    this.mcp = requested && !AkanServer.#isEnvOff("AKAN_MCP", "AKAN_PUBLIC_MCP");
     if (typeof mcp === "boolean") return this;
     const { enabled: _enabled, readOnly, auth, ...rest } = mcp;
     if (readOnly !== undefined) this.mcpReadOnly = readOnly;

package/server/console.ts

@@ -124,16 +124,16 @@ export interface AkanConsoleContext extends Record<string, unknown> {
   debug: () => ReturnType<AkanServer["inspectConsole"]>;
 }
 
-export const assertAkanConsoleAllowed = (
-  env: Pick<BaseEnv, "environment" | "operationMode"> = {
-    environment: (process.env.AKAN_PUBLIC_ENV ?? "debug") as BaseEnv["environment"],
-    operationMode: (process.env.AKAN_PUBLIC_OPERATION_MODE ?? "cloud") as BaseEnv["operationMode"],
-  },
-) => {
+export const assertAkanConsoleAllowed = (env: Partial<Pick<BaseEnv, "environment" | "operationMode">> = {}) => {
+  const environment = env.environment ?? ((process.env.AKAN_PUBLIC_ENV ?? "debug") as BaseEnv["environment"]);
+  const operationMode =
+    env.operationMode ??
+    ((process.env.AKAN_PUBLIC_OPERATION_MODE ??
+      (environment === "local" ? "local" : "cloud")) as BaseEnv["operationMode"]);
   const isProductionLike =
-    env.environment === "main" ||
-    env.operationMode === "cloud" ||
-    env.operationMode === "edge" ||
+    environment === "main" ||
+    operationMode === "cloud" ||
+    operationMode === "edge" ||
     process.env.NODE_ENV === "production";
   if (!isProductionLike || process.env.AKAN_CONSOLE === "1") return;
 

package/server/decorators.ts

@@ -1,27 +1,15 @@
 /**
- * Method decorators for a server class: `@Transaction`, `@Try`, `@CacheMethod`. Kept because `libs/util`'s
+ * Method decorators for a server class: `@Transaction`, `@Try`. Kept because `libs/util`'s
  * storage adaptors use `@Try` on their remote calls; new code follows the adaptor rule instead
  * (`catch` → `logger.error` → `return null`).
  */
 
 type DecoratedInstance = {
-  logger?: { warn?: (message: string) => void; trace?: (message: string) => void };
+  logger?: { warn?: (message: string) => void };
   __database?: { transaction?: <T>(fn: () => Promise<T>) => Promise<T> };
-  __databaseModel?: {
-    __database?: { transaction?: <T>(fn: () => Promise<T>) => Promise<T> };
-    __model?: { modelName: string };
-    __cache?: {
-      get: (key: string) => Promise<string | null>;
-      set: (key: string, value: string, option: unknown) => unknown;
-    };
-  };
+  __databaseModel?: { __database?: { transaction?: <T>(fn: () => Promise<T>) => Promise<T> } };
   database?: { transaction?: <T>(fn: () => Promise<T>) => Promise<T> };
   connection?: { transaction?: <T>(fn: () => Promise<T>) => Promise<T> };
-  __model?: { modelName: string };
-  __cache?: {
-    get: (key: string) => Promise<string | null>;
-    set: (key: string, value: string, option: unknown) => unknown;
-  };
 };
 
 /** Method decorator that catches errors and logs a warning instead of throwing. */
@@ -53,52 +41,3 @@ export const Transaction = (): MethodDecorator => {
     return descriptor;
   }) as MethodDecorator;
 };
-
-/**
- * Method decorator that caches method results for the given timeout in milliseconds.
- *
- * Not `Cache` — `akanjs/signal` exports a `Cache` **middleware class**, and an app importing both barrels got
- * one name meaning two things.
- */
-export const CacheMethod = (timeout = 1000, getCacheKey?: (...args: unknown[]) => string): MethodDecorator => {
-  return ((_target: unknown, key: string, descriptor: PropertyDescriptor) => {
-    const originMethod = descriptor.value as (this: unknown, ...args: unknown[]) => unknown;
-    const cacheMap = new Map<string, unknown>();
-    const timerMap = new Map<string, NodeJS.Timeout>();
-    descriptor.value = async function (...args: unknown[]) {
-      const instance = this as DecoratedInstance;
-      const classType = instance.__model ? "doc" : instance.__databaseModel ? "service" : "class";
-      const model = instance.__model ?? instance.__databaseModel?.__model;
-      const cache = instance.__cache ?? instance.__databaseModel?.__cache;
-      const cacheKeyValue = getCacheKey ? getCacheKey(...args) : JSON.stringify(args);
-      const cacheKey = `${classType}:${model?.modelName ?? "unknown"}:${key}:${cacheKeyValue}`;
-      const getCache = async (cacheKey: string) => {
-        if (classType === "class") return cacheMap.get(cacheKey);
-        const cached = (await cache?.get(cacheKey)) as string | null;
-        if (cached) return JSON.parse(cached);
-        return null;
-      };
-      const setCache = async (cacheKey: string, value: unknown) => {
-        if (classType === "class") {
-          const existingTimer = timerMap.get(cacheKey);
-          if (existingTimer) clearTimeout(existingTimer);
-          cacheMap.set(cacheKey, value);
-          const timer = setTimeout(() => {
-            cacheMap.delete(cacheKey);
-            timerMap.delete(cacheKey);
-          }, timeout);
-          timerMap.set(cacheKey, timer);
-        } else await cache?.set(cacheKey, JSON.stringify(value), { PX: timeout });
-      };
-      const cachedData = await getCache(cacheKey);
-      if (cachedData) {
-        instance.logger?.trace?.(`${model?.modelName ?? "unknown"} cache hit: ${cacheKey}`);
-        return cachedData;
-      }
-      const result = await originMethod.apply(this, args);
-      await setCache(cacheKey, result);
-      instance.logger?.trace?.(`${model?.modelName ?? "unknown"} cache set: ${cacheKey}`);
-      return result;
-    };
-  }) as MethodDecorator;
-};

package/server/devtools/depsSerializer.ts

@@ -1,7 +1,6 @@
 import { type BaseEnv, INJECT_META } from "akanjs/base";
 import type { AdaptorCls, InjectInfo, ServiceCls } from "akanjs/service";
 import type { DiLifecycle } from "../di/diLifecycle";
-import { DevtoolsJson } from "./devtoolsJson";
 import type { DepEdge, DepEdgeKind, DepNode, DepNodeKind, DepsData } from "./types";
 
 export interface DepsSerializerContext {
@@ -193,9 +192,7 @@ export class DepsSerializer {
       detail: {
         local: Boolean(injectInfo.local),
         isMap: Boolean(injectInfo.isMap),
-        ...(injectInfo.cacheOption?.expireAt !== undefined
-          ? { expireAt: DevtoolsJson.toSafe(injectInfo.cacheOption.expireAt) }
-          : {}),
+        ...(injectInfo.ttl !== undefined ? { ttl: injectInfo.ttl } : {}),
       },
     };
   }

package/server/di/diLifecycle.ts

@@ -17,7 +17,7 @@ import { agentTurnConstant, agentTurnDocument } from "../../signal/agentTurn";
 import { Base, BaseEndpoint, BaseInternal } from "../../signal/base.signal";
 import type { Endpoint } from "../../signal/endpoint";
 import type { Internal } from "../../signal/internal";
-import { Cache, Logging, type MiddlewareCls, Timeout } from "../../signal/middleware";
+import { Logging, type MiddlewareCls, Timeout } from "../../signal/middleware";
 import type { ServerSignal, ServerSignalCls } from "../../signal/serverSignal";
 import { SignalRegistry } from "../../signal/signalRegistry";
 import type { AkanLib, DatabaseModule, ScalarModule, ServiceModule } from "../akanLib";
@@ -128,8 +128,6 @@ export class DiLifecycle {
     this.#middleware.set(Logging.refName, Logging);
 
     this.#middleware.set(Timeout.refName, Timeout);
-
-    this.#middleware.set(Cache.refName, Cache);
     const defaultOption = createDefaultAkanOption();
     defaultOption.getMiddlewares().forEach((middleware) => {
       this.#middleware.set(middleware.refName, middleware);

package/server/head.tsx

@@ -0,0 +1,60 @@
+import type { Head, ResolvedHead, ResolveHeadResult } from "akanjs/client";
+import { AKAN_RSC_HEAD_SNAPSHOT_VERSION, type AkanHeadSnapshotV1 } from "./routeState";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export function createAkanLocaleAlternateHeadSnapshot(languages: Record<string, string>): AkanHeadSnapshotV1 {
+  return {
+    version: AKAN_RSC_HEAD_SNAPSHOT_VERSION,
+    nodes: Object.entries(languages).map(([lang, href]) => ({
+      tag: "link",
+      attrs: { rel: "alternate", hrefLang: lang, href },
+    })),
+  };
+}
+
+export function mergeAkanHeadSnapshots(
+  ...snapshots: Array<AkanHeadSnapshotV1 | null | undefined>
+): AkanHeadSnapshotV1 | undefined {
+  const nodes = snapshots.flatMap((snapshot) => snapshot?.nodes ?? []);
+  return snapshots.some(Boolean) ? { version: AKAN_RSC_HEAD_SNAPSHOT_VERSION, nodes } : undefined;
+}
+
+export function renderAkanHeadSnapshot(snapshot: AkanHeadSnapshotV1): Head {
+  return (
+    <>
+      {snapshot.nodes.map((node, index) => {
+        const marker = {
+          "data-akan-head": "route",
+          "data-akan-head-key": `${node.tag}:${index}`,
+        };
+        if (node.tag === "title") {
+          return (
+            <title key={`${node.tag}:${index}`} {...marker}>
+              {node.text ?? ""}
+            </title>
+          );
+        }
+        if (node.tag === "meta") {
+          return <meta key={`${node.tag}:${index}`} {...node.attrs} {...marker} />;
+        }
+        return <link key={`${node.tag}:${index}`} {...node.attrs} {...marker} />;
+      })}
+    </>
+  );
+}
+
+export function shouldRenderLocaleAlternates(options: { isSpecialRoute?: boolean }): boolean {
+  return options.isSpecialRoute !== true;
+}
+
+export function isResolvedHead(value: unknown): value is ResolvedHead {
+  return isRecord(value) && "node" in value;
+}
+
+export function resolveHeadResult(value: ResolveHeadResult): ResolvedHead {
+  if (isResolvedHead(value)) return value;
+  return { node: value };
+}

package/server/imageOptimizer.ts

@@ -61,6 +61,7 @@ export class ImageOptimizer {
   static readonly #avif = "image/avif";
   static readonly #heic = "image/heic";
   static readonly #bypassTypes = new Set(["image/x-icon", "image/x-icns", "image/bmp", "image/jxl", "image/heic"]);
+  static readonly #encodableTypes = new Set(["image/jpeg", "image/png", "image/webp", "image/avif"]);
 
   #publicDir: string;
   #cacheDir: string;
@@ -329,6 +330,7 @@ export class ImageOptimizer {
       shouldBypass || !params.outputType || inputType === ImageOptimizer.#webp || inputType === ImageOptimizer.#avif
         ? inputType
         : params.outputType;
+    const shouldEncode = !shouldBypass && ImageOptimizer.#encodableTypes.has(outputType);
     const cachePath = this.#getCachePath({
       href: params.href,
       width: params.width,
@@ -351,7 +353,7 @@ export class ImageOptimizer {
     let buffer = source.buffer;
     let contentType = inputType;
     let cacheable = true;
-    if (!shouldBypass) {
+    if (shouldEncode) {
       try {
         buffer = await this.#semaphore.run(() =>
           ImageOptimizer.#optimize(source.buffer, {

package/server/resolver/database.resolver.ts

@@ -155,37 +155,40 @@ export class DatabaseResolver {
         });
         Object.entries(getLoaderInfos(database.model)).forEach(([key, loaderInfo]) => {
           Object.assign(this, {
-            [key]: new DataLoader<any, any>(async (keys) => {
-              traceDataLoaderBatch(keys.length);
-              if (loaderInfo.type === "query") {
-                const fields = loaderInfo.field as string[];
-                const query = { kind: "any", queries: keys } as QueryOf<unknown>;
+            [key]: new DataLoader<any, any>(
+              async (keys) => {
+                traceDataLoaderBatch(keys.length);
+                if (loaderInfo.type === "query") {
+                  const fields = loaderInfo.field as string[];
+                  const query = { kind: "any", queries: keys } as QueryOf<unknown>;
+                  const docs = await timedQuery(() =>
+                    this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
+                  );
+                  const byKey = new Map(docs.map((doc) => [fields.map((field) => String(doc[field])).join(""), doc]));
+                  return keys.map(
+                    (queryKey) => byKey.get(fields.map((field) => String(queryKey[field])).join("")) ?? null,
+                  );
+                }
+                const field = loaderInfo.field as string;
+                const query = {
+                  [field]: documentQueryHelper.oneOf([...keys]),
+                };
                 const docs = await timedQuery(() =>
                   this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
                 );
-                const byKey = new Map(docs.map((doc) => [fields.map((field) => String(doc[field])).join(""), doc]));
-                return keys.map(
-                  (queryKey) => byKey.get(fields.map((field) => String(queryKey[field])).join("")) ?? null,
-                );
-              }
-              const field = loaderInfo.field as string;
-              const query = {
-                [field]: documentQueryHelper.oneOf([...keys]),
-              };
-              const docs = await timedQuery(() =>
-                this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
-              );
-              if (loaderInfo.type === "arrayField") {
-                const byKey = new Map<string, unknown>();
-                for (const doc of docs) {
-                  const values = Array.isArray(doc[field]) ? doc[field] : [];
-                  for (const value of values) if (!byKey.has(String(value))) byKey.set(String(value), doc);
+                if (loaderInfo.type === "arrayField") {
+                  const byKey = new Map<string, unknown>();
+                  for (const doc of docs) {
+                    const values = Array.isArray(doc[field]) ? doc[field] : [];
+                    for (const value of values) if (!byKey.has(String(value))) byKey.set(String(value), doc);
+                  }
+                  return keys.map((key) => byKey.get(String(key)) ?? null);
                 }
+                const byKey = new Map(docs.map((doc) => [String(doc[field]), doc]));
                 return keys.map((key) => byKey.get(String(key)) ?? null);
-              }
-              const byKey = new Map(docs.map((doc) => [String(doc[field]), doc]));
-              return keys.map((key) => byKey.get(String(key)) ?? null);
-            }),
+              },
+              { name: key, cache: loaderInfo.cache },
+            ),
           });
         });
       }

package/server/routeElementComposer.tsx

@@ -10,7 +10,7 @@ import type {
 } from "akanjs/client";
 import { Children, cloneElement, isValidElement, type ReactElement, type ReactNode, Suspense } from "react";
 import { getExplicitPageConfigKeys, resolvePageState } from "../client/frameConfig";
-import { resolveHeadResult } from "./metadata";
+import { resolveHeadResult } from "./head";
 import { type AkanRouteSegmentState, createAkanRouteSegments, createAkanSegmentOutletKey } from "./routeState";
 import { isAkanRscPartialCommitEnabled } from "./rscPartialCommit";
 import { AkanSegmentOutletReference } from "./rscSegmentOutletReference";
@@ -118,7 +118,7 @@ export class RouteElementComposer {
     searchParams: Record<string, string | string[]>;
   }): Promise<Head | null | undefined> {
     return (
-      await RouteElementComposer.resolveHeadWithMetadata({
+      await RouteElementComposer.resolveHeadWithSnapshot({
         pathRoute,
         params,
         searchParams,
@@ -126,7 +126,7 @@ export class RouteElementComposer {
     ).node;
   }
 
-  static async resolveHeadWithMetadata({
+  static async resolveHeadWithSnapshot({
     pathRoute,
     params,
     searchParams,

package/server/routeTreeBuilder.ts

@@ -26,7 +26,6 @@ import {
   type RouteModuleSource,
   resolveRouteModule,
 } from "../client/route/resolveRouteModule";
-import { resolveHeadExport, resolveMetadataHead } from "./metadata";
 
 type RouteModuleKindWithOverrides = "page" | "layout" | "overrides";
 
@@ -295,18 +294,6 @@ export class RouteTreeBuilder {
     if ("head" in mod && "generateHead" in mod) {
       throw new Error(`[route-convention] head and generateHead cannot both be exported in ${key}`);
     }
-    if (
-      !parsed.isInternalRootLayout &&
-      ("head" in mod || "generateHead" in mod) &&
-      ("metadata" in mod || "generateMetadata" in mod)
-    ) {
-      throw new Error(
-        `[route-convention] head/generateHead and metadata/generateMetadata cannot both be exported in ${key}`,
-      );
-    }
-    if ("metadata" in mod && "generateMetadata" in mod) {
-      throw new Error(`[route-convention] metadata and generateMetadata cannot both be exported in ${key}`);
-    }
   }
 
   static #makeRouteRender(key: string, kind: "page" | "layout", loader: () => Promise<RouteModuleSource>): RouteRender {
@@ -336,17 +323,7 @@ export class RouteTreeBuilder {
           routeRender.NotFound = layoutMod.NotFound;
           routeRender.Error = layoutMod.Error;
         }
-        if (mod.generateHead) {
-          const head = await mod.generateHead(props);
-          if (head !== null && head !== undefined) return resolveHeadExport(head, { includeHeadSnapshot: false });
-        }
-        if (mod.generateMetadata) {
-          const metadata = await mod.generateMetadata(props);
-          return metadata === null || metadata === undefined ? metadata : resolveMetadataHead(metadata);
-        }
-        if (mod.head !== undefined)
-          return mod.head === null ? null : resolveHeadExport(mod.head, { includeHeadSnapshot: false });
-        return mod.metadata === undefined ? undefined : resolveMetadataHead(mod.metadata);
+        return mod.generateHead ? await mod.generateHead(props) : mod.head;
       },
     };
     if (kind === "page") {

package/server/rscWorker.tsx

@@ -36,13 +36,13 @@ import {
   resolveRouteCacheStoreTtl,
   shouldStoreRouteCache,
 } from "./cachePolicy";
-import { LogForwarder } from "./logging/logForwarder";
 import {
   createAkanLocaleAlternateHeadSnapshot,
   mergeAkanHeadSnapshots,
   renderAkanHeadSnapshot,
   shouldRenderLocaleAlternates,
-} from "./metadata";
+} from "./head";
+import { LogForwarder } from "./logging/logForwarder";
 import { ProcessMetricsCollector } from "./processMetricsCollector";
 import { RouteElementComposer } from "./routeElementComposer";
 import {
@@ -1311,15 +1311,13 @@ export class RscRenderer {
     if (!body) return null;
     const routeHead =
       "resolveHead" in route
-        ? await RouteElementComposer.resolveHeadWithMetadata({
+        ? await RouteElementComposer.resolveHeadWithSnapshot({
             pathRoute: route,
             params,
             searchParams,
           })
-        : { node: undefined, hasExplicitLanguageAlternates: false };
-    const routeHeadSnapshot = this.#createRouteHeadSnapshot(url, routeHead, {
-      hasExplicitLanguageAlternates: routeHead.hasExplicitLanguageAlternates,
-    });
+        : { node: undefined };
+    const routeHeadSnapshot = this.#createRouteHeadSnapshot(url, routeHead, {});
     return (
       <html lang={params.lang ?? RscRenderer.#getLocale(pathname, this.#i18n)} suppressHydrationWarning>
         <head key="head">
@@ -1329,10 +1327,7 @@ export class RscRenderer {
           {routeHeadSnapshot
             ? renderAkanHeadSnapshot(routeHeadSnapshot)
             : (routeHead.node ?? this.#renderDefaultHead())}
-          {!routeHeadSnapshot &&
-          shouldRenderLocaleAlternates({ hasExplicitLanguageAlternates: routeHead.hasExplicitLanguageAlternates })
-            ? this.#renderLocaleAlternates(url)
-            : null}
+          {routeHeadSnapshot ? null : this.#renderLocaleAlternates(url)}
           {this.#renderStylesheet(pathname)}
         </head>
         <body key="body">{body}</body>
@@ -1353,14 +1348,13 @@ export class RscRenderer {
       basePath: this.#getBasePath(url),
     });
     setRequestFrameState(pathRoute.pageState);
-    const routeHead = await RouteElementComposer.resolveHeadWithMetadata({
+    const routeHead = await RouteElementComposer.resolveHeadWithSnapshot({
       pathRoute,
       params: match.params,
       searchParams,
     });
     const routeHeadSnapshot = this.#createRouteHeadSnapshot(url, routeHead, {
       isSpecialRoute: pathRoute.isSpecialRoute,
-      hasExplicitLanguageAlternates: routeHead.hasExplicitLanguageAlternates,
     });
     const body = RouteElementComposer.compose({
       pathRoute,
@@ -1377,11 +1371,7 @@ export class RscRenderer {
           {routeHeadSnapshot
             ? renderAkanHeadSnapshot(routeHeadSnapshot)
             : (routeHead.node ?? this.#renderDefaultHead())}
-          {!routeHeadSnapshot &&
-          shouldRenderLocaleAlternates({
-            isSpecialRoute: pathRoute.isSpecialRoute,
-            hasExplicitLanguageAlternates: routeHead.hasExplicitLanguageAlternates,
-          })
+          {!routeHeadSnapshot && shouldRenderLocaleAlternates({ isSpecialRoute: pathRoute.isSpecialRoute })
             ? this.#renderLocaleAlternates(url)
             : null}
           {this.#renderStylesheet(url.pathname)}
@@ -1470,21 +1460,20 @@ export class RscRenderer {
     match: { pathRoute: PathRoute; params: Record<string, string> },
     searchParams: Record<string, string | string[]>,
   ): Promise<ResolvedHead["headSnapshot"]> {
-    const routeHead = await RouteElementComposer.resolveHeadWithMetadata({
+    const routeHead = await RouteElementComposer.resolveHeadWithSnapshot({
       pathRoute: match.pathRoute,
       params: match.params,
       searchParams,
     });
     return this.#createRouteHeadSnapshot(url, routeHead, {
       isSpecialRoute: match.pathRoute.isSpecialRoute,
-      hasExplicitLanguageAlternates: routeHead.hasExplicitLanguageAlternates,
     });
   }
 
   #createRouteHeadSnapshot(
     url: URL,
     routeHead: ResolvedHead,
-    options: { isSpecialRoute?: boolean; hasExplicitLanguageAlternates?: boolean },
+    options: { isSpecialRoute?: boolean },
   ): ResolvedHead["headSnapshot"] {
     if (!routeHead.headSnapshot) return undefined;
     return mergeAkanHeadSnapshots(

package/server/webRouter.ts

@@ -1209,18 +1209,22 @@ export class WebRouter {
       if (details.length === 0) return null;
       return WebRouter.#jsonResponse({ applinks: { apps: [], details } }, cacheControl);
     }
+    
+    const packageSuffixes = process.env.AKAN_PUBLIC_ENV === "main" ? [""] : ["", ".debug"];
     const assetLinks = associations
       .filter(
         (association) => association.domains.length > 0 && (association.androidSha256CertFingerprints?.length ?? 0) > 0,
       )
-      .map((association) => ({
-        relation: ["delegate_permission/common.handle_all_urls"],
-        target: {
-          namespace: "android_app",
-          package_name: association.appId,
-          sha256_cert_fingerprints: association.androidSha256CertFingerprints,
-        },
-      }));
+      .flatMap((association) =>
+        packageSuffixes.map((suffix) => ({
+          relation: ["delegate_permission/common.handle_all_urls"],
+          target: {
+            namespace: "android_app",
+            package_name: `${association.appId}${suffix}`,
+            sha256_cert_fingerprints: association.androidSha256CertFingerprints,
+          },
+        })),
+      );
     if (assetLinks.length === 0) return null;
     return WebRouter.#jsonResponse(assetLinks, cacheControl);
   }