@akanjs/cli 2.3.9-rc.9 → 2.3.10-rc.0

package/incrementalBuilder.proc.js

@@ -2,7 +2,7 @@
 var __require = import.meta.require;
 
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
-import path42 from "path";
+import path44 from "path";
 
 // pkgs/@akanjs/devkit/aiEditor.ts
 import { input, select } from "@inquirer/prompts";
@@ -744,6 +744,44 @@ var DEFAULT_AKAN_IMAGE_CONFIG = {
   fetchTimeoutMs: 7000,
   maxRemoteBytes: 25 * 1024 * 1024
 };
+var normalizeIndexPath = (indexPath) => {
+  const normalized = indexPath?.trim();
+  if (!normalized)
+    return;
+  const path2 = `/${normalized.replace(/^\/+|\/+$/g, "")}`;
+  return path2 === "/" ? "/" : path2;
+};
+var normalizeStringList = (values) => {
+  const normalized = values?.map((value) => value.trim()).filter(Boolean) ?? [];
+  return normalized.length > 0 ? [...new Set(normalized)] : undefined;
+};
+var normalizeDeepLinkDomain = (domain) => {
+  const normalized = domain.trim();
+  if (!normalized)
+    return "";
+  try {
+    const url = new URL(normalized.includes("://") ? normalized : `https://${normalized}`);
+    return url.host.toLowerCase();
+  } catch {
+    return normalized.replace(/^https?:\/\//, "").replace(/\/+$/g, "").toLowerCase();
+  }
+};
+var normalizeDeepLinks = (deepLinks) => {
+  if (!deepLinks)
+    return;
+  const schemes = normalizeStringList(deepLinks.schemes);
+  const domains = normalizeStringList(deepLinks.domains?.map(normalizeDeepLinkDomain));
+  const teamId = deepLinks.ios?.teamId?.trim();
+  const sha256CertFingerprints = normalizeStringList(deepLinks.android?.sha256CertFingerprints);
+  if (!schemes && !domains && !teamId && !sha256CertFingerprints)
+    return;
+  return {
+    ...schemes ? { schemes } : {},
+    ...domains ? { domains } : {},
+    ...teamId ? { ios: { teamId } } : {},
+    ...sha256CertFingerprints ? { android: { sha256CertFingerprints } } : {}
+  };
+};
 
 class AkanAppConfig {
   app;
@@ -757,6 +795,7 @@ class AkanAppConfig {
   i18n;
   publicEnv;
   mobile;
+  secrets;
   baseDevEnv;
   libs;
   domains = new Set;
@@ -783,11 +822,16 @@ class AkanAppConfig {
     process.env.AKAN_PUBLIC_DEFAULT_LOCALE = this.i18n.defaultLocale;
     process.env.AKAN_PUBLIC_LOCALES = this.i18n.locales.join(",");
     this.publicEnv = config?.publicEnv ?? [];
+    this.secrets = config?.secrets ?? [];
     this.mobile = this.#resolveMobileConfig(config.mobile);
     this.docker = this.#makeDockerContent(config?.docker ?? {});
   }
   #resolveMobileConfig(mobile) {
-    const { targets: rawTargets, ...rawMobile } = mobile ?? {};
+    const {
+      targets: rawTargets,
+      indexPath: _indexPath,
+      ...rawMobile
+    } = mobile ?? {};
     const appName = rawMobile.appName ?? this.app.name;
     const appId = rawMobile.appId ?? `com.${this.app.name}.app`;
     const version = rawMobile.version ?? "0.0.1";
@@ -800,6 +844,8 @@ class AkanAppConfig {
       const target = rawTarget;
       const fallbackBasePath = !rawTargets && this.basePaths.has(name) ? name : undefined;
       const basePath2 = (target.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
+      const indexPath = normalizeIndexPath(target.indexPath);
+      const deepLinks = normalizeDeepLinks(target.deepLinks);
       if (basePath2 && !this.basePaths.has(basePath2)) {
         throw new Error(`Mobile target '${name}' uses unknown basePath '${basePath2}' in apps/${this.app.name}/akan.config.ts`);
       }
@@ -808,6 +854,8 @@ class AkanAppConfig {
         ...target,
         name,
         basePath: basePath2,
+        indexPath,
+        deepLinks,
         appName: target.appName ?? appName,
         appId: target.appId ?? appId,
         version: target.version ?? version,
@@ -12116,7 +12164,14 @@ class SsrBaseArtifactBuilder {
       basePaths: [...akanConfig2.basePaths],
       branches: [...akanConfig2.branches],
       i18n: akanConfig2.i18n,
-      imageConfig: akanConfig2.images
+      imageConfig: akanConfig2.images,
+      deepLinkAssociations: Object.values(akanConfig2.mobile.targets).filter((target) => (target.deepLinks?.domains?.length ?? 0) > 0).map((target) => ({
+        targetName: target.name,
+        appId: target.appId,
+        domains: target.deepLinks?.domains ?? [],
+        iosTeamId: target.deepLinks?.ios?.teamId,
+        androidSha256CertFingerprints: target.deepLinks?.android?.sha256CertFingerprints
+      }))
     };
     await Bun.write(path35.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
 `);
@@ -12504,6 +12559,7 @@ void run().catch((error) => {
 }
 // pkgs/@akanjs/devkit/applicationReleasePackager.ts
 import { cp, mkdir as mkdir9, rm as rm4 } from "fs/promises";
+import path38 from "path";
 
 // pkgs/@akanjs/devkit/uploadRelease.ts
 import { HttpClient as HttpClient2, Logger as Logger9 } from "akanjs/common";
@@ -12619,13 +12675,9 @@ class ApplicationReleasePackager {
     await cp(`${this.#app.dist.cwdPath}/backend`, `${buildPath}/backend`, { recursive: true });
     await cp(this.#app.dist.cwdPath, buildRoot, { recursive: true });
     await rm4(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
-    await this.#app.workspace.spawn("tar", [
-      "-zcf",
-      `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}-release.tar.gz`,
-      "-C",
-      buildRoot,
-      "./"
-    ]);
+    const releaseRoot = this.#app.workspace.workspaceRoot;
+    const releaseArchivePath = path38.relative(releaseRoot, `${releaseRoot}/releases/builds/${this.#app.name}-release.tar.gz`).split(path38.sep).join("/");
+    await this.#app.workspace.spawn("tar", ["-zcf", releaseArchivePath, "-C", buildRoot, "./"], { cwd: releaseRoot });
     await this.#writeCsrZipIfPresent();
     return { platformVersion };
   }
@@ -12646,22 +12698,18 @@ class ApplicationReleasePackager {
     await cp(this.#app.dist.cwdPath, `${sourceRoot}/apps/${this.#app.name}`, { recursive: true });
     const libDeps = ["social", "shared", "platform", "util"];
     await Promise.all(libDeps.map((lib) => cp(`${this.#app.workspace.cwdPath}/libs/${lib}`, `${sourceRoot}/libs/${lib}`, { recursive: true })));
-    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path38) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path38}`;
+    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path39) => {
+      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path39}`;
       if (await FileSys.dirExists(targetPath))
         await rm4(targetPath, { recursive: true, force: true });
     }));
     const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path38) => cp(`${this.#app.workspace.cwdPath}/${path38}`, `${sourceRoot}/${path38}`, { recursive: true })));
+    await Promise.all(syncPaths.map((path39) => cp(`${this.#app.workspace.cwdPath}/${path39}`, `${sourceRoot}/${path39}`, { recursive: true })));
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
-    await this.#app.workspace.spawn("tar", [
-      "-zcf",
-      `${this.#app.workspace.cwdPath}/releases/sources/${this.#app.name}-source.tar.gz`,
-      "-C",
-      sourceRoot,
-      "./"
-    ]);
+    const sourceCwd = this.#app.workspace.cwdPath;
+    const sourceArchivePath = path38.relative(sourceCwd, `${sourceCwd}/releases/sources/${this.#app.name}-source.tar.gz`).split(path38.sep).join("/");
+    await this.#app.workspace.spawn("tar", ["-zcf", sourceArchivePath, "-C", sourceRoot, "./"], { cwd: sourceCwd });
   }
   async#resetSourceRoot(sourceRoot) {
     if (await FileSys.dirExists(sourceRoot)) {
@@ -12743,20 +12791,20 @@ class ApplicationReleasePackager {
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path38 from "path";
+import path39 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath2) => {
     try {
-      candidates.push(path38.join(path38.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path39.join(path39.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path38.dirname(Bun.main));
+  addResolvedPackageCandidate(path39.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path38.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(path38.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  candidates.push(path39.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(path39.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   for (const candidate of [...new Set(candidates)]) {
     if (await Bun.file(candidate).exists())
       return candidate;
@@ -12766,7 +12814,7 @@ async function resolveSignalTestPreloadPath(target) {
 // pkgs/@akanjs/devkit/builder.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir10 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 var SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
 var assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
 var assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file"]));
@@ -12783,14 +12831,14 @@ class Builder {
   #globEntrypoints(cwd, pattern) {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path39.sep);
+      const segments = relativePath.split(path40.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    }).map((rel) => path39.join(cwd, rel));
+    }).map((rel) => path40.join(cwd, rel));
   }
   #globFiles(cwd, pattern = "**/*.*") {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path39.sep);
+      const segments = relativePath.split(path40.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
     });
   }
@@ -12798,17 +12846,17 @@ class Builder {
     const out = [];
     for (const p of additionalEntryPoints) {
       if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path39.sep}`) ? p.slice(cwd.length + 1) : p;
+        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path40.sep}`) ? p.slice(cwd.length + 1) : p;
         out.push(...this.#globEntrypoints(cwd, rel));
       } else
-        out.push(path39.isAbsolute(p) ? p : path39.join(cwd, p));
+        out.push(path40.isAbsolute(p) ? p : path40.join(cwd, p));
     }
     return out;
   }
   #getBuildOptions({ bundle = false, additionalEntryPoints = [] } = {}) {
     const cwd = this.#executor.cwdPath;
     const entrypoints = [
-      ...bundle ? [path39.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
+      ...bundle ? [path40.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
       ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints)
     ];
     return {
@@ -12829,9 +12877,9 @@ class Builder {
     for (const relativePath of this.#globFiles(cwd)) {
       if (relativePath === "package.json")
         continue;
-      const sourcePath = path39.join(cwd, relativePath);
-      const targetPath = path39.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir10(path39.dirname(targetPath), { recursive: true });
+      const sourcePath = path40.join(cwd, relativePath);
+      const targetPath = path40.join(this.#distExecutor.cwdPath, relativePath);
+      await mkdir10(path40.dirname(targetPath), { recursive: true });
       await Bun.write(targetPath, Bun.file(sourcePath));
     }
   }
@@ -12842,13 +12890,13 @@ class Builder {
       return withoutFormatDir;
     if (!hasDotSlash && withoutFormatDir === publishedPath)
       return publishedPath;
-    const parsed = path39.posix.parse(withoutFormatDir);
+    const parsed = path40.posix.parse(withoutFormatDir);
     if (![".js", ".mjs", ".cjs"].includes(parsed.ext))
       return withoutFormatDir;
-    const withoutExt = path39.posix.join(parsed.dir, parsed.name);
+    const withoutExt = path40.posix.join(parsed.dir, parsed.name);
     const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
     const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path39.join(this.#executor.cwdPath, candidate)));
+    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path40.join(this.#executor.cwdPath, candidate)));
     if (!matchedSource)
       return withoutFormatDir;
     return hasDotSlash ? `./${matchedSource}` : matchedSource;
@@ -12897,9 +12945,9 @@ class Builder {
   }
 }
 // pkgs/@akanjs/devkit/capacitorApp.ts
-import { cp as cp2, mkdir as mkdir11, rm as rm5 } from "fs/promises";
+import { cp as cp2, mkdir as mkdir11, readFile as readFile2, rm as rm5, writeFile as writeFile2 } from "fs/promises";
 import os from "os";
-import path40 from "path";
+import path41 from "path";
 import { select as select2 } from "@inquirer/prompts";
 import { MobileProject } from "@trapezedev/project";
 import { capitalize as capitalize5 } from "akanjs/common";
@@ -13106,13 +13154,13 @@ var rootCapacitorConfigFilenames = [
   "capacitor.config.js",
   "capacitor.config.json"
 ];
-var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path40.join(appRoot, file));
+var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path41.join(appRoot, file));
 async function clearRootCapacitorConfigs(appRoot) {
   await Promise.all(rootCapacitorConfigPaths(appRoot).map((file) => rm5(file, { force: true })));
 }
 async function writeRootCapacitorConfig(appRoot, content) {
   await clearRootCapacitorConfigs(appRoot);
-  await Bun.write(path40.join(appRoot, "capacitor.config.json"), content);
+  await Bun.write(path41.join(appRoot, "capacitor.config.json"), content);
 }
 var getLocalIP = () => {
   const interfaces = os.networkInterfaces();
@@ -13221,13 +13269,13 @@ function buildIosNativeRunCommand({
   scheme = "App",
   configuration = "Debug"
 }) {
-  const derivedDataPath = path40.join(appRoot, "ios/DerivedData", device.id);
+  const derivedDataPath = path41.join(appRoot, "ios/DerivedData", device.id);
   const productPlatform = device.kind === "device" ? "iphoneos" : "iphonesimulator";
   const destination = device.kind === "device" ? `id=${device.xcodebuildId ?? device.id}` : `platform=iOS Simulator,id=${device.id}`;
   return {
     configuration,
     derivedDataPath,
-    appPath: path40.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
+    appPath: path41.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
     xcodebuildArgs: [
       "-project",
       "App.xcodeproj",
@@ -13411,11 +13459,12 @@ function materializeCapacitorConfig(target, { operation, localServerUrl, localIp
   const {
     name,
     basePath: _basePath,
+    indexPath: _indexPath,
     version: _version,
     buildNum: _buildNum,
     assets: _assets,
     permissions: _permissions,
-    links: _links,
+    deepLinks: _deepLinks,
     files: _files,
     appId,
     appName,
@@ -13437,7 +13486,7 @@ function materializeCapacitorConfig(target, { operation, localServerUrl, localIp
     ...capacitorConfig,
     appId,
     appName,
-    webDir: path40.posix.join(".akan", "mobile", name, "www"),
+    webDir: path41.posix.join(".akan", "mobile", name, "www"),
     plugins: {
       CapacitorCookies: { enabled: true },
       ...pluginsConfig,
@@ -13494,10 +13543,10 @@ class CapacitorApp {
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRootPath = path40.posix.join(".akan", "mobile", this.target.name);
-    this.targetRoot = path40.join(this.app.cwdPath, this.targetRootPath);
-    this.targetWebRoot = path40.join(this.targetRoot, "www");
-    this.targetAssetRoot = path40.join(this.targetRoot, "assets");
+    this.targetRootPath = path41.posix.join(".akan", "mobile", this.target.name);
+    this.targetRoot = path41.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path41.join(this.targetRoot, "www");
+    this.targetAssetRoot = path41.join(this.targetRoot, "assets");
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: this.androidRootPath },
       ios: { path: this.iosProjectPath }
@@ -13512,9 +13561,9 @@ class CapacitorApp {
     await mkdir11(this.targetRoot, { recursive: true });
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm5(path40.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+        await rm5(path41.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm5(path40.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+        await rm5(path41.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
@@ -13537,7 +13586,7 @@ class CapacitorApp {
     await this.#prepareExternalFiles("ios");
     await this.#applyIosMetadata();
     await this.#applyPermissions();
-    await this.#applyLinks();
+    await this.#applyDeepLinks("ios", { operation, env });
     await this.project.commit();
     await this.#generateAssets({ operation, env });
     this.app.verbose(`syncing iOS`);
@@ -13637,7 +13686,7 @@ ${textError instanceof Error ? textError.message : ""}`);
     const xcodebuildArgs = noAllowProvisioningUpdates ? command.xcodebuildArgs : [...command.xcodebuildArgs.slice(0, -1), "-allowProvisioningUpdates", ...command.xcodebuildArgs.slice(-1)];
     try {
       await this.#spawn("xcodebuild", xcodebuildArgs, {
-        cwd: path40.join(this.app.cwdPath, this.iosProjectPath),
+        cwd: path41.join(this.app.cwdPath, this.iosProjectPath),
         env: mobileEnv
       });
       const devicectlId = runTarget.devicectlId ?? runTarget.id;
@@ -13662,7 +13711,7 @@ ${textError instanceof Error ? textError.message : ""}`);
     return isRecord2(this.target.ios) && typeof this.target.ios.scheme === "string" ? this.target.ios.scheme : "App";
   }
   async#getIosDevelopmentTeam() {
-    const pbxprojPath = path40.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
+    const pbxprojPath = path41.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
     if (!await Bun.file(pbxprojPath).exists())
       return;
     return (await Bun.file(pbxprojPath).text()).match(/DEVELOPMENT_TEAM = ([^;]+);/)?.[1]?.trim();
@@ -13680,15 +13729,16 @@ ${error.message}`;
     await this.#prepareExternalFiles("android");
     await this.#applyAndroidMetadata();
     await this.#applyPermissions();
-    await this.#applyLinks();
+    await this.#applyDeepLinks("android", { operation, env });
     await this.project.commit();
     await this.#generateAssets({ operation, env });
     await this.#ensureAndroidAssetsDir();
     await this.#ensureAndroidDebugKeystore();
     await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
+    await this.#setDeepLinksInAndroid(this.target.deepLinks?.schemes ?? [], this.target.deepLinks?.domains ?? []);
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(path40.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const appGradle = await FileEditor.create(path41.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -13732,7 +13782,7 @@ ${error.message}`;
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: path40.join(this.app.cwdPath, this.androidRootPath),
+      cwd: path41.join(this.app.cwdPath, this.androidRootPath),
       env: await this.#commandEnv("release", env)
     });
   }
@@ -13740,10 +13790,10 @@ ${error.message}`;
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async#ensureAndroidAssetsDir() {
-    await mkdir11(path40.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
+    await mkdir11(path41.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
   async#ensureAndroidDebugKeystore() {
-    const keystorePath = path40.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
+    const keystorePath = path41.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
     if (await Bun.file(keystorePath).exists())
       return;
     await this.#spawn("keytool", [
@@ -13782,7 +13832,7 @@ ${error.message}`;
     await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
   async#assertAndroidReleaseSigningConfig() {
-    const gradlePropertiesPath = path40.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
+    const gradlePropertiesPath = path41.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
     const gradleProperties = await Bun.file(gradlePropertiesPath).exists() ? await Bun.file(gradlePropertiesPath).text() : "";
     const missingKeys = getMissingAndroidReleaseSigningKeys({ gradleProperties });
     if (missingKeys.length > 0)
@@ -13809,16 +13859,20 @@ ${error.message}`;
     await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
-    const htmlSource = path40.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    const htmlSource = path41.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!await Bun.file(htmlSource).exists())
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
     await rm5(this.targetWebRoot, { recursive: true, force: true });
     await mkdir11(this.targetWebRoot, { recursive: true });
-    await Bun.write(path40.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await Bun.write(path41.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
-    const script = `<script>window.__AKAN_MOBILE_TARGET__=${JSON.stringify({ name: this.target.name, basePath: basePath2 })};</script>`;
+    const script = `<script>window.__AKAN_MOBILE_TARGET__=${JSON.stringify({
+      name: this.target.name,
+      basePath: basePath2,
+      indexPath: this.target.indexPath
+    })};</script>`;
     if (html.includes("window.__AKAN_MOBILE_TARGET__"))
       return html;
     return html.replace(/<\/head\s*>/i, `${script}
@@ -13834,7 +13888,7 @@ ${error.message}`;
     });
     const content = `${JSON.stringify(config, null, 2)}
 `;
-    await Bun.write(path40.join(this.targetRoot, "capacitor.config.json"), content);
+    await Bun.write(path41.join(this.targetRoot, "capacitor.config.json"), content);
     return content;
   }
   async#prepareTargetAssets() {
@@ -13842,11 +13896,11 @@ ${error.message}`;
       return;
     await mkdir11(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path40.join(this.app.cwdPath, this.target.assets.icon), path40.join(this.targetAssetRoot, "icon.png"), {
+      await cp2(path41.join(this.app.cwdPath, this.target.assets.icon), path41.join(this.targetAssetRoot, "icon.png"), {
         force: true
       });
     if (this.target.assets.splash)
-      await cp2(path40.join(this.app.cwdPath, this.target.assets.splash), path40.join(this.targetAssetRoot, "splash.png"), {
+      await cp2(path41.join(this.app.cwdPath, this.target.assets.splash), path41.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -13854,11 +13908,11 @@ ${error.message}`;
     const files = this.target.files?.[platform];
     if (!files)
       return;
-    const platformRoot = path40.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    const platformRoot = path41.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path40.join(platformRoot, to);
-      await mkdir11(path40.dirname(targetPath), { recursive: true });
-      await cp2(path40.join(this.app.cwdPath, from), targetPath, { force: true });
+      const targetPath = path41.join(platformRoot, to);
+      await mkdir11(path41.dirname(targetPath), { recursive: true });
+      await cp2(path41.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
   async#generateAssets({ operation, env }) {
@@ -13868,7 +13922,7 @@ ${error.message}`;
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path40.posix.join(this.targetRootPath, "assets"),
+      path41.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -13901,25 +13955,48 @@ ${error.message}`;
         await this.addPush();
     }
   }
-  async#applyLinks() {
-    const links = this.target.links;
-    if (!links)
+  async#applyDeepLinks(platform, { operation, env }) {
+    const deepLinks = this.target.deepLinks;
+    if (!deepLinks)
       return;
-    const schemes = links.schemes ?? [];
-    if (schemes.length > 0) {
-      await this.#setPermissionInIos({
-        appTransportSecurity: ""
-      });
+    const schemes = deepLinks.schemes ?? [];
+    const domains = deepLinks.domains ?? [];
+    if (domains.length > 0)
+      this.#assertDeepLinkVerificationConfig(platform, { operation, env });
+    if (platform === "ios") {
+      if (schemes.length > 0) {
+        await this.#setPermissionInIos({
+          appTransportSecurity: ""
+        });
+        await this.#setUrlSchemesInIos(schemes);
+      }
+      if (domains.length > 0)
+        await this.#setAssociatedDomainsInIos(domains);
+      return;
+    }
+    if (platform === "android") {
       for (const scheme of schemes) {
         this.project.android.getAndroidManifest().injectFragment("activity", `<intent-filter><action android:name="android.intent.action.VIEW" /><category android:name="android.intent.category.DEFAULT" /><category android:name="android.intent.category.BROWSABLE" /><data android:scheme="${scheme}" /></intent-filter>`);
       }
+      for (const domain of domains) {
+        const pathPrefix = resolveMobilePath(this.target, "/");
+        this.project.android.getAndroidManifest().injectFragment("activity", `<intent-filter android:autoVerify="true"><action android:name="android.intent.action.VIEW" /><category android:name="android.intent.category.DEFAULT" /><category android:name="android.intent.category.BROWSABLE" /><data android:scheme="https" android:host="${domain}" android:pathPrefix="${pathPrefix}" /></intent-filter>`);
+      }
+      await this.#setDeepLinksInAndroid(schemes, domains);
     }
-    for (const domain of links.associatedDomains ?? []) {
-      this.app.logger.info(`Configure iOS associated domain manually if needed: ${domain}`);
+  }
+  #assertDeepLinkVerificationConfig(platform, { operation, env }) {
+    const deepLinks = this.target.deepLinks;
+    if (!deepLinks?.domains?.length)
+      return;
+    if (platform === "ios" && !deepLinks.ios?.teamId) {
+      throw new Error(`Mobile target '${this.target.name}' uses deepLinks.domains but is missing deepLinks.ios.teamId in apps/${this.app.name}/akan.config.ts`);
     }
-    for (const host of links.androidHosts ?? []) {
-      const pathPrefix = resolveMobilePath(this.target, "/");
-      this.project.android.getAndroidManifest().injectFragment("activity", `<intent-filter android:autoVerify="true"><action android:name="android.intent.action.VIEW" /><category android:name="android.intent.category.DEFAULT" /><category android:name="android.intent.category.BROWSABLE" /><data android:scheme="https" android:host="${host}" android:pathPrefix="${pathPrefix}" /></intent-filter>`);
+    if (platform === "android" && !deepLinks.android?.sha256CertFingerprints?.length) {
+      const message = `Mobile target '${this.target.name}' uses deepLinks.domains but is missing deepLinks.android.sha256CertFingerprints in apps/${this.app.name}/akan.config.ts`;
+      if (operation === "release" || env === "main")
+        throw new Error(message);
+      this.app.logger.warn(message);
     }
   }
   async#commandEnv(operation, env) {
@@ -13940,6 +14017,8 @@ ${error.message}`;
     const params = new URLSearchParams({ csr: "true", akanMobileTarget: this.target.name });
     if (basePath2)
       params.set("akanMobileBasePath", basePath2);
+    if (this.target.indexPath)
+      params.set("akanMobileIndexPath", this.target.indexPath);
     return `http://${ip}:${port}/${pathname}?${params}`;
   }
   async#clearRootCapacitorConfigs() {
@@ -13999,6 +14078,112 @@ ${error.message}`;
       this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
     ]);
   }
+  async#setUrlSchemesInIos(schemes) {
+    const urlTypes = schemes.map((scheme) => ({
+      CFBundleURLName: this.target.appId,
+      CFBundleURLSchemes: [scheme]
+    }));
+    await Promise.all([
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", { CFBundleURLTypes: urlTypes }),
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Release", { CFBundleURLTypes: urlTypes })
+    ]);
+  }
+  async#setAssociatedDomainsInIos(domains) {
+    const entitlementsRelPath = "App/App.entitlements";
+    const entitlementsPath = path41.join(this.app.cwdPath, this.iosProjectPath, entitlementsRelPath);
+    const values = domains.map((domain) => `applinks:${domain}`);
+    const body = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+      '<plist version="1.0">',
+      "<dict>",
+      "  <key>com.apple.developer.associated-domains</key>",
+      "  <array>",
+      ...values.map((value) => `    <string>${value}</string>`),
+      "  </array>",
+      "</dict>",
+      "</plist>",
+      ""
+    ].join(`
+`);
+    await writeFile2(entitlementsPath, body);
+    await this.#setCodeSignEntitlementsInIos(entitlementsRelPath);
+  }
+  async#setCodeSignEntitlementsInIos(entitlementsRelPath) {
+    const pbxprojPath = path41.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
+    const lines = (await readFile2(pbxprojPath, "utf8")).split(`
+`);
+    let changed = false;
+    for (let index = 0;index < lines.length; index++) {
+      const line = lines[index] ?? "";
+      if (!line.includes(`PRODUCT_BUNDLE_IDENTIFIER = ${this.target.appId};`))
+        continue;
+      let start = index;
+      while (start >= 0 && !lines[start]?.includes("buildSettings = {"))
+        start--;
+      let end = index;
+      while (end < lines.length && !/^\s*\};\s*$/.test(lines[end] ?? ""))
+        end++;
+      const settings = lines.slice(start, end + 1);
+      if (settings.some((setting) => setting.includes("CODE_SIGN_ENTITLEMENTS")))
+        continue;
+      const indent = line.match(/^\s*/)?.[0] ?? "";
+      lines.splice(index, 0, `${indent}CODE_SIGN_ENTITLEMENTS = ${entitlementsRelPath};`);
+      index++;
+      changed = true;
+    }
+    if (changed)
+      await writeFile2(pbxprojPath, lines.join(`
+`));
+  }
+  async#setUrlSchemesInAndroid(schemes) {
+    const manifestPath = path41.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
+    let manifest = await readFile2(manifestPath, "utf8");
+    let changed = false;
+    for (const scheme of schemes) {
+      if (manifest.includes(`android:scheme="${scheme}"`))
+        continue;
+      const filter = [
+        "            <intent-filter>",
+        '                <action android:name="android.intent.action.VIEW" />',
+        '                <category android:name="android.intent.category.DEFAULT" />',
+        '                <category android:name="android.intent.category.BROWSABLE" />',
+        `                <data android:scheme="${scheme}" />`,
+        "            </intent-filter>"
+      ].join(`
+`);
+      manifest = manifest.replace(/(\s*<\/activity>)/, `
+${filter}$1`);
+      changed = true;
+    }
+    if (changed)
+      await writeFile2(manifestPath, manifest);
+  }
+  async#setDeepLinksInAndroid(schemes, domains) {
+    await this.#setUrlSchemesInAndroid(schemes);
+    const manifestPath = path41.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
+    let manifest = await readFile2(manifestPath, "utf8");
+    let changed = false;
+    const pathPrefix = resolveMobilePath(this.target, "/");
+    for (const domain of domains) {
+      if (manifest.includes(`android:host="${domain}"`) && manifest.includes('android:scheme="https"'))
+        continue;
+      const filter = [
+        '            <intent-filter android:autoVerify="true">',
+        '                <action android:name="android.intent.action.VIEW" />',
+        '                <category android:name="android.intent.category.DEFAULT" />',
+        '                <category android:name="android.intent.category.BROWSABLE" />',
+        `                <data android:scheme="https" android:host="${domain}" android:pathPrefix="${pathPrefix}" />`,
+        "            </intent-filter>"
+      ].join(`
+`);
+      manifest = manifest.replace(/(\s*<\/activity>)/, `
+${filter}$1`);
+      changed = true;
+    }
+    if (changed)
+      await writeFile2(manifestPath, manifest);
+  }
   #setFeaturesInAndroid(features) {
     for (const feature of features) {
       if (this.#hasFeatureInAndroid(feature)) {
@@ -14078,7 +14263,7 @@ var Pkg = createInternalArgToken("Pkg");
 var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path41 from "path";
+import path42 from "path";
 import { confirm, input as input2, select as select3 } from "@inquirer/prompts";
 import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
@@ -14582,7 +14767,7 @@ var runCommands = async (...commands) => {
     process.exit(1);
   });
   const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path41.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const packageJsonCandidates = [`${path42.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -14862,8 +15047,8 @@ var scanModuleSpecifiers = (source2, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts10.readConfigFile(tsConfigPath, (path42) => {
-    return ts10.sys.readFile(path42);
+  const configFile = ts10.readConfigFile(tsConfigPath, (path43) => {
+    return ts10.sys.readFile(path43);
   });
   return ts10.parseJsonConfigFileContent(configFile.config, ts10.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
@@ -15079,6 +15264,571 @@ ${document}
 `;
   }
 }
+// pkgs/@akanjs/devkit/qualityScanner.ts
+import { createHash } from "crypto";
+import { readdir as readdir3, readFile as readFile3, stat as stat4 } from "fs/promises";
+import path43 from "path";
+import ignore2 from "ignore";
+import ts11 from "typescript";
+var MAX_FILE_LINES = 2000;
+var PLACEHOLDER_EXPORT_NAMES = new Set([
+  "aa",
+  "dumb",
+  "dumb2",
+  "someBaseLogic",
+  "someCommonLogic",
+  "someFrontendLogic",
+  "someBackendLogic"
+]);
+var SUGGESTED_RULES = [
+  "Keep generated scanSync index files out of hand-written changes; generated indexes should only contain one-depth export statements.",
+  "Generated Akan index files should not contain placeholder exports such as aa, dumb, dumb2, or some*Logic.",
+  "Dictionary text should not contain scaffold wording, misspellings, or stale copied domain nouns.",
+  "Warn earlier on very long Akan files: 500 lines for services, 800 lines for Template/Zone files, and 1000 lines for Util files.",
+  "Global declarations, Window augmentation, and prototype mutation should stay in explicitly approved low-level integration files.",
+  "Keep app root folders small and conventional: application code belongs under common, env, lib, page, private, public, script, srvkit, ui, or webkit.",
+  "Keep apps/*/lib and libs/*/lib root files limited to generated support facets such as cnst.ts, db.ts, dict.ts, sig.ts, srv.ts, st.ts, useClient.ts, and useServer.ts.",
+  "Use domain module folders consistently: lib/<model> for database modules, lib/_<service> for service modules, and lib/__scalar/<scalar> for scalar modules.",
+  "Keep module UI filenames predictable: database modules use <Model>.Template/Unit/Util/View/Zone.tsx, service modules use <Service>.Util/Zone.tsx, and scalar modules use <Scalar>.Template/Unit.tsx.",
+  "Move shared app utilities to apps/*/common instead of creating apps/*/base.",
+  "Avoid large mixed-purpose class files; class export files should import helpers from neighboring utility files instead of declaring them inline."
+];
+var APP_ROOT_FILES = new Set([
+  "akan.app.json",
+  "akan.config.ts",
+  "capacitor.config.ts",
+  "client.ts",
+  "main.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json"
+]);
+var LIB_ROOT_FILES = new Set([
+  "cnst.ts",
+  "db.ts",
+  "dict.ts",
+  "option.ts",
+  "sig.ts",
+  "srv.ts",
+  "st.ts",
+  "useClient.ts",
+  "useServer.ts"
+]);
+var CONVENTION_SUFFIXES = [
+  ".constant.ts",
+  ".dictionary.ts",
+  ".document.ts",
+  ".service.ts",
+  ".signal.ts",
+  ".store.ts"
+];
+
+class AkanQualityScanner {
+  async scan(workspaceRoot) {
+    const targetFiles = await this.#collectTargetFiles(workspaceRoot);
+    const sourceFiles = await Promise.all(targetFiles.map((file) => this.#readSourceFile(workspaceRoot, file)));
+    const warnings = [
+      ...this.#scanGlobalQuality(sourceFiles),
+      ...sourceFiles.flatMap((sourceFile2) => this.#scanSingleFileQuality(sourceFile2)),
+      ...sourceFiles.flatMap((sourceFile2) => this.#scanConventionQuality(sourceFile2)),
+      ...sourceFiles.flatMap((sourceFile2) => this.#scanLayoutQuality(sourceFile2))
+    ];
+    return {
+      workspaceRoot,
+      scannedFiles: sourceFiles.length,
+      warnings: warnings.sort(compareWarnings),
+      suggestedRules: SUGGESTED_RULES
+    };
+  }
+  async#collectTargetFiles(workspaceRoot) {
+    const ignoreFilter = ignore2().add(await this.#readGitIgnore(workspaceRoot));
+    const files = [];
+    for (const targetRoot of ["apps", "libs"]) {
+      const absoluteTargetRoot = path43.join(workspaceRoot, targetRoot);
+      if (!await isDirectory(absoluteTargetRoot))
+        continue;
+      await this.#walkTargetFiles(workspaceRoot, absoluteTargetRoot, ignoreFilter, files);
+    }
+    return files.sort();
+  }
+  async#readGitIgnore(workspaceRoot) {
+    const gitIgnorePath = path43.join(workspaceRoot, ".gitignore");
+    if (!await Bun.file(gitIgnorePath).exists())
+      return [];
+    return (await readFile3(gitIgnorePath, "utf8")).split(/\r?\n/);
+  }
+  async#walkTargetFiles(workspaceRoot, currentPath, ignoreFilter, files) {
+    const entries = await readdir3(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path43.join(currentPath, entry.name);
+      const relativePath = toPosix(path43.relative(workspaceRoot, absolutePath));
+      if (shouldSkipPath(relativePath, entry.isDirectory(), ignoreFilter))
+        continue;
+      if (entry.isDirectory()) {
+        await this.#walkTargetFiles(workspaceRoot, absolutePath, ignoreFilter, files);
+        continue;
+      }
+      if ((relativePath.endsWith(".ts") || relativePath.endsWith(".tsx")) && !relativePath.endsWith(".d.ts")) {
+        files.push(relativePath);
+      }
+    }
+  }
+  async#readSourceFile(workspaceRoot, file) {
+    const absolutePath = path43.join(workspaceRoot, file);
+    const content = await readFile3(absolutePath, "utf8");
+    return {
+      file,
+      absolutePath,
+      content,
+      sourceFile: ts11.createSourceFile(file, content, ts11.ScriptTarget.Latest, true, getScriptKind(file))
+    };
+  }
+  #scanGlobalQuality(sourceFiles) {
+    const exportedFunctionLikes = sourceFiles.flatMap((sourceFile2) => getExportedFunctionLikes(sourceFile2));
+    const warnings = [];
+    for (const [name, declarations] of groupBy(exportedFunctionLikes, (declaration) => declaration.name)) {
+      if (declarations.length < 2)
+        continue;
+      warnings.push({
+        rule: "akan.global.duplicate-exported-function-name",
+        scope: "global",
+        severity: "warning",
+        message: `Exported function or class name "${name}" is declared in ${declarations.length} files.`,
+        locations: declarations.map(({ file, line }) => ({ file, line }))
+      });
+    }
+    const declarationsWithBody = exportedFunctionLikes.filter((declaration) => declaration.bodyFingerprint);
+    for (const [fingerprint, declarations] of groupBy(declarationsWithBody, (declaration) => declaration.bodyFingerprint ?? "")) {
+      const uniqueNames = new Set(declarations.map((declaration) => declaration.name));
+      if (declarations.length < 2 || uniqueNames.size < 2 || fingerprint === "")
+        continue;
+      warnings.push({
+        rule: "akan.global.duplicate-exported-function-body",
+        scope: "global",
+        severity: "warning",
+        message: `Exported functions/classes share the same implementation body: ${declarations.map((declaration) => declaration.name).join(", ")}.`,
+        locations: declarations.map(({ file, line }) => ({ file, line }))
+      });
+    }
+    return warnings;
+  }
+  #scanSingleFileQuality(sourceFile2) {
+    const warnings = [];
+    const lineCount = sourceFile2.content.split(/\r?\n/).length;
+    const recommendedLineLimit = getRecommendedLineLimit(sourceFile2.file);
+    if (recommendedLineLimit && lineCount > recommendedLineLimit) {
+      warnings.push({
+        rule: "akan.file.recommended-max-lines",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `File has ${lineCount} lines. Recommended limit for this file type is ${recommendedLineLimit} lines.`
+      });
+    }
+    if (lineCount > MAX_FILE_LINES) {
+      warnings.push({
+        rule: "akan.file.max-lines",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `File has ${lineCount} lines. Keep single files under ${MAX_FILE_LINES} lines.`
+      });
+    }
+    warnings.push(...getPlaceholderExportWarnings(sourceFile2));
+    warnings.push(...getDictionaryTextWarnings(sourceFile2));
+    warnings.push(...getGlobalMutationWarnings(sourceFile2));
+    const exportedClassNames = getExportedClassNames(sourceFile2.sourceFile);
+    if (exportedClassNames.length === 0)
+      return warnings;
+    const allowedInterfaceNames = new Set(exportedClassNames.map((name) => `${name}Options`));
+    for (const declaration of getTopLevelDeclarations(sourceFile2)) {
+      if (declaration.kind === "class" && exportedClassNames.includes(declaration.name))
+        continue;
+      if (declaration.kind === "interface" && allowedInterfaceNames.has(declaration.name))
+        continue;
+      warnings.push({
+        rule: "akan.file.class-export-global-declaration",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: declaration.line,
+        message: `Class export files should not declare top-level ${declaration.kind} "${declaration.name}". Move helpers to another file and import them.`
+      });
+    }
+    return warnings;
+  }
+  #scanConventionQuality(sourceFile2) {
+    const suffix = CONVENTION_SUFFIXES.find((candidate) => sourceFile2.file.endsWith(candidate));
+    if (!suffix)
+      return [];
+    const modelName = toPascalCase(path43.basename(sourceFile2.file, suffix));
+    const warnings = [];
+    for (const declaration of getTopLevelDeclarations(sourceFile2)) {
+      if (isAllowedConventionDeclaration(suffix, modelName, declaration))
+        continue;
+      warnings.push({
+        rule: `akan.convention${suffix.replace(".ts", "")}`,
+        scope: "convention",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: declaration.line,
+        message: `${path43.basename(sourceFile2.file)} should not declare top-level ${declaration.kind} "${declaration.name}". Allowed declarations: ${getConventionDescription(suffix, modelName)}.`
+      });
+    }
+    return warnings;
+  }
+  #scanLayoutQuality(sourceFile2) {
+    const segments = sourceFile2.file.split("/");
+    const warnings = [];
+    if (segments[0] === "apps" && segments.length === 3 && !APP_ROOT_FILES.has(segments[2])) {
+      warnings.push({
+        rule: "akan.layout.app-root-file",
+        scope: "layout",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `Unexpected app root file "${segments[2]}". Keep application code in conventional app folders.`
+      });
+    }
+    const libRootFile = getLibRootFile(sourceFile2.file);
+    if (libRootFile && !LIB_ROOT_FILES.has(libRootFile)) {
+      warnings.push({
+        rule: "akan.layout.lib-root-file",
+        scope: "layout",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `Unexpected lib root file "${libRootFile}". Keep direct lib root files limited to generated support facets.`
+      });
+    }
+    const moduleUiWarning = getModuleUiWarning(sourceFile2.file);
+    if (moduleUiWarning)
+      warnings.push(moduleUiWarning);
+    return warnings;
+  }
+}
+function formatQualityScanResult(result) {
+  const sections = [
+    "Akan Code Quality Scan",
+    `workspace: ${result.workspaceRoot}`,
+    `scanned files: ${result.scannedFiles}`,
+    `warnings: ${result.warnings.length}`,
+    "",
+    "Warnings:",
+    "",
+    ...formatQualityWarnings(result.warnings),
+    "",
+    "Suggested quality rules:",
+    "",
+    ...result.suggestedRules.map((rule) => `  - ${rule}`)
+  ];
+  return sections.join(`
+`);
+}
+function formatQualityWarnings(warnings) {
+  if (warnings.length === 0)
+    return ["No warnings found."];
+  return warnings.flatMap((warning) => {
+    const location = formatQualityLocation(warning.file, warning.line);
+    const lines = [`${location} - warning ${warning.rule}: ${warning.message}`];
+    if (warning.locations?.length) {
+      lines.push(...warning.locations.map(({ file, line }) => `  note: related location ${formatQualityLocation(file, line)}`));
+    }
+    return lines;
+  });
+}
+function formatQualityLocation(file, line) {
+  return `${file ?? "<global>"}:${line ?? 1}:1`;
+}
+function getExportedFunctionLikes(sourceFile2) {
+  const declarations = [];
+  for (const statement of sourceFile2.sourceFile.statements) {
+    if (ts11.isFunctionDeclaration(statement) && statement.name && isExported(statement)) {
+      declarations.push({
+        name: statement.name.text,
+        kind: "function",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        bodyFingerprint: getBodyFingerprint(sourceFile2.sourceFile, statement.body)
+      });
+    }
+    if (ts11.isClassDeclaration(statement) && statement.name && isExported(statement)) {
+      declarations.push({
+        name: statement.name.text,
+        kind: "class",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        bodyFingerprint: getBodyFingerprint(sourceFile2.sourceFile, statement)
+      });
+    }
+    if (ts11.isVariableStatement(statement) && isExported(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts11.isIdentifier(declaration.name) || !isFunctionLikeInitializer(declaration.initializer))
+          continue;
+        declarations.push({
+          name: declaration.name.text,
+          kind: "function-variable",
+          file: sourceFile2.file,
+          line: getLine(sourceFile2.sourceFile, declaration),
+          bodyFingerprint: getBodyFingerprint(sourceFile2.sourceFile, declaration.initializer)
+        });
+      }
+    }
+  }
+  return declarations;
+}
+function getExportedClassNames(sourceFile2) {
+  return sourceFile2.statements.filter((statement) => ts11.isClassDeclaration(statement) && !!statement.name).filter((statement) => isExported(statement)).map((statement) => statement.name.text);
+}
+function getPlaceholderExportWarnings(sourceFile2) {
+  if (!sourceFile2.file.endsWith("/index.ts") && !sourceFile2.file.endsWith("/index.tsx"))
+    return [];
+  return getTopLevelDeclarations(sourceFile2).filter((declaration) => declaration.exported && PLACEHOLDER_EXPORT_NAMES.has(declaration.name)).map((declaration) => ({
+    rule: "akan.file.placeholder-export",
+    scope: "file",
+    severity: "warning",
+    file: sourceFile2.file,
+    line: declaration.line,
+    message: `Generated or barrel index file should not export placeholder "${declaration.name}".`
+  }));
+}
+function getDictionaryTextWarnings(sourceFile2) {
+  if (!sourceFile2.file.endsWith(".dictionary.ts"))
+    return [];
+  const stalePatterns = [
+    { pattern: /\b[A-Z][A-Za-z0-9]* description\b/, label: "scaffold description text" },
+    { pattern: /settting/, label: "misspelling: settting" },
+    { pattern: /\uBC30\uB108 \uC218/, label: "stale copied Korean domain noun: \uBC30\uB108 \uC218" }
+  ];
+  return stalePatterns.flatMap(({ pattern, label }) => findPatternLines(sourceFile2.content, pattern).map((line) => ({
+    rule: "akan.file.dictionary-stale-text",
+    scope: "file",
+    severity: "warning",
+    file: sourceFile2.file,
+    line,
+    message: `Dictionary text appears to contain ${label}.`
+  })));
+}
+function getGlobalMutationWarnings(sourceFile2) {
+  const warnings = [];
+  for (const statement of sourceFile2.sourceFile.statements) {
+    if (ts11.isModuleDeclaration(statement) && statement.name.getText(sourceFile2.sourceFile) === "global") {
+      warnings.push({
+        rule: "akan.file.global-declaration",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        message: "Global declarations require an explicit low-level integration allowlist."
+      });
+    }
+    if (ts11.isInterfaceDeclaration(statement) && statement.name.text === "Window") {
+      warnings.push({
+        rule: "akan.file.window-augmentation",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        message: "Window augmentation should be isolated to approved browser integration files."
+      });
+    }
+    if (ts11.isExpressionStatement(statement) && statement.expression.getText(sourceFile2.sourceFile).includes(".prototype.")) {
+      warnings.push({
+        rule: "akan.file.prototype-mutation",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        message: "Prototype mutation should be avoided or isolated to approved low-level integration files."
+      });
+    }
+  }
+  return warnings;
+}
+function getTopLevelDeclarations(sourceFile2) {
+  return sourceFile2.sourceFile.statements.flatMap((statement) => getTopLevelDeclaration(sourceFile2.sourceFile, statement));
+}
+function getTopLevelDeclaration(sourceFile2, statement) {
+  const line = getLine(sourceFile2, statement);
+  if (ts11.isClassDeclaration(statement) && statement.name) {
+    return [{ name: statement.name.text, kind: "class", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isFunctionDeclaration(statement) && statement.name) {
+    return [{ name: statement.name.text, kind: "function", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isInterfaceDeclaration(statement)) {
+    return [{ name: statement.name.text, kind: "interface", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isTypeAliasDeclaration(statement)) {
+    return [{ name: statement.name.text, kind: "type", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isEnumDeclaration(statement)) {
+    return [{ name: statement.name.text, kind: "enum", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isVariableStatement(statement)) {
+    return statement.declarationList.declarations.filter((declaration) => ts11.isIdentifier(declaration.name)).map((declaration) => ({
+      name: declaration.name.text,
+      kind: "variable",
+      line: getLine(sourceFile2, declaration),
+      exported: isExported(statement),
+      node: statement
+    }));
+  }
+  if (ts11.isExportDeclaration(statement)) {
+    return [{ name: "export declaration", kind: "export", line, exported: true, node: statement }];
+  }
+  return [];
+}
+function isAllowedConventionDeclaration(suffix, modelName, declaration) {
+  if (suffix === ".dictionary.ts")
+    return isExportedConst(declaration) && declaration.name === "dictionary";
+  if (suffix === ".constant.ts")
+    return isAllowedConstantDeclaration(modelName, declaration);
+  if (suffix === ".document.ts")
+    return declaration.kind === "class" && [`${modelName}Filter`, modelName, `${modelName}Model`].includes(declaration.name);
+  if (suffix === ".service.ts")
+    return declaration.kind === "class" && declaration.name === `${modelName}Service`;
+  if (suffix === ".signal.ts")
+    return declaration.kind === "class" && [`${modelName}Internal`, `${modelName}Slice`, `${modelName}Endpoint`].includes(declaration.name);
+  if (suffix === ".store.ts")
+    return declaration.kind === "class" && declaration.name === `${modelName}Store`;
+  return false;
+}
+function isAllowedConstantDeclaration(modelName, declaration) {
+  if (declaration.kind !== "class")
+    return false;
+  if ([`${modelName}Input`, `${modelName}Object`, modelName, `Light${modelName}`, `${modelName}Insight`].includes(declaration.name))
+    return true;
+  if (!ts11.isClassDeclaration(declaration.node))
+    return false;
+  const heritageClause = declaration.node.heritageClauses?.find((clause) => clause.token === ts11.SyntaxKind.ExtendsKeyword);
+  const expression = heritageClause?.types[0]?.expression;
+  return !!expression && expression.getText().startsWith("enumOf(");
+}
+function getConventionDescription(suffix, modelName) {
+  if (suffix === ".dictionary.ts")
+    return "export const dictionary";
+  if (suffix === ".constant.ts")
+    return `${modelName}Input, ${modelName}Object, ${modelName}, Light${modelName}, ${modelName}Insight, or enumOf classes`;
+  if (suffix === ".document.ts")
+    return `${modelName}Filter, ${modelName}, or ${modelName}Model`;
+  if (suffix === ".service.ts")
+    return `${modelName}Service`;
+  if (suffix === ".signal.ts")
+    return `${modelName}Internal, ${modelName}Slice, or ${modelName}Endpoint`;
+  return `${modelName}Store`;
+}
+function getLibRootFile(file) {
+  const segments = file.split("/");
+  if (segments[0] === "libs" && segments.length === 4 && segments[2] === "lib")
+    return segments[3];
+  if (segments[0] === "apps" && segments.length === 5 && segments[2] === "lib")
+    return segments[4];
+  return null;
+}
+function getModuleUiWarning(file) {
+  if (!file.endsWith(".tsx"))
+    return null;
+  const moduleInfo = getModuleInfo(file);
+  if (!moduleInfo)
+    return null;
+  const { moduleName, fileName, kind } = moduleInfo;
+  const pascalName = toPascalCase(moduleName.replace(/^_+/, ""));
+  const allowedSuffixes = kind === "database" ? ["Template", "Unit", "Util", "View", "Zone"] : kind === "service" ? ["Util", "Zone"] : ["Template", "Unit"];
+  const allowedFileNames = new Set(allowedSuffixes.map((suffix) => `${pascalName}.${suffix}.tsx`));
+  if (allowedFileNames.has(fileName) || fileName.endsWith(".test.tsx") || fileName.endsWith(".spec.tsx"))
+    return null;
+  return {
+    rule: "akan.layout.module-ui-file",
+    scope: "layout",
+    severity: "warning",
+    file,
+    message: `Unexpected ${kind} module UI filename "${fileName}". Expected one of: ${[...allowedFileNames].join(", ")}.`
+  };
+}
+function getModuleInfo(file) {
+  const segments = file.split("/");
+  const libIndex = segments.indexOf("lib");
+  if (libIndex < 0)
+    return null;
+  const moduleName = segments[libIndex + 1];
+  if (moduleName === "__scalar") {
+    if (segments.length !== libIndex + 4)
+      return null;
+    return { moduleName: segments[libIndex + 2], fileName: segments[libIndex + 3], kind: "scalar" };
+  }
+  if (segments.length !== libIndex + 3)
+    return null;
+  const fileName = segments[libIndex + 2];
+  if (moduleName.startsWith("__")) {
+    const scalarName = moduleName === "__scalar" ? segments[libIndex + 2] : moduleName;
+    return { moduleName: scalarName, fileName, kind: "scalar" };
+  }
+  if (moduleName.startsWith("_"))
+    return { moduleName, fileName, kind: "service" };
+  return { moduleName, fileName, kind: "database" };
+}
+function isExportedConst(declaration) {
+  return declaration.exported && ts11.isVariableStatement(declaration.node) && (declaration.node.declarationList.flags & ts11.NodeFlags.Const) !== 0;
+}
+function isExported(node) {
+  return !!ts11.getCombinedModifierFlags(node) && !!(ts11.getCombinedModifierFlags(node) & ts11.ModifierFlags.Export);
+}
+function isFunctionLikeInitializer(node) {
+  return !!node && (ts11.isArrowFunction(node) || ts11.isFunctionExpression(node));
+}
+function getBodyFingerprint(sourceFile2, node) {
+  if (!node)
+    return;
+  const normalizedBody = node.getText(sourceFile2).replace(/\s+/g, " ").trim();
+  if (normalizedBody.length < 80)
+    return;
+  return createHash("sha256").update(normalizedBody).digest("hex");
+}
+function shouldSkipPath(relativePath, isDirectory, ignoreFilter) {
+  const ignorePath = isDirectory ? `${relativePath}/` : relativePath;
+  return relativePath === ".git" || relativePath.includes("/.git/") || relativePath.includes("/node_modules/") || ignoreFilter.ignores(relativePath) || ignoreFilter.ignores(ignorePath);
+}
+async function isDirectory(absolutePath) {
+  try {
+    return (await stat4(absolutePath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function getScriptKind(file) {
+  return file.endsWith(".tsx") ? ts11.ScriptKind.TSX : ts11.ScriptKind.TS;
+}
+function getLine(sourceFile2, node) {
+  return sourceFile2.getLineAndCharacterOfPosition(node.getStart(sourceFile2)).line + 1;
+}
+function getRecommendedLineLimit(file) {
+  if (file.endsWith(".service.ts"))
+    return 500;
+  if (file.endsWith(".Template.tsx") || file.endsWith(".Zone.tsx"))
+    return 800;
+  if (file.endsWith(".Util.tsx"))
+    return 1000;
+  return null;
+}
+function findPatternLines(content, pattern) {
+  return content.split(/\r?\n/).flatMap((line, index) => pattern.test(line) ? [index + 1] : []);
+}
+function toPascalCase(value) {
+  return value.replace(/(^|[-_./])([a-zA-Z0-9])/g, (_, __, char) => char.toUpperCase()).replace(/[-_./]/g, "");
+}
+function toPosix(value) {
+  return value.split(path43.sep).join("/");
+}
+function groupBy(items, getKey) {
+  const grouped = new Map;
+  for (const item of items) {
+    const key = getKey(item);
+    grouped.set(key, [...grouped.get(key) ?? [], item]);
+  }
+  return grouped;
+}
+function compareWarnings(a, b) {
+  return a.scope.localeCompare(b.scope) || (a.file ?? "").localeCompare(b.file ?? "") || (a.line ?? 0) - (b.line ?? 0) || a.rule.localeCompare(b.rule);
+}
 // pkgs/@akanjs/devkit/selectModel.ts
 import { select as select5 } from "@inquirer/prompts";
 // pkgs/@akanjs/devkit/streamAi.ts
@@ -15196,10 +15946,10 @@ class IncrementalBuilder {
     }
   }
   batchTouchesPagesTree(appDir, batch) {
-    const absAppDir = path42.resolve(appDir);
+    const absAppDir = path44.resolve(appDir);
     for (const f of batch.files) {
-      const abs = path42.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path42.sep}`) && abs !== absAppDir)
+      const abs = path44.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path44.sep}`) && abs !== absAppDir)
         continue;
       if (/\.(tsx|ts|jsx|js)$/.test(abs))
         return true;
@@ -15207,15 +15957,15 @@ class IncrementalBuilder {
     return false;
   }
   async batchMayChangePageKeys(appDir, batch) {
-    const absAppDir = path42.resolve(appDir);
-    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path42.normalize(key)));
+    const absAppDir = path44.resolve(appDir);
+    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path44.normalize(key)));
     for (const f of batch.files) {
-      const abs = path42.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path42.sep}`) && abs !== absAppDir)
+      const abs = path44.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path44.sep}`) && abs !== absAppDir)
         continue;
       if (!/\.(tsx|ts|jsx|js)$/.test(abs))
         continue;
-      const rel = path42.normalize(path42.relative(absAppDir, abs));
+      const rel = path44.normalize(path44.relative(absAppDir, abs));
       if (!await Bun.file(abs).exists() || !pageKeys.has(rel))
         return true;
     }
@@ -15243,7 +15993,7 @@ class IncrementalBuilder {
 ${cssText}`).toString(36);
           const cssRelPath = `styles/${cssAssetName}-${cssHash}.css`;
           const cssUrl = `/_akan/styles/${cssAssetName}-${cssHash}.css`;
-          await Bun.write(path42.join(artifactDir, cssRelPath), cssText);
+          await Bun.write(path44.join(artifactDir, cssRelPath), cssText);
           cssAssetEntries.push([basePath2, { cssUrl, cssRelPath }]);
           cssBase64ByUrl[cssUrl] = Buffer.from(new TextEncoder().encode(cssText)).toString("base64");
         })()
@@ -15311,10 +16061,10 @@ ${cssText}`).toString(36);
     if (changedFiles.length === 0)
       return false;
     return changedFiles.some((file) => {
-      const normalized = path42.resolve(file);
+      const normalized = path44.resolve(file);
       if (/\.(woff2?|ttf|otf)$/i.test(normalized))
         return true;
-      return this.#optimizedFonts.files.some((fontFile) => path42.resolve(fontFile) === normalized);
+      return this.#optimizedFonts.files.some((fontFile) => path44.resolve(fontFile) === normalized);
     });
   }
   async installWatcher() {