@open-mercato/cli 0.6.8-develop.6891.1.4dca3f1ad3 → 0.6.8-develop.6893.1.7af3b3a72d

package/dist/lib/generators/module-registry.js

@@ -3,6 +3,10 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { VariableDeclarationKind } from "ts-morph";
 import ts from "typescript-js";
+import {
+  DEV_SUPERVISOR_MANIFEST_FILE,
+  DEV_SUPERVISOR_MANIFEST_VERSION
+} from "../dev-supervisor-manifest.js";
 import {
   calculateStructureChecksum,
   toVar,
@@ -58,6 +62,11 @@ import {
   resolveStandaloneSourceMirrorBase
 } from "./scanner.js";
 import { loadGeneratorExtensions } from "./extensions/index.js";
+import {
+  renderRouteManifestShardOutputs,
+  renderRouteMetadataOutput,
+  routeManifestShardFilePattern
+} from "./route-manifest-shards.js";
 function assertUniqueBackendRoutePattern(seen, moduleId, pattern) {
   if (!pattern.startsWith("/backend/")) return;
   const previous = seen.get(pattern);
@@ -1157,12 +1166,16 @@ function discoverTranslations(roots) {
   const locales = /* @__PURE__ */ new Set();
   if (fs.existsSync(i18nCore)) {
     for (const entry of fs.readdirSync(i18nCore, { withFileTypes: true })) {
-      if (entry.isFile() && entry.name.endsWith(".json")) locales.add(entry.name.replace(/\.json$/, ""));
+      if (entry.isFile() && /^[a-zA-Z0-9][a-zA-Z0-9_-]*\.json$/.test(entry.name)) {
+        locales.add(entry.name.replace(/\.json$/, ""));
+      }
     }
   }
   if (fs.existsSync(i18nApp)) {
     for (const entry of fs.readdirSync(i18nApp, { withFileTypes: true })) {
-      if (entry.isFile() && entry.name.endsWith(".json")) locales.add(entry.name.replace(/\.json$/, ""));
+      if (entry.isFile() && /^[a-zA-Z0-9][a-zA-Z0-9_-]*\.json$/.test(entry.name)) {
+        locales.add(entry.name.replace(/\.json$/, ""));
+      }
     }
   }
   return Array.from(locales, (locale) => ({
@@ -1242,6 +1255,8 @@ async function processPageFiles(options) {
   const eagerRoutes = [];
   const runtimeRoutes = [];
   const manifestRoutes = [];
+  const manifestShardRoutes = [];
+  const metadataRoutes = [];
   const routePatterns = [];
   for (const { relPath, fromApp } of files.filter(({ relPath: f }) => isModulePageFile(path.basename(f)))) {
     const segs = relPath.split("/");
@@ -1309,7 +1324,19 @@ async function processPageFiles(options) {
     const manifestBaseProps = buildPageRouteManifestSpread(manifestMetaExpr, routePath);
     eagerRoutes.push(`{ ${baseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`);
     runtimeRoutes.push(`{ ${runtimeBaseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`);
-    manifestRoutes.push(`{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps}, load: async () => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod.default ?? mod) as any } }`);
+    const metadataDeclaration = `{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps} }`;
+    const manifestDeclaration = `{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps}, load: async () => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod.default ?? mod) as any } }`;
+    manifestRoutes.push(manifestDeclaration);
+    manifestShardRoutes.push({
+      path: routePath,
+      declaration: manifestDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : []
+    });
+    metadataRoutes.push({
+      path: routePath,
+      declaration: metadataDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : []
+    });
     routePatterns.push(routePath);
   }
   for (const { relPath, fromApp } of files.filter(({ relPath: f }) => !isModulePageFile(path.basename(f)))) {
@@ -1382,13 +1409,27 @@ async function processPageFiles(options) {
     const manifestBaseProps = buildPageRouteManifestSpread(manifestMetaExpr, routePath);
     eagerRoutes.push(`{ ${baseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`);
     runtimeRoutes.push(`{ ${runtimeBaseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`);
-    manifestRoutes.push(`{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps}, load: async () => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod.default ?? mod) as any } }`);
+    const metadataDeclaration = `{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps} }`;
+    const manifestDeclaration = `{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps}, load: async () => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod.default ?? mod) as any } }`;
+    manifestRoutes.push(manifestDeclaration);
+    manifestShardRoutes.push({
+      path: routePath,
+      declaration: manifestDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : []
+    });
+    metadataRoutes.push({
+      path: routePath,
+      declaration: metadataDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : []
+    });
     routePatterns.push(routePath);
   }
   return {
     eagerRoutes,
     runtimeRoutes,
     manifestRoutes,
+    manifestShardRoutes,
+    metadataRoutes,
     routePatterns
   };
 }
@@ -1397,11 +1438,13 @@ async function processApiRoutes(options) {
   const apiApp = path.join(roots.appBase, "api");
   const apiPkg = path.join(roots.pkgBase, "api");
   if (!fs.existsSync(apiApp) && !fs.existsSync(apiPkg)) {
-    return { eagerApis: [], runtimeApis: [], manifestApis: [] };
+    return { eagerApis: [], runtimeApis: [], manifestApis: [], manifestShardApis: [], metadataApis: [] };
   }
   const eagerApis = [];
   const runtimeApis = [];
   const manifestApis = [];
+  const manifestShardApis = [];
+  const metadataApis = [];
   const routeFiles = scanModuleDir(roots, SCAN_CONFIGS.apiRoutes);
   for (const { relPath, fromApp } of routeFiles) {
     const segs = relPath.split("/");
@@ -1430,7 +1473,11 @@ async function processApiRoutes(options) {
     eagerImports.push(buildImportStatement(`* as ${importName}`, importPath));
     eagerApis.push(`{ path: ((${importName} as any).metadata?.path ?? ${toLiteral(routePath)}), metadata: (${importName} as any).metadata, handlers: ${importName} as any${docsPart} }`);
     runtimeApis.push(`{ path: ${toLiteral(resolvedPath)}, metadata: ${metadataLiteral}, handlers: { ${exportedMethods.map((method) => `${method}: async (req: Request, ctx?: any) => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod as any).${method}(req, ctx) }`).join(", ")} } }`);
-    manifestApis.push(`{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("route-file")}, path: ${toLiteral(resolvedPath)}, methods: [${exportedMethods.map((method) => toLiteral(method)).join(", ")}], load: async () => ${buildDynamicImportExpression(importPath)} }`);
+    const metadataDeclaration = `{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("route-file")}, path: ${toLiteral(resolvedPath)}, methods: [${exportedMethods.map((method) => toLiteral(method)).join(", ")}] }`;
+    const manifestDeclaration = `{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("route-file")}, path: ${toLiteral(resolvedPath)}, methods: [${exportedMethods.map((method) => toLiteral(method)).join(", ")}], load: async () => ${buildDynamicImportExpression(importPath)} }`;
+    manifestApis.push(manifestDeclaration);
+    manifestShardApis.push({ path: resolvedPath, declaration: manifestDeclaration });
+    metadataApis.push({ path: resolvedPath, declaration: metadataDeclaration });
   }
   const plainFiles = scanModuleDir(roots, SCAN_CONFIGS.apiPlainFiles);
   for (const { relPath, fromApp } of plainFiles) {
@@ -1460,7 +1507,11 @@ async function processApiRoutes(options) {
     eagerImports.push(buildImportStatement(`* as ${importName}`, importPath));
     eagerApis.push(`{ path: ((${importName} as any).metadata?.path ?? ${toLiteral(routePath)}), metadata: (${importName} as any).metadata, handlers: ${importName} as any${docsPart} }`);
     runtimeApis.push(`{ path: ${toLiteral(resolvedPath)}, metadata: ${metadataLiteral}, handlers: { ${exportedMethods.map((entryMethod) => `${entryMethod}: async (req: Request, ctx?: any) => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod as any).${entryMethod}(req, ctx) }`).join(", ")} } }`);
-    manifestApis.push(`{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("route-file")}, path: ${toLiteral(resolvedPath)}, methods: [${exportedMethods.map((entryMethod) => toLiteral(entryMethod)).join(", ")}], load: async () => ${buildDynamicImportExpression(importPath)} }`);
+    const metadataDeclaration = `{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("route-file")}, path: ${toLiteral(resolvedPath)}, methods: [${exportedMethods.map((entryMethod) => toLiteral(entryMethod)).join(", ")}] }`;
+    const manifestDeclaration = `{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("route-file")}, path: ${toLiteral(resolvedPath)}, methods: [${exportedMethods.map((entryMethod) => toLiteral(entryMethod)).join(", ")}], load: async () => ${buildDynamicImportExpression(importPath)} }`;
+    manifestApis.push(manifestDeclaration);
+    manifestShardApis.push({ path: resolvedPath, declaration: manifestDeclaration });
+    metadataApis.push({ path: resolvedPath, declaration: metadataDeclaration });
   }
   const methods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
   for (const method of methods) {
@@ -1499,13 +1550,19 @@ async function processApiRoutes(options) {
       eagerImports.push(buildImportStatement(`${importName}, * as ${metaName}`, importPath));
       eagerApis.push(`{ method: ${toLiteral(method)}, path: (${metaName}.metadata?.path ?? ${toLiteral(routePath)}), handler: ${importName}, metadata: ${metaName}.metadata${docsPart} }`);
       runtimeApis.push(`{ method: ${toLiteral(method)}, path: ${toLiteral(resolvedPath)}, handler: async (req: Request, ctx?: any) => { const mod = await ${buildDynamicImportExpression(importPath)}; const handler = ((mod as any).default ?? (mod as any).${method} ?? (mod as any).handler) as any; return handler(req, ctx) }, metadata: ${metadataLiteral} }`);
-      manifestApis.push(`{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("legacy")}, method: ${toLiteral(method)}, path: ${toLiteral(resolvedPath)}, methods: [${toLiteral(method)}], load: async () => ${buildDynamicImportExpression(importPath)} }`);
+      const metadataDeclaration = `{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("legacy")}, method: ${toLiteral(method)}, path: ${toLiteral(resolvedPath)}, methods: [${toLiteral(method)}] }`;
+      const manifestDeclaration = `{ moduleId: ${toLiteral(modId)}, kind: ${toLiteral("legacy")}, method: ${toLiteral(method)}, path: ${toLiteral(resolvedPath)}, methods: [${toLiteral(method)}], load: async () => ${buildDynamicImportExpression(importPath)} }`;
+      manifestApis.push(manifestDeclaration);
+      manifestShardApis.push({ path: resolvedPath, declaration: manifestDeclaration });
+      metadataApis.push({ path: resolvedPath, declaration: metadataDeclaration });
     }
   }
   return {
     eagerApis,
     runtimeApis,
-    manifestApis
+    manifestApis,
+    manifestShardApis,
+    metadataApis
   };
 }
 function processSubscribers(discovered) {
@@ -2101,48 +2158,229 @@ function processWorkersAst(discovered) {
   }
   return workers;
 }
+function collectWorkerGenerationEntries(discovered, moduleId) {
+  const workers = [];
+  for (const { id, importPath, metadata } of discovered) {
+    if (!metadata.queue) continue;
+    workers.push({
+      id: metadata.id ?? id,
+      moduleId,
+      queue: metadata.queue,
+      concurrency: metadata.concurrency ?? 1,
+      importPath
+    });
+  }
+  return workers;
+}
 function processTranslationsAst(options) {
-  const { discovered, modId, appImportBase, pkgImportBase, imports, extraImports } = options;
+  const { discovered, modId, appImportBase, pkgImportBase, imports, extraImports, localeOutputs } = options;
   const translations = [];
   for (const { locale, coreHas, appHas } of discovered) {
     if (coreHas && appHas) {
       const coreName = `T_${toVar(modId)}_${toVar(locale)}_C`;
       const appName = `T_${toVar(modId)}_${toVar(locale)}_A`;
-      imports.push(buildImportStatement(coreName, `${pkgImportBase}/i18n/${locale}.json`));
-      imports.push(buildImportStatement(appName, `${appImportBase}/i18n/${locale}.json`));
-      extraImports?.push(buildImportStatement(coreName, `${pkgImportBase}/i18n/${locale}.json`));
-      extraImports?.push(buildImportStatement(appName, `${appImportBase}/i18n/${locale}.json`));
+      const localeImports = [
+        buildImportStatement(coreName, `${pkgImportBase}/i18n/${locale}.json`),
+        buildImportStatement(appName, `${appImportBase}/i18n/${locale}.json`)
+      ];
+      imports.push(...localeImports);
+      extraImports?.push(...localeImports);
+      const value = objectLiteral([
+        { kind: "spread", value: asExpression(identifier(coreName), "unknown as Record<string, string>") },
+        { kind: "spread", value: asExpression(identifier(appName), "unknown as Record<string, string>") }
+      ]);
       translations.push({
         name: JSON.stringify(locale),
-        value: objectLiteral([
-          { kind: "spread", value: asExpression(identifier(coreName), "unknown as Record<string, string>") },
-          { kind: "spread", value: asExpression(identifier(appName), "unknown as Record<string, string>") }
-        ])
+        value
       });
+      localeOutputs?.set(locale, { imports: localeImports, value });
       continue;
     }
     if (appHas) {
       const appName = `T_${toVar(modId)}_${toVar(locale)}_A`;
-      imports.push(buildImportStatement(appName, `${appImportBase}/i18n/${locale}.json`));
-      extraImports?.push(buildImportStatement(appName, `${appImportBase}/i18n/${locale}.json`));
+      const localeImports = [buildImportStatement(appName, `${appImportBase}/i18n/${locale}.json`)];
+      imports.push(...localeImports);
+      extraImports?.push(...localeImports);
+      const value = asExpression(identifier(appName), "unknown as Record<string, string>");
       translations.push({
         name: JSON.stringify(locale),
-        value: asExpression(identifier(appName), "unknown as Record<string, string>")
+        value
       });
+      localeOutputs?.set(locale, { imports: localeImports, value });
       continue;
     }
     if (coreHas) {
       const coreName = `T_${toVar(modId)}_${toVar(locale)}_C`;
-      imports.push(buildImportStatement(coreName, `${pkgImportBase}/i18n/${locale}.json`));
-      extraImports?.push(buildImportStatement(coreName, `${pkgImportBase}/i18n/${locale}.json`));
+      const localeImports = [buildImportStatement(coreName, `${pkgImportBase}/i18n/${locale}.json`)];
+      imports.push(...localeImports);
+      extraImports?.push(...localeImports);
+      const value = asExpression(identifier(coreName), "unknown as Record<string, string>");
       translations.push({
         name: JSON.stringify(locale),
-        value: asExpression(identifier(coreName), "unknown as Record<string, string>")
+        value
       });
+      localeOutputs?.set(locale, { imports: localeImports, value });
     }
   }
   return translations;
 }
+function sourceDeclaresCliCommand(filePath, commandName) {
+  let sourceText;
+  try {
+    sourceText = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
+  const declarations = /* @__PURE__ */ new Map();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+        declarations.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  const expressionDeclaresCommand = (expression, seen = /* @__PURE__ */ new Set()) => {
+    if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) {
+      return expressionDeclaresCommand(expression.expression, seen);
+    }
+    if (ts.isIdentifier(expression)) {
+      if (seen.has(expression.text)) return false;
+      const initializer = declarations.get(expression.text);
+      if (!initializer) return false;
+      const nextSeen = new Set(seen);
+      nextSeen.add(expression.text);
+      return expressionDeclaresCommand(initializer, nextSeen);
+    }
+    if (ts.isArrayLiteralExpression(expression)) {
+      return expression.elements.some((element) => ts.isSpreadElement(element) ? expressionDeclaresCommand(element.expression, seen) : expressionDeclaresCommand(element, seen));
+    }
+    if (!ts.isObjectLiteralExpression(expression)) return false;
+    return expression.properties.some((property) => {
+      if (!ts.isPropertyAssignment(property)) return false;
+      const propertyName = ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name) ? property.name.text : null;
+      return propertyName === "command" && (ts.isStringLiteralLike(property.initializer) || ts.isNoSubstitutionTemplateLiteral(property.initializer)) && property.initializer.text === commandName;
+    });
+  };
+  return sourceFile.statements.some((statement) => ts.isExportAssignment(statement) && !statement.isExportEquals && expressionDeclaresCommand(statement.expression));
+}
+function appDeclaresProgrammaticDevSupervisorOverrides(appDir) {
+  const srcDir = path.join(appDir, "src");
+  const pending = [srcDir];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "__tests__" && entry.name !== "node_modules") pending.push(entryPath);
+        continue;
+      }
+      if (!/\.[cm]?tsx?$/.test(entry.name) || /(?:^|\.)test\.[cm]?tsx?$/.test(entry.name)) continue;
+      let sourceText;
+      try {
+        sourceText = fs.readFileSync(entryPath, "utf8");
+      } catch {
+        continue;
+      }
+      const sourceFile = ts.createSourceFile(entryPath, sourceText, ts.ScriptTarget.Latest, true);
+      const directImports = /* @__PURE__ */ new Set();
+      const namespaceImports = /* @__PURE__ */ new Set();
+      for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteralLike(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@open-mercato/shared/modules/overrides") continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings)) namespaceImports.add(bindings.name.text);
+        if (bindings && ts.isNamedImports(bindings)) {
+          for (const element of bindings.elements) {
+            const importedName = element.propertyName?.text ?? element.name.text;
+            if (importedName === "applyWorkerOverrides" || importedName === "applyCliOverrides") {
+              directImports.add(element.name.text);
+            }
+          }
+        }
+      }
+      let found = false;
+      const visit = (node) => {
+        if (found) return;
+        if (ts.isCallExpression(node)) {
+          if (ts.isIdentifier(node.expression) && directImports.has(node.expression.text)) {
+            found = true;
+            return;
+          }
+          if (ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && namespaceImports.has(node.expression.expression.text) && ["applyWorkerOverrides", "applyCliOverrides"].includes(node.expression.name.text)) {
+            found = true;
+            return;
+          }
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(sourceFile);
+      if (found) return true;
+    }
+  }
+  return false;
+}
+function renderAstI18nLocaleRegistryFile(options) {
+  const sourceFile = createGeneratedSourceFile(options.fileName);
+  addAutoGeneratedComment(sourceFile, "registry (locale-specific i18n version)");
+  addImportSpec(sourceFile, {
+    moduleSpecifier: "@open-mercato/shared/modules/registry",
+    namedImports: [{ name: "Module", isTypeOnly: true }]
+  });
+  addImportStatements(sourceFile, options.imports);
+  sourceFile.addVariableStatement({
+    declarationKind: VariableDeclarationKind.Const,
+    isExported: true,
+    declarations: [{
+      name: "modules",
+      type: "Module[]",
+      initializer: arrayLiteral(options.moduleEntries, writeValue)
+    }]
+  });
+  sourceFile.addExportAssignment({
+    isExportEquals: false,
+    expression: "modules"
+  });
+  return getSourceText(sourceFile);
+}
+function buildI18nLocaleShardFileName(locale) {
+  const safeLocale = locale.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `modules.i18n.${safeLocale}.generated.ts`;
+}
+function renderI18nLocaleLoadersFile(locales) {
+  const cases = locales.map((locale) => {
+    const moduleSpecifier = `./${buildI18nLocaleShardFileName(locale).replace(/\.ts$/, "")}`;
+    return `    case ${JSON.stringify(locale)}:
+      return import(${JSON.stringify(moduleSpecifier)}).then((entry) => entry.modules)`;
+  }).join("\n");
+  return `// AUTO-GENERATED by mercato generate registry (locale-specific i18n loaders)
+import type { Module } from '@open-mercato/shared/modules/registry'
+
+export async function loadI18nModules(locale: string): Promise<Module[]> {
+  switch (locale) {
+${cases ? `${cases}
+` : ""}    default:
+      return []
+  }
+}
+`;
+}
+function removeStaleI18nLocaleShards(outputDir, expectedFileNames) {
+  if (!fs.existsSync(outputDir)) return;
+  for (const entry of fs.readdirSync(outputDir, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (!/^modules\.i18n\..+\.generated\.(?:ts|checksum)$/.test(entry.name)) continue;
+    if (entry.name.startsWith("modules.i18n.loaders.generated.")) continue;
+    if (expectedFileNames.has(entry.name)) continue;
+    fs.unlinkSync(path.join(outputDir, entry.name));
+  }
+}
 function resolveConventionFile(resolved, prefix, modId, importIdRef, imports, extraImports, importStyle = "namespace") {
   if (!resolved) return null;
   const importName = `${prefix}_${toVar(modId)}_${importIdRef.value++}`;
@@ -2205,6 +2443,10 @@ async function generateModuleRegistryFromDiscovery(options) {
   const frontendRouteManifestDecls = [];
   const backendRouteManifestDecls = [];
   const apiRouteManifestDecls = [];
+  const backendRouteShardEntries = [];
+  const backendRouteMetadataEntries = [];
+  const apiRouteShardEntries = [];
+  const apiRouteMetadataEntries = [];
   const importIdRef = { value: 0 };
   const requiresByModule = /* @__PURE__ */ new Map();
   const commandLoaderEntries = [];
@@ -2370,6 +2612,8 @@ async function generateModuleRegistryFromDiscovery(options) {
         backendRoutes.push(...generatedBackendRoutes.eagerRoutes);
         runtimeBackendRoutes.push(...generatedBackendRoutes.runtimeRoutes);
         backendRouteManifestDecls.push(...generatedBackendRoutes.manifestRoutes);
+        backendRouteShardEntries.push(...generatedBackendRoutes.manifestShardRoutes);
+        backendRouteMetadataEntries.push(...generatedBackendRoutes.metadataRoutes);
         for (const pattern of generatedBackendRoutes.routePatterns) {
           assertUniqueBackendRoutePattern(seenBackendRoutePatterns, modId, pattern);
         }
@@ -2388,6 +2632,8 @@ async function generateModuleRegistryFromDiscovery(options) {
       apis.push(...generatedApis.eagerApis);
       runtimeApis.push(...generatedApis.runtimeApis);
       apiRouteManifestDecls.push(...generatedApis.manifestApis);
+      apiRouteShardEntries.push(...generatedApis.manifestShardApis);
+      apiRouteMetadataEntries.push(...generatedApis.metadataApis);
     }
     {
       const cliResolved = discovered.resolve("cli.ts");
@@ -2586,6 +2832,12 @@ async function generateModuleRegistryFromDiscovery(options) {
     exportName: "apiRoutes",
     entries: apiRouteManifestDecls
   });
+  const routeManifestOutputs = [
+    ...renderRouteManifestShardOutputs("backend", backendRouteShardEntries),
+    ...renderRouteManifestShardOutputs("api", apiRouteShardEntries),
+    renderRouteMetadataOutput("backend", backendRouteMetadataEntries),
+    renderRouteMetadataOutput("api", apiRouteMetadataEntries)
+  ];
   const legacySubscribersOutput = renderAstLegacyAliasFile({
     fileName: "subscribers.generated.ts",
     exportName: "moduleSubscribers",
@@ -2628,6 +2880,29 @@ async function generateModuleRegistryFromDiscovery(options) {
   writeGeneratedFile({ outFile: frontendRoutesOutFile, checksumFile: frontendRoutesChecksumFile, content: frontendRoutesOutput, structureChecksum, result, quiet });
   writeGeneratedFile({ outFile: backendRoutesOutFile, checksumFile: backendRoutesChecksumFile, content: backendRoutesOutput, structureChecksum, result, quiet });
   writeGeneratedFile({ outFile: apiRoutesOutFile, checksumFile: apiRoutesChecksumFile, content: apiRoutesOutput, structureChecksum, result, quiet });
+  const expectedRouteManifestFiles = new Set(routeManifestOutputs.flatMap(({ fileName }) => [
+    fileName,
+    fileName.replace(/\.ts$/, ".checksum")
+  ]));
+  if (fs.existsSync(outputDir)) {
+    for (const entry of fs.readdirSync(outputDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !routeManifestShardFilePattern.test(entry.name)) continue;
+      if (expectedRouteManifestFiles.has(entry.name)) continue;
+      const stalePath = path.join(outputDir, entry.name);
+      fs.unlinkSync(stalePath);
+      result.filesWritten.push(stalePath);
+    }
+  }
+  for (const routeOutput of routeManifestOutputs) {
+    writeGeneratedFile({
+      outFile: path.join(outputDir, routeOutput.fileName),
+      checksumFile: path.join(outputDir, routeOutput.fileName.replace(/\.ts$/, ".checksum")),
+      content: routeOutput.content,
+      structureChecksum,
+      result,
+      quiet
+    });
+  }
   writeGeneratedFile({ outFile: legacySubscribersOutFile, checksumFile: legacySubscribersChecksumFile, content: legacySubscribersOutput, structureChecksum, result, quiet });
   const commandLoadersOutput = renderCommandLoadersFile(commandLoaderEntries);
   writeGeneratedFile({ outFile: commandLoadersOutFile, checksumFile: commandLoadersChecksumFile, content: commandLoadersOutput, structureChecksum, result, quiet });
@@ -2656,14 +2931,14 @@ async function generateModuleRegistryFromDiscovery(options) {
   {
     const bootstrapPlugins = [...pluginRegistry.values()].filter((p) => p.bootstrapRegistration);
     const allEntryImports = [
-      buildImportStatement(`{ backendRoutes }`, `./backend-routes.generated`),
+      buildImportStatement(`{ backendRouteFacades }`, `./backend-route-shards.generated`),
       buildImportStatement(`{ frontendRoutes }`, `./frontend-routes.generated`)
     ];
     const allRegImports = [
       `import { registerBackendRouteManifests, registerFrontendRouteManifests } from '@open-mercato/shared/modules/registry'`
     ];
     const allCalls = [
-      `registerBackendRouteManifests(backendRoutes)`,
+      `registerBackendRouteManifests(backendRouteFacades)`,
       `registerFrontendRouteManifests(frontendRoutes)`
     ];
     for (const plugin of bootstrapPlugins) {
@@ -2698,6 +2973,8 @@ async function generateModuleRegistryAppFromDiscovery(options) {
   const bootstrapChecksumFile = path.join(outputDir, "modules.bootstrap.generated.checksum");
   const i18nOutFile = path.join(outputDir, "modules.i18n.generated.ts");
   const i18nChecksumFile = path.join(outputDir, "modules.i18n.generated.checksum");
+  const i18nLoadersOutFile = path.join(outputDir, "modules.i18n.loaders.generated.ts");
+  const i18nLoadersChecksumFile = path.join(outputDir, "modules.i18n.loaders.generated.checksum");
   const legacyOutFile = path.join(outputDir, "bootstrap-modules.generated.ts");
   const legacyChecksumFile = path.join(outputDir, "bootstrap-modules.generated.checksum");
   const enabledIdsOutFile = path.join(outputDir, "enabled-module-ids.generated.ts");
@@ -2711,6 +2988,7 @@ async function generateModuleRegistryAppFromDiscovery(options) {
   const moduleDecls = [];
   const bootstrapModuleDecls = [];
   const i18nModuleDecls = [];
+  const i18nLocaleShards = /* @__PURE__ */ new Map();
   const importIdRef = { value: 0 };
   const requiresByModule = /* @__PURE__ */ new Map();
   const commandLoaderEntries = [];
@@ -2722,6 +3000,7 @@ async function generateModuleRegistryAppFromDiscovery(options) {
     const frontendRoutes = [];
     const backendRoutes = [];
     const translations = [];
+    const localeTranslations = /* @__PURE__ */ new Map();
     const subscribers = [];
     const workers = [];
     let infoImportName = null;
@@ -2837,10 +3116,25 @@ async function generateModuleRegistryAppFromDiscovery(options) {
       appImportBase,
       pkgImportBase: imps.pkgBase,
       imports,
-      extraImports: translationImports
+      extraImports: translationImports,
+      localeOutputs: localeTranslations
     }));
-    bootstrapImports.push(...translationImports);
     i18nImports.push(...translationImports);
+    for (const [locale, localeTranslation] of localeTranslations) {
+      const shard = i18nLocaleShards.get(locale) ?? { imports: [], moduleDecls: [] };
+      shard.imports.push(...localeTranslation.imports);
+      shard.moduleDecls.push(objectLiteral([
+        { name: "id", value: modId },
+        {
+          name: "translations",
+          value: objectLiteral([{
+            name: JSON.stringify(locale),
+            value: localeTranslation.value
+          }])
+        }
+      ]));
+      i18nLocaleShards.set(locale, shard);
+    }
     subscribers.push(...processSubscribersAst(await discovered.getSubscribers()));
     workers.push(...processWorkersAst(await discovered.getWorkers()));
     {
@@ -2949,7 +3243,9 @@ async function generateModuleRegistryAppFromDiscovery(options) {
       routeAwareModuleEntries.push({ name: "backendRoutes", value: arrayLiteral(backendRoutes, writeValue) });
     }
     moduleDecls.push(objectLiteral(routeAwareModuleEntries));
-    bootstrapModuleDecls.push(objectLiteral(moduleEntries));
+    bootstrapModuleDecls.push(objectLiteral(moduleEntries.filter(
+      (entry) => entry.kind === "spread" || entry.name !== "translations"
+    )));
     i18nModuleDecls.push(objectLiteral(i18nModuleEntries));
   }
   const output = renderAstModuleRegistryFile({
@@ -3001,6 +3297,41 @@ async function generateModuleRegistryAppFromDiscovery(options) {
   writeGeneratedFile({ outFile, checksumFile, content: output, structureChecksum, result, quiet });
   writeGeneratedFile({ outFile: bootstrapOutFile, checksumFile: bootstrapChecksumFile, content: bootstrapOutput, structureChecksum, result, quiet });
   writeGeneratedFile({ outFile: i18nOutFile, checksumFile: i18nChecksumFile, content: i18nOutput, structureChecksum, result, quiet });
+  const i18nLocales = [...i18nLocaleShards.keys()].sort((a, b) => a.localeCompare(b));
+  const shardFileNames = /* @__PURE__ */ new Set();
+  const expectedShardArtifacts = /* @__PURE__ */ new Set();
+  for (const locale of i18nLocales) {
+    const fileName = buildI18nLocaleShardFileName(locale);
+    if (shardFileNames.has(fileName)) {
+      throw new Error(`Locale names produce the same generated i18n shard file: ${locale}`);
+    }
+    shardFileNames.add(fileName);
+    expectedShardArtifacts.add(fileName);
+    expectedShardArtifacts.add(fileName.replace(/\.ts$/, ".checksum"));
+    const shard = i18nLocaleShards.get(locale);
+    const content = renderAstI18nLocaleRegistryFile({
+      fileName,
+      imports: shard.imports,
+      moduleEntries: shard.moduleDecls
+    });
+    writeGeneratedFile({
+      outFile: path.join(outputDir, fileName),
+      checksumFile: path.join(outputDir, fileName.replace(/\.ts$/, ".checksum")),
+      content,
+      structureChecksum,
+      result,
+      quiet
+    });
+  }
+  removeStaleI18nLocaleShards(outputDir, expectedShardArtifacts);
+  writeGeneratedFile({
+    outFile: i18nLoadersOutFile,
+    checksumFile: i18nLoadersChecksumFile,
+    content: renderI18nLocaleLoadersFile(i18nLocales),
+    structureChecksum,
+    result,
+    quiet
+  });
   writeGeneratedFile({ outFile: legacyOutFile, checksumFile: legacyChecksumFile, content: legacyOutput, structureChecksum, result, quiet });
   const enabledIdsOutput = renderEnabledModuleIdsFile(enabled.map((entry) => entry.id));
   writeGeneratedFile({ outFile: enabledIdsOutFile, checksumFile: enabledIdsChecksumFile, content: enabledIdsOutput, structureChecksum, result, quiet });
@@ -3019,14 +3350,19 @@ async function generateModuleRegistryCliFromDiscovery(options) {
   const legacyChecksumFile = path.join(outputDir, "cli-modules.generated.checksum");
   const commandLoadersOutFile = path.join(outputDir, "command-loaders.generated.ts");
   const commandLoadersChecksumFile = path.join(outputDir, "command-loaders.generated.checksum");
+  const devSupervisorOutFile = path.join(outputDir, DEV_SUPERVISOR_MANIFEST_FILE);
+  const devSupervisorChecksumFile = path.join(outputDir, "dev-supervisor.generated.checksum");
   const enabled = discovery.enabled;
   const imports = [];
   const moduleDecls = [];
   const importIdRef = { value: 0 };
   const requiresByModule = /* @__PURE__ */ new Map();
   const commandLoaderEntries = [];
+  const devSupervisorWorkers = [];
+  let schedulerStartStatus = "missing-module";
+  let requiresFullBootstrap = enabled.some((entry) => entry.devSupervisorRequiresFullBootstrap === true) || appDeclaresProgrammaticDevSupervisorOverrides(resolver.getAppDir());
   for (const discovered of discovery.modules) {
-    const { modId, roots, imps, appImportBase } = discovered;
+    const { modId, imps, appImportBase } = discovered;
     commandLoaderEntries.push(...discovered.commandLoaderEntries);
     let cliImportName = null;
     const translations = [];
@@ -3096,11 +3432,20 @@ async function generateModuleRegistryCliFromDiscovery(options) {
       if (fields) fieldsImportName = fields.importName;
     }
     {
+      if (modId === "scheduler") schedulerStartStatus = "missing-cli";
       const cliResolved = discovered.resolve("cli.ts");
       if (cliResolved) {
         const importName = `CLI_${toVar(modId)}`;
         imports.push(buildImportStatement(importName, sanitizeGeneratedModuleSpecifier(cliResolved.importPath)));
         cliImportName = importName;
+        if (modId === "scheduler") {
+          if (sourceDeclaresCliCommand(cliResolved.absolutePath, "start")) {
+            schedulerStartStatus = "ok";
+          } else {
+            schedulerStartStatus = "missing-command";
+            requiresFullBootstrap = true;
+          }
+        }
       }
     }
     translations.push(...processTranslationsAst({
@@ -3111,7 +3456,10 @@ async function generateModuleRegistryCliFromDiscovery(options) {
       imports
     }));
     subscribers.push(...processSubscribersAst(await discovered.getSubscribers()));
-    workers.push(...processWorkersAst(await discovered.getWorkers()));
+    const discoveredWorkers = await discovered.getWorkers();
+    const workerGenerationEntries = collectWorkerGenerationEntries(discoveredWorkers, modId);
+    workers.push(...processWorkersAst(discoveredWorkers));
+    devSupervisorWorkers.push(...workerGenerationEntries.map(({ importPath: _importPath, ...worker }) => worker));
     {
       dashboardWidgetsValue = buildModuleDashboardWidgetsValue(discovered.dashboardWidgetEntries);
     }
@@ -3265,6 +3613,21 @@ async function generateModuleRegistryCliFromDiscovery(options) {
   const structureChecksum = discovery.getStructureChecksum();
   writeGeneratedFile({ outFile, checksumFile, content: output, structureChecksum, result, quiet });
   writeGeneratedFile({ outFile: legacyOutFile, checksumFile: legacyChecksumFile, content: legacyOutput, structureChecksum, result, quiet });
+  const devSupervisorOutput = `${JSON.stringify({
+    version: DEV_SUPERVISOR_MANIFEST_VERSION,
+    workers: devSupervisorWorkers,
+    schedulerStartStatus,
+    requiresFullBootstrap
+  }, null, 2)}
+`;
+  writeGeneratedFile({
+    outFile: devSupervisorOutFile,
+    checksumFile: devSupervisorChecksumFile,
+    content: devSupervisorOutput,
+    structureChecksum,
+    result,
+    quiet
+  });
   const commandLoadersOutput = renderCommandLoadersFile(commandLoaderEntries);
   writeGeneratedFile({ outFile: commandLoadersOutFile, checksumFile: commandLoadersChecksumFile, content: commandLoadersOutput, structureChecksum, result, quiet });
   return result;