@akanjs/devkit 3.0.0-alpha.11 → 3.0.0-alpha.111

package/routeSourceValidator.ts

@@ -3,10 +3,27 @@ import ts from "typescript";
 
 /** What the build needs out of a route module without evaluating it. */
 export interface RouteSourceInfo {
-  /** `pageConfig.devOnly === true`, read straight off the AST. */
+  /** `pageConfig.devOnly === true`, or `.config({ devOnly: true })` on a chain, read straight off the AST. */
   devOnly: boolean;
+  /** Present when the default export is a `page()` / `layout()` / `rootLayout()` chain. */
+  chain?: RouteSourceChain;
 }
 
+export interface RouteSourceChain {
+  kind: "page" | "layout" | "rootLayout";
+  /** The `.param()` names, in chain order. */
+  params: string[];
+  /** The `.prompt()` name, when the page publishes itself as an MCP prompt. */
+  prompt?: string;
+}
+
+interface ChainStage {
+  name: string;
+  args: ts.NodeArray<ts.Expression>;
+}
+
+const chainRoots = new Set(["page", "layout", "rootLayout"]);
+
 /**
  * Static enforcement of the `page/` route conventions, split out of `executors.ts` so that importing
  * an executor does not pull `typescript` (+65MB resident) into the module graph. Both validators need
@@ -21,7 +38,7 @@ export class RouteSourceValidator {
     source: string,
     filePath: string,
     kind: "page" | "layout",
-    options: { rootLayout?: boolean } = {},
+    options: { rootLayout?: boolean; pattern?: string } = {},
   ): RouteSourceInfo {
     const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
     const allowed = getRouteExports(kind, { rootLayout: options.rootLayout });
@@ -81,7 +98,91 @@ export class RouteSourceValidator {
     if (exported.has("metadata") && exported.has("generateMetadata")) {
       throw new Error(`[route-convention] metadata and generateMetadata cannot both be exported in ${filePath}`);
     }
-    return { devOnly: RouteSourceValidator.#readDevOnly(sourceFile, filePath) };
+    const chain = RouteSourceValidator.#readChain(sourceFile, filePath);
+    if (!chain) return { devOnly: RouteSourceValidator.#readDevOnly(sourceFile, filePath) };
+    const named = [...exported].filter((name) => name !== "default");
+    if (named.length)
+      throw new Error(
+        `[route-convention] ${filePath} exports ${named.join(", ")} beside its ${chain.kind}() chain — every route setting is a stage of the chain`,
+      );
+    if (kind === "page" && chain.kind !== "page")
+      throw new Error(`[route-convention] ${filePath} is a page file but exports ${chain.kind}()`);
+    if (kind === "layout" && chain.kind === "page")
+      throw new Error(`[route-convention] ${filePath} is a layout file but exports page()`);
+    if (options.pattern) RouteSourceValidator.#assertChainParams(chain, options.pattern, filePath);
+    return {
+      devOnly: chain.devOnly,
+      chain: { kind: chain.kind, params: chain.params, ...(chain.prompt ? { prompt: chain.prompt } : {}) },
+    };
+  }
+
+  /**
+   * The default export as a `page()` / `layout()` / `rootLayout()` chain, or null when the module is the legacy
+   * shape. Read off the source for the same reason `devOnly` is: the build enumerates routes without importing
+   * them, and `akan sync` should name a `[projectId]` folder whose page declares no `.param("projectId")` before
+   * the first request does.
+   */
+  static #readChain(sourceFile: ts.SourceFile, filePath: string) {
+    for (const statement of sourceFile.statements) {
+      if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+      let node = RouteSourceValidator.#unwrapExpression(statement.expression);
+      const stages: ChainStage[] = [];
+      while (node && ts.isCallExpression(node)) {
+        const callee = node.expression;
+        if (ts.isPropertyAccessExpression(callee)) {
+          stages.unshift({ name: callee.name.text, args: node.arguments });
+          node = callee.expression;
+          continue;
+        }
+        if (ts.isIdentifier(callee) && chainRoots.has(callee.text))
+          return RouteSourceValidator.#chainOf(callee.text as RouteSourceChain["kind"], stages, filePath);
+        return null;
+      }
+      return null;
+    }
+    return null;
+  }
+
+  static #chainOf(kind: RouteSourceChain["kind"], stages: ChainStage[], filePath: string) {
+    const params: string[] = [];
+    let prompt: string | undefined;
+    let devOnly = false;
+    const literal = (stage: ChainStage) => {
+      const first = stage.args[0];
+      if (!first || !ts.isStringLiteralLike(first))
+        throw new Error(
+          `[route-convention] .${stage.name}() takes a string literal first in ${filePath} — the build reads it without evaluating the module`,
+        );
+      return first.text;
+    };
+    for (const stage of stages) {
+      if (stage.name === "param") params.push(literal(stage));
+      else if (stage.name === "prompt") prompt = literal(stage);
+      else if (stage.name === "config")
+        devOnly = RouteSourceValidator.#devOnlyOf(RouteSourceValidator.#unwrapExpression(stage.args[0]), filePath);
+    }
+    return { kind, params, prompt, devOnly };
+  }
+
+  /** The same rule the loader applies: a page names every `[x]` it sits under, a layout may name a subset. */
+  static #assertChainParams(chain: { kind: string; params: string[] }, pattern: string, filePath: string) {
+    const inPath = pattern
+      .split("/")
+      .filter((part) => part.startsWith(":"))
+      .map((part) => part.slice(1))
+      .filter((name) => name !== "lang");
+    if (chain.params.includes("lang"))
+      throw new Error(`[route-convention] ${filePath} declares .param("lang"), which every route receives undeclared`);
+    const unknown = chain.params.find((name) => !inPath.includes(name));
+    if (unknown)
+      throw new Error(
+        `[route-convention] ${filePath} declares .param("${unknown}") but no [${unknown}] segment is in its path`,
+      );
+    const undeclared = inPath.find((name) => !chain.params.includes(name));
+    if (chain.kind === "page" && undeclared)
+      throw new Error(
+        `[route-convention] ${filePath} sits under [${undeclared}] but declares no .param("${undeclared}") — a page reads only what it declares`,
+      );
   }
 
   /**
@@ -98,24 +199,30 @@ export class RouteSourceValidator {
       for (const declaration of statement.declarationList.declarations) {
         if (!ts.isIdentifier(declaration.name) || declaration.name.text !== "pageConfig") continue;
         const initializer = RouteSourceValidator.#unwrapExpression(declaration.initializer);
-        if (!initializer || !ts.isObjectLiteralExpression(initializer)) continue;
-        for (const property of initializer.properties) {
-          if (!ts.isPropertyAssignment(property)) continue;
-          const name = property.name;
-          const key = ts.isIdentifier(name) ? name.text : ts.isStringLiteral(name) ? name.text : null;
-          if (key !== "devOnly") continue;
-          const value = RouteSourceValidator.#unwrapExpression(property.initializer);
-          if (value?.kind === ts.SyntaxKind.TrueKeyword) return true;
-          if (value?.kind === ts.SyntaxKind.FalseKeyword) return false;
-          throw new Error(
-            `[route-convention] pageConfig.devOnly must be a literal true or false in ${filePath} — the build reads it without evaluating the module`,
-          );
-        }
+        if (initializer && ts.isObjectLiteralExpression(initializer))
+          return RouteSourceValidator.#devOnlyOf(initializer, filePath);
       }
     }
     return false;
   }
 
+  static #devOnlyOf(config: ts.Expression | undefined, filePath: string): boolean {
+    if (!config || !ts.isObjectLiteralExpression(config)) return false;
+    for (const property of config.properties) {
+      if (!ts.isPropertyAssignment(property)) continue;
+      const name = property.name;
+      const key = ts.isIdentifier(name) ? name.text : ts.isStringLiteral(name) ? name.text : null;
+      if (key !== "devOnly") continue;
+      const value = RouteSourceValidator.#unwrapExpression(property.initializer);
+      if (value?.kind === ts.SyntaxKind.TrueKeyword) return true;
+      if (value?.kind === ts.SyntaxKind.FalseKeyword) return false;
+      throw new Error(
+        `[route-convention] devOnly must be a literal true or false in ${filePath} — the build reads it without evaluating the module`,
+      );
+    }
+    return false;
+  }
+
   static #unwrapExpression(expression?: ts.Expression): ts.Expression | undefined {
     let current = expression;
     while (

package/scanInfo.ts

@@ -9,9 +9,9 @@ import type {
   PkgScanResult,
   ScanResult,
 } from "./akanConfig";
-
+import { AkanAppConfig } from "./akanConfig";
 import { AppExecutor, LibExecutor, PkgExecutor, WorkspaceExecutor } from "./executors";
-import { appRootAllowedDirs, appRootAllowedFiles, libFacetRootAllowedFiles } from "./workspaceLayout";
+import { isAllowedLibFacetRootFile, rootAllowedDirs, rootAllowedFiles } from "./workspaceLayout";
 
 const scalarFileTypes = ["constant", "dictionary", "document", "template", "unit", "util", "view", "zone"] as const;
 type ScalarFileType = (typeof scalarFileTypes)[number];
@@ -57,7 +57,6 @@ const moduleUiFileTypes = {
   scalar: new Set(["Template", "Unit"]),
 } satisfies Record<ModuleKind, Set<string>>;
 const testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
-const rootSignalTestFilePattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
 
 // The dependency scanner needs `typescript` (~65MB resident). Only the scan/sync commands run it, so
 // load it on demand rather than through the module graph of every process that imports scan info.
@@ -65,8 +64,6 @@ const createDependencyScanner = async (exec: AppExecutor | LibExecutor | PkgExec
   (await import("./dependencyScanner")).TypeScriptDependencyScanner.from(exec);
 
 const isAllowedTestFile = (filename: string) => testFilePattern.test(filename);
-const isAllowedLibRootFile = (filename: string) =>
-  libFacetRootAllowedFiles.has(filename) || rootSignalTestFilePattern.test(filename);
 const getScanPath = (exec: AppExecutor | LibExecutor, relativePath: string) =>
   path.posix.join(`${exec.type}s`, exec.name, relativePath.split(path.sep).join("/"));
 async function clearGeneratedRootCapacitorConfigs(exec: AppExecutor | LibExecutor) {
@@ -85,24 +82,29 @@ async function assertScanConvention(exec: AppExecutor | LibExecutor, libRoot: {
     violations.push(`${getScanPath(exec, relativePath)}: ${reason}`);
   };
 
-  if (exec.type === "app") {
-    const { files, dirs } = await exec.getFilesAndDirs(".");
-    files
-      .filter((filename) => !appRootAllowedFiles.has(filename))
-      .forEach((filename) => {
-        addViolation(filename, "unsupported app root file");
-      });
-    dirs
-      .filter((dirname) => !appRootAllowedDirs.has(dirname))
-      .forEach((dirname) => {
-        addViolation(dirname, "unsupported app root folder");
-      });
-  }
+  const allowedRootFiles: ReadonlySet<string> = rootAllowedFiles[exec.type];
+  const allowedRootDirs: ReadonlySet<string> = rootAllowedDirs[exec.type];
+  const { files, dirs } = await exec.getFilesAndDirs(".");
+  files
+    .filter((filename) => !allowedRootFiles.has(filename))
+    .forEach((filename) => {
+      addViolation(filename, `unsupported ${exec.type} root file`);
+    });
+  dirs
+    .filter((dirname) => !allowedRootDirs.has(dirname))
+    .forEach((dirname) => {
+      addViolation(dirname, `unsupported ${exec.type} root folder`);
+    });
+
+  //* An app validates its page tree in `getPageKeys`, which a lib has no equivalent of — so a lib's own
+  //* routes went unchecked until whichever app opted into them with `syncPageLibs` blew up on the sync.
+  if (exec.type === "lib")
+    for (const { relativePath, reason } of await exec.getPageConventionViolations()) addViolation(relativePath, reason);
 
   libRoot.files
-    .filter((filename) => !isAllowedLibRootFile(filename))
+    .filter((filename) => !isAllowedLibFacetRootFile(filename))
     .forEach((filename) => {
-      addViolation(path.join("lib", filename), "unsupported lib root file");
+      addViolation(path.join("lib", filename), "unsupported lib facet root file");
     });
 
   libRoot.dirs
@@ -284,12 +286,11 @@ class ScanInfo {
       }),
     ]);
     const routes = exec.type === "lib" ? [] : await (exec as AppExecutor).getPageKeys();
-    const scanResult: AppScanResult | LibScanResult = {
+    const common = {
       name: exec.name,
       type: exec.type,
       repoName: exec.workspace.repoName,
       serveDomain: WorkspaceExecutor.getBaseDevEnv(path.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
-      akanConfig,
       files,
       libDeps,
       pkgDeps,
@@ -297,6 +298,11 @@ class ScanInfo {
       devDependencies: npmDevDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
       routes,
     };
+    //? `exec.type` and the resolved config class are correlated, which the union alone cannot express.
+    const scanResult: AppScanResult | LibScanResult =
+      akanConfig instanceof AkanAppConfig
+        ? ({ ...common, akanConfig } satisfies AppScanResult)
+        : ({ ...common, akanConfig } satisfies LibScanResult);
     return scanResult;
   }
 
@@ -461,7 +467,7 @@ export class LibInfo extends ScanInfo {
           LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
         }),
     );
-    const libInfo = new LibInfo(exec, scanResult);
+    const libInfo = new LibInfo(exec, scanResult as LibScanResult);
     LibInfo.libInfos.set(exec.name, libInfo);
     LibInfo.#sortedLibIndices = null;
     return libInfo;
@@ -512,7 +518,7 @@ export class LibInfo extends ScanInfo {
 export class PkgInfo {
   readonly exec: PkgExecutor;
   readonly name: string;
-  private scanResult: PkgScanResult;
+  #scanResult: PkgScanResult;
 
   static async scanExecutor(exec: PkgExecutor) {
     const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
@@ -554,10 +560,10 @@ export class PkgInfo {
   constructor(exec: PkgExecutor, scanResult: PkgScanResult) {
     this.exec = exec;
     this.name = exec.name;
-    this.scanResult = scanResult;
+    this.#scanResult = scanResult;
   }
   getScanResult() {
-    return this.scanResult;
+    return this.#scanResult;
   }
 }
 

package/semver.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import { compareSemver } from "./semver";
+
+describe("compareSemver", () => {
+  test("orders plain versions", () => {
+    expect(compareSemver("1.4.0", "1.3.13")).toBe(1);
+    expect(compareSemver("1.3.13", "1.4.0")).toBe(-1);
+    expect(compareSemver("19.2.7", "19.2.7")).toBe(0);
+  });
+
+  test("compares the version behind a range operator, not the range", () => {
+    expect(compareSemver("^3.1049.0", "^3.721.0")).toBe(1);
+    expect(compareSemver("~1.2.0", "^1.10.0")).toBe(-1);
+    expect(compareSemver(">=1.3.13", "1.4.0")).toBe(-1);
+  });
+
+  test("sorts a prerelease below its release", () => {
+    expect(compareSemver("1.0.0-alpha", "1.0.0")).toBe(-1);
+    expect(compareSemver("0.0.0-experimental-603e6108-20241029", "0.0.0")).toBe(-1);
+  });
+
+  test("falls back to numeric comparison for specs that are not versions", () => {
+    expect(compareSemver("workspace:*", "0.0.0")).toBe(0);
+    expect(compareSemver("workspace:*", "1.0.0")).toBe(-1);
+  });
+});

package/semver.ts

@@ -0,0 +1,31 @@
+// `Bun.semver.order` compares range strings loosely — `^3.1049.0` vs `^3.721.0` answers 0 — so the
+// operator prefix has to come off before it sees the version.
+const stripRangeOperator = (version: string) => version.replace(/^[\s^~>=<v]+/, "").trim();
+
+const parseVersion = (version: string): number[] => {
+  return version
+    .replace(/^[^\d]*/, "")
+    .split(/[.-]/)
+    .map((part) => Number.parseInt(part, 10))
+    .map((part) => (Number.isFinite(part) ? part : 0));
+};
+
+const compareNumeric = (a: string, b: string): number => {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  const length = Math.max(left.length, right.length);
+  for (let i = 0; i < length; i++) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+};
+
+export const compareSemver = (a: string, b: string): number => {
+  try {
+    return Bun.semver.order(stripRangeOperator(a), stripRangeOperator(b));
+  } catch {
+    // Not every dependency spec is a version — `workspace:*`, a git URL, a tarball path.
+    return compareNumeric(a, b);
+  }
+};

package/slicePlanner.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { AppExecutor, Executor, WorkspaceExecutor } from "./executors";
+import { formatSlicePlan, SlicePlanner } from "./slicePlanner";
+import type { PackageJson } from "./types";
+
+const tempRoots: string[] = [];
+const originalEnv = { ...process.env };
+
+beforeEach(() => {
+  process.env = { ...originalEnv };
+  process.env.AKAN_PUBLIC_REPO_NAME = "workspace";
+  process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
+  process.env.AKAN_PUBLIC_ENV = "local";
+});
+
+afterEach(async () => {
+  process.env = { ...originalEnv };
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+const write = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+const gitignore = [
+  "node_modules",
+  "apps/*/lib/cnst.ts",
+  "libs/*/common/index.ts",
+  "**/env.server.local.ts",
+  "**/akan.app.json",
+].join("\n");
+
+// `AppExecutor.from` and `AppInfo.fromExecutor` both memoise by name, so each fixture needs a fresh one.
+const makeWorkspace = async (appName: string, libName: string) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-slice-"));
+  tempRoots.push(root);
+  const rootPackageJson: PackageJson = {
+    name: "workspace",
+    version: "0.0.1",
+    description: "workspace",
+    workspaces: ["pkgs/*"],
+    dependencies: { lodash: "4.0.0", "unused-dep": "1.0.0", ioredis: "5.0.0" },
+    devDependencies: { typescript: "6.0.0", "@types/lodash": "4.1.0", "@types/qrcode": "1.0.0" },
+    patchedDependencies: {
+      "lodash@4.0.0": "patches/lodash@4.0.0.patch",
+      "unused-dep@1.0.0": "patches/unused-dep@1.0.0.patch",
+    },
+  };
+  await write(path.join(root, "package.json"), `${JSON.stringify(rootPackageJson, null, 2)}\n`);
+  await write(path.join(root, ".gitignore"), `${gitignore}\n`);
+  await write(path.join(root, "biome.json"), "{}\n");
+  //? The framework's peers are declared by akanjs, not by any import, so the planner reads them here.
+  await write(
+    path.join(root, "node_modules/akanjs/package.json"),
+    '{ "name": "akanjs", "version": "3.0.0", "peerDependencies": { "react": "19.0.0", "ioredis": "5.0.0" } }\n',
+  );
+  await write(path.join(root, "patches/lodash@4.0.0.patch"), "");
+  await write(path.join(root, "patches/unused-dep@1.0.0.patch"), "");
+
+  await write(path.join(root, `apps/${appName}/akan.config.ts`), "export default {};\n");
+  await write(path.join(root, `apps/${appName}/tsconfig.json`), "{}\n");
+  await write(
+    path.join(root, `apps/${appName}/lib/task/task.constant.ts`),
+    [
+      `import { helper } from "@libs/${libName}/common";`,
+      'import lodash from "lodash";',
+      "",
+      "export { helper, lodash };",
+      "",
+    ].join("\n"),
+  );
+  await write(path.join(root, `apps/${appName}/lib/cnst.ts`), "export {};\n");
+  await write(path.join(root, `apps/${appName}/env/env.server.local.ts`), "export const env = {};\n");
+
+  await write(path.join(root, `libs/${libName}/akan.config.ts`), "export default {};\n");
+  await write(path.join(root, `libs/${libName}/tsconfig.json`), "{}\n");
+  await mkdir(path.join(root, `libs/${libName}/lib`), { recursive: true });
+  await write(path.join(root, `libs/${libName}/common/helper.ts`), "export const helper = 1;\n");
+  await write(path.join(root, `libs/${libName}/common/index.ts`), 'export * from "./helper";\n');
+
+  await write(path.join(root, "pkgs/in-tree/package.json"), '{ "name": "in-tree" }\n');
+
+  const git = new Executor("fixture", root);
+  await git.spawn("git", ["init", "--quiet"]);
+  await git.spawn("git", ["add", "-A"]);
+  await git.spawn("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "--quiet", "-m", "fixture"]);
+
+  const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot: root, repoName: `workspace-${appName}` });
+  return { root, plan: async () => await new SlicePlanner(AppExecutor.from(workspace, appName)).plan() };
+};
+
+describe("SlicePlanner", () => {
+  test("resolves the lib closure and lists only git-tracked slice files", async () => {
+    const { plan } = await makeWorkspace("slice-app", "slice-lib");
+    const result = await plan();
+
+    expect(result.app).toBe("slice-app");
+    expect(result.libs).toEqual(["slice-lib"]);
+    expect(result.appFiles).toContain("apps/slice-app/lib/task/task.constant.ts");
+    expect(result.libFiles["slice-lib"]).toContain("libs/slice-lib/common/helper.ts");
+  });
+
+  test("leaves out generated barrels, env values and every other workspace member", async () => {
+    const { plan } = await makeWorkspace("ignore-app", "ignore-lib");
+    const result = await plan();
+
+    expect(result.appFiles).not.toContain("apps/ignore-app/lib/cnst.ts");
+    expect(result.appFiles).not.toContain("apps/ignore-app/env/env.server.local.ts");
+    expect(result.libFiles["ignore-lib"]).not.toContain("libs/ignore-lib/common/index.ts");
+    expect(result.rootFiles).toEqual(expect.arrayContaining(["package.json", ".gitignore", "biome.json"]));
+    expect(result.rootFiles.filter((file) => file.startsWith("pkgs/"))).toEqual([]);
+    expect(result.rootFiles.filter((file) => /^(apps|libs)\//.test(file))).toEqual([]);
+  });
+
+  test("drops `workspaces` from the slice manifest and reports it", async () => {
+    const { plan } = await makeWorkspace("manifest-app", "manifest-lib");
+    const result = await plan();
+
+    expect(result.packageJson.workspaces).toBeUndefined();
+    expect(result.warnings.join("\n")).toContain("workspaces");
+  });
+
+  test("prunes what the slice does not import, keeping the toolchain and the type packages", async () => {
+    const { plan } = await makeWorkspace("deps-app", "deps-lib");
+    const result = await plan();
+
+    expect(result.requiredDependencies).toContain("lodash");
+    //? `ioredis` is an akanjs peer: nothing imports it, and pruning it would break the server at runtime.
+    expect(result.packageJson.dependencies).toEqual({ lodash: "4.0.0", ioredis: "5.0.0" });
+    //? Nothing imports `@types/lodash` by name, so only its companion keeps it.
+    expect(result.packageJson.devDependencies).toEqual({ typescript: "6.0.0", "@types/lodash": "4.1.0" });
+    expect(result.packageJson.patchedDependencies).toEqual({ "lodash@4.0.0": "patches/lodash@4.0.0.patch" });
+    expect(result.unusedDependencies).toEqual(["@types/qrcode", "unused-dep"]);
+  });
+
+  test("carries the dependencies whole when there is no akanjs manifest to read the peers from", async () => {
+    const { root, plan } = await makeWorkspace("nopeer-app", "nopeer-lib");
+    await rm(path.join(root, "node_modules"), { recursive: true, force: true });
+    const result = await plan();
+
+    expect(result.unusedDependencies).toEqual([]);
+    expect(result.packageJson.dependencies).toEqual({ lodash: "4.0.0", "unused-dep": "1.0.0", ioredis: "5.0.0" });
+    expect(result.warnings.join("\n")).toContain("carried whole");
+  });
+
+  test("names a type package the way DefinitelyTyped does", () => {
+    expect(SlicePlanner.typesPackageOf("lodash")).toBe("@types/lodash");
+    expect(SlicePlanner.typesPackageOf("@capacitor/core")).toBe("@types/capacitor__core");
+  });
+
+  test("warns about untracked files under the slice paths", async () => {
+    const { root, plan } = await makeWorkspace("untracked-app", "untracked-lib");
+    await write(path.join(root, "apps/untracked-app/lib/task/task.service.ts"), "export {};\n");
+    const result = await plan();
+
+    expect(result.warnings.join("\n")).toContain("apps/untracked-app/lib/task/task.service.ts");
+  });
+});
+
+describe("formatSlicePlan", () => {
+  test("collapses the workspace shell to its top-level entries", () => {
+    const text = formatSlicePlan({
+      app: "demo",
+      libs: ["util"],
+      appFiles: ["apps/demo/main.ts"],
+      libFiles: { util: ["libs/util/index.ts"] },
+      rootFiles: ["package.json", "infra/app/values/main.yaml", "infra/app/templates/app.yaml"],
+      packageJson: { name: "demo", version: "0.0.1", description: "demo" },
+      requiredDependencies: [],
+      unusedDependencies: [],
+      warnings: [],
+    });
+
+    expect(text).toContain("app: demo (apps/demo: 1 files)");
+    expect(text).toContain("3 files across infra, package.json");
+    expect(text).toContain("(none)");
+  });
+});