@open-mercato/cli 0.6.8-develop.7099.1.7ba2771d06 → 0.7.0

package/src/lib/generators/module-registry.ts

@@ -32,7 +32,6 @@ import {
   conditionalExpression,
   createGeneratedSourceFile,
   elementAccess,
-  escapeGeneratedJsonLiteral,
   returnStatement,
   getSourceText,
   identifier,
@@ -45,7 +44,6 @@ import {
   optionalPropertyAccess,
   parenthesized,
   propertyAccess,
-  renderGeneratedValue,
   spreadExpression,
   type GeneratedObjectEntry,
   variableStatement,
@@ -135,7 +133,7 @@ type DashboardWidgetEntry = {
   importPath: string
 }
 
-export type CommandLoaderGenerationEntry = {
+type CommandLoaderGenerationEntry = {
   moduleId: string
   key: string
   importPath: string
@@ -161,7 +159,7 @@ type RuntimeApiMethodMetadata = {
 type PageRouteGenerationResult = {
   eagerRoutes: string[]
   runtimeRoutes: string[]
-  manifestRoutes: WriterFunction[]
+  manifestRoutes: string[]
   manifestShardRoutes: RouteManifestShardEntry[]
   metadataRoutes: RouteManifestShardEntry[]
   routePatterns: string[]
@@ -192,7 +190,7 @@ function assertUniqueBackendRoutePattern(
 type ApiRouteGenerationResult = {
   eagerApis: string[]
   runtimeApis: string[]
-  manifestApis: WriterFunction[]
+  manifestApis: string[]
   manifestShardApis: RouteManifestShardEntry[]
   metadataApis: RouteManifestShardEntry[]
 }
@@ -246,19 +244,8 @@ type SerializableWorkerMetadata = {
   id?: string
   queue?: string
   concurrency?: number
-  schedulerSafe?: boolean
-  schedulerRequiredFeatures?: string[]
   lockDuration?: number
   maxStalledCount?: number
-  /**
-   * Whether the worker's metadata declares an `onJobAbandoned` callback.
-   *
-   * A function cannot be serialized into the registry the way the scalar options are, so the flag is
-   * resolved here at build time and the callback itself is emitted as a lazy import beside the
-   * handler. Recorded only when the source module could actually be loaded — the object-literal
-   * fallback below cannot see whether a referenced identifier is a function.
-   */
-  hasJobAbandonedHook?: boolean
 }
 
 type PageMetadataManifestLoadResult = {
@@ -590,55 +577,6 @@ function extractObjectPropertiesFromAst(sourceFile: string, exportName: string):
   return Object.keys(result).length > 0 ? result : null
 }
 
-/**
- * Whether an exported object literal declares a property, regardless of what it evaluates to.
- *
- * Needed for callbacks: the value resolvers above can read literals and local constants, but a
- * property whose value is an imported function stays unresolvable, so "did the author declare it"
- * cannot be answered by inspecting the extracted value. Answering it from the syntax instead is what
- * lets the generator emit a lazy accessor for a hook it can see but cannot serialize.
- */
-export function namedObjectLiteralDeclaresProperty(sourceFile: string, exportName: string, propertyName: string): boolean {
-  let source = ''
-  try {
-    source = fs.readFileSync(sourceFile, 'utf8')
-  } catch {
-    return false
-  }
-
-  const parsed = ts.createSourceFile(sourceFile, source, ts.ScriptTarget.Latest, true, inferScriptKind(sourceFile))
-  const exportedNames = new Set<string>()
-  for (const statement of parsed.statements) {
-    if (
-      ts.isExportDeclaration(statement)
-      && statement.exportClause
-      && ts.isNamedExports(statement.exportClause)
-      && !statement.moduleSpecifier
-    ) {
-      for (const element of statement.exportClause.elements) exportedNames.add(element.name.text)
-    }
-  }
-
-  for (const statement of parsed.statements) {
-    if (!ts.isVariableStatement(statement)) continue
-    const exportsDirectly = (ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined)
-      ?.some((modifier: ts.Modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || declaration.name.text !== exportName) continue
-      if (!exportsDirectly && !exportedNames.has(exportName)) continue
-      const objectLiteral = unwrapObjectLiteralExpression(declaration.initializer)
-      if (!objectLiteral) return false
-      return objectLiteral.properties.some((property) => {
-        const name = property.name
-        if (!name) return false
-        const key = ts.isIdentifier(name) ? name.text : ts.isStringLiteral(name) ? name.text : null
-        return key === propertyName
-      })
-    }
-  }
-  return false
-}
-
 export function extractNamedObjectLiteralExport(sourceFile: string, exportName: string): Record<string, unknown> | null {
   const literal = extractNamedObjectLiteralSource(sourceFile, exportName)
   if (literal) {
@@ -1198,7 +1136,11 @@ function requiresRuntimePageMetadataFromSourceFile(sourceFile: string): boolean
 }
 
 function toLiteral(value: unknown): string {
-  return escapeGeneratedJsonLiteral(JSON.stringify(value))
+  return JSON.stringify(value)
+    .replace(/</g, '\\u003c')
+    .replace(/>/g, '\\u003e')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
 }
 
 const GENERATED_MODULE_RELATIVE_PREFIXES = ['@/', '../../src/modules/', './'] as const
@@ -1440,81 +1382,32 @@ function collectCommandLoaderEntries(
   return entries
 }
 
-export function renderCommandLoadersFile(entries: CommandLoaderGenerationEntry[]): string {
+function renderCommandLoadersFile(entries: CommandLoaderGenerationEntry[]): string {
   const seenCommandIds = new Map<string, string>()
-  const loaderEntries: WriterFunction[] = []
+  const rendered: string[] = []
 
   for (const entry of entries) {
-    const loadValue = arrowFunction({
-      body: importExpression(sanitizeGeneratedModuleSpecifier(entry.importPath)),
-    })
+    const loadExpr = `() => ${buildDynamicImportExpression(entry.importPath)}`
     for (const id of entry.ids) {
       const previous = seenCommandIds.get(id)
       if (previous && previous !== entry.key) {
         throw new Error(`[generate] Duplicate command id "${id}" discovered in "${previous}" and "${entry.key}"`)
       }
       seenCommandIds.set(id, entry.key)
-      loaderEntries.push(objectLiteral([
-        { name: 'moduleId', value: entry.moduleId },
-        { name: 'id', value: id },
-        { name: 'key', value: entry.key },
-        { name: 'load', value: loadValue },
-      ]))
+      rendered.push(`  { moduleId: ${toLiteral(entry.moduleId)}, id: ${toLiteral(id)}, key: ${toLiteral(entry.key)}, load: ${loadExpr} },`)
     }
-    loaderEntries.push(objectLiteral([
-      { name: 'moduleId', value: entry.moduleId },
-      { name: 'key', value: entry.key },
-      { name: 'load', value: loadValue },
-    ]))
+    rendered.push(`  { moduleId: ${toLiteral(entry.moduleId)}, key: ${toLiteral(entry.key)}, load: ${loadExpr} },`)
   }
 
-  const sourceFile = createGeneratedSourceFile('command-loaders.generated.ts')
-  addAutoGeneratedComment(sourceFile, 'command-loaders')
-
-  addImportSpec(sourceFile, {
-    moduleSpecifier: '@open-mercato/shared/lib/commands',
-    isTypeOnly: true,
-    namedImports: [{ name: 'CommandLoader' }],
-  })
+  return `// AUTO-GENERATED by mercato generate command-loaders
+import type { CommandLoader } from '@open-mercato/shared/lib/commands'
 
-  sourceFile.addVariableStatement({
-    declarationKind: VariableDeclarationKind.Const,
-    isExported: true,
-    declarations: [
-      {
-        name: 'commandLoaderEntries',
-        type: 'CommandLoader[]',
-        initializer: arrayLiteral(loaderEntries, writeValue),
-      },
-    ],
-  })
-  sourceFile.addExportAssignment({
-    isExportEquals: false,
-    expression: 'commandLoaderEntries',
-  })
+export const commandLoaderEntries: CommandLoader[] = [
+${rendered.join('\n')}
+]
 
-  return getSourceText(sourceFile)
-}
-
-export function renderBootstrapRegistrationsFile(options: {
-  entryImports: string[]
-  registrationImports: string[]
-  calls: string[]
-}): string {
-  const uniqueImports = [...new Set([...options.entryImports, ...options.registrationImports])]
-
-  const sourceFile = createGeneratedSourceFile('bootstrap-registrations.generated.ts')
-  addAutoGeneratedComment(sourceFile, 'registry')
-  addImportStatements(sourceFile, uniqueImports)
-
-  sourceFile.addFunction({
-    name: 'runBootstrapRegistrations',
-    isExported: true,
-    returnType: 'void',
-    statements: options.calls,
-  })
-
-  return getSourceText(sourceFile)
+export default commandLoaderEntries
+`
 }
 
 function serializeGeneratedImport(statement: GeneratedImportStatement): string {
@@ -1770,38 +1663,8 @@ function buildPageRouteProps(metaExpr: string, routePath: string): string {
   return `pattern: ${toLiteral(routePath || '/')}, requireAuth: (${metaExpr})?.requireAuth, requireRoles: (${metaExpr})?.requireRoles, requireFeatures: (${metaExpr})?.requireFeatures, requireCustomerAuth: (${metaExpr})?.requireCustomerAuth, requireCustomerFeatures: (${metaExpr})?.requireCustomerFeatures, nav: (${metaExpr})?.nav, title: (${metaExpr})?.pageTitle ?? (${metaExpr})?.title, titleKey: (${metaExpr})?.pageTitleKey ?? (${metaExpr})?.titleKey, group: (${metaExpr})?.pageGroup ?? (${metaExpr})?.group, groupKey: (${metaExpr})?.pageGroupKey ?? (${metaExpr})?.groupKey, icon: (${metaExpr})?.icon, order: (${metaExpr})?.pageOrder ?? (${metaExpr})?.order, priority: (${metaExpr})?.pagePriority ?? (${metaExpr})?.priority, navHidden: (${metaExpr})?.navHidden, visible: (${metaExpr})?.visible, enabled: (${metaExpr})?.enabled, breadcrumb: (${metaExpr})?.breadcrumb, pageContext: (${metaExpr})?.pageContext, placement: (${metaExpr})?.placement`
 }
 
-function buildPageRouteManifestSpread(metaExpr: string, routePath: string): WriterFunction {
-  return callExpression(identifier('resolvePageRouteMetadata'), [routePath || '/', identifier(metaExpr)])
-}
-
-function buildManifestRouteLoader(importPath: string): WriterFunction {
-  return arrowFunction({
-    async: true,
-    body: block((writer) => {
-      writeStatements(writer, [
-        variableStatement({
-          name: 'mod',
-          initializer: awaitExpression(importExpression(sanitizeGeneratedModuleSpecifier(importPath))),
-        }),
-        returnStatement(
-          asExpression(
-            parenthesized(nullishCoalesce([
-              propertyAccess(identifier('mod'), 'default'),
-              identifier('mod'),
-            ])),
-            'any',
-          ),
-        ),
-      ])
-    }),
-  })
-}
-
-function buildManifestApiLoader(importPath: string): WriterFunction {
-  return arrowFunction({
-    async: true,
-    body: importExpression(sanitizeGeneratedModuleSpecifier(importPath)),
-  })
+function buildPageRouteManifestSpread(metaExpr: string, routePath: string): string {
+  return `...resolvePageRouteMetadata(${toLiteral(routePath || '/')}, ${metaExpr})`
 }
 
 function normalizeBreadcrumb(raw: unknown): SerializablePageMetadata['breadcrumb'] {
@@ -1914,14 +1777,6 @@ function normalizeWorkerMetadata(raw: unknown): SerializableWorkerMetadata | nul
   if (typeof source.concurrency === 'number') normalized.concurrency = source.concurrency
   if (typeof source.lockDuration === 'number') normalized.lockDuration = source.lockDuration
   if (typeof source.maxStalledCount === 'number') normalized.maxStalledCount = source.maxStalledCount
-  if (typeof source.onJobAbandoned === 'function') normalized.hasJobAbandonedHook = true
-  if (source.schedulerSafe === true) normalized.schedulerSafe = true
-  if (Array.isArray(source.schedulerRequiredFeatures)) {
-    const features = source.schedulerRequiredFeatures.filter(
-      (feature): feature is string => typeof feature === 'string' && feature.length > 0,
-    )
-    if (features.length > 0) normalized.schedulerRequiredFeatures = features
-  }
   return Object.keys(normalized).length > 0 ? normalized : null
 }
 
@@ -1933,16 +1788,8 @@ async function loadSubscriberMetadata(sourceFile: string): Promise<SerializableS
 
 async function loadWorkerMetadata(sourceFile: string): Promise<SerializableWorkerMetadata | null> {
   const sourceModule = await loadModuleExportsFromSource<Record<string, unknown>>(sourceFile)
-  const metadata = normalizeWorkerMetadata(sourceModule?.metadata)
+  return normalizeWorkerMetadata(sourceModule?.metadata)
     ?? normalizeWorkerMetadata(extractNamedObjectLiteralExport(sourceFile, 'metadata'))
-  if (!metadata) return null
-  // Resolved from the syntax, not the extracted value: a worker module that cannot be imported at
-  // build time falls back to the literal extractor, which cannot tell an imported function from an
-  // unresolvable identifier. Missing this is silent — the hook is simply never installed.
-  if (!metadata.hasJobAbandonedHook && namedObjectLiteralDeclaresProperty(sourceFile, 'metadata', 'onJobAbandoned')) {
-    metadata.hasJobAbandonedHook = true
-  }
-  return metadata
 }
 
 async function discoverSubscribers(
@@ -2127,7 +1974,7 @@ async function processPageFiles(options: {
   const metaPrefix = type === 'frontend' ? 'M' : 'BM'
   const eagerRoutes: string[] = []
   const runtimeRoutes: string[] = []
-  const manifestRoutes: WriterFunction[] = []
+  const manifestRoutes: string[] = []
   const manifestShardRoutes: RouteManifestShardEntry[] = []
   const metadataRoutes: RouteManifestShardEntry[] = []
   const routePatterns: string[] = []
@@ -2202,25 +2049,18 @@ async function processPageFiles(options: {
     const manifestBaseProps = buildPageRouteManifestSpread(manifestMetaExpr, routePath)
     eagerRoutes.push(`{ ${baseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
     runtimeRoutes.push(`{ ${runtimeBaseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
-    const metadataEntries: GeneratedObjectEntry[] = [
-      { name: 'moduleId', value: modId },
-      { kind: 'spread', value: manifestBaseProps },
-    ]
-    const manifestEntry = objectLiteral([
-      ...metadataEntries,
-      { name: 'load', value: buildManifestRouteLoader(importPath) },
-    ])
-    const shardImports = manifestImportStatement ? [manifestImportStatement] : []
-    manifestRoutes.push(manifestEntry)
+    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: renderGeneratedValue(manifestEntry),
-      imports: shardImports,
+      declaration: manifestDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : [],
     })
     metadataRoutes.push({
       path: routePath,
-      declaration: renderGeneratedValue(objectLiteral(metadataEntries)),
-      imports: shardImports,
+      declaration: metadataDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : [],
     })
     routePatterns.push(routePath)
   }
@@ -2300,25 +2140,18 @@ async function processPageFiles(options: {
     const manifestBaseProps = buildPageRouteManifestSpread(manifestMetaExpr, routePath)
     eagerRoutes.push(`{ ${baseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
     runtimeRoutes.push(`{ ${runtimeBaseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
-    const metadataEntries: GeneratedObjectEntry[] = [
-      { name: 'moduleId', value: modId },
-      { kind: 'spread', value: manifestBaseProps },
-    ]
-    const manifestEntry = objectLiteral([
-      ...metadataEntries,
-      { name: 'load', value: buildManifestRouteLoader(importPath) },
-    ])
-    const shardImports = manifestImportStatement ? [manifestImportStatement] : []
-    manifestRoutes.push(manifestEntry)
+    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: renderGeneratedValue(manifestEntry),
-      imports: shardImports,
+      declaration: manifestDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : [],
     })
     metadataRoutes.push({
       path: routePath,
-      declaration: renderGeneratedValue(objectLiteral(metadataEntries)),
-      imports: shardImports,
+      declaration: metadataDeclaration,
+      imports: manifestImportStatement ? [manifestImportStatement] : [],
     })
     routePatterns.push(routePath)
   }
@@ -2350,7 +2183,7 @@ async function processApiRoutes(options: {
 
   const eagerApis: string[] = []
   const runtimeApis: string[] = []
-  const manifestApis: WriterFunction[] = []
+  const manifestApis: string[] = []
   const manifestShardApis: RouteManifestShardEntry[] = []
   const metadataApis: RouteManifestShardEntry[] = []
 
@@ -2383,19 +2216,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(', ')} } }`)
-    const metadataEntries: GeneratedObjectEntry[] = [
-      { name: 'moduleId', value: modId },
-      { name: 'kind', value: 'route-file' },
-      { name: 'path', value: resolvedPath },
-      { name: 'methods', value: arrayLiteral(exportedMethods, writeValue) },
-    ]
-    const manifestEntry = objectLiteral([
-      ...metadataEntries,
-      { name: 'load', value: buildManifestApiLoader(importPath) },
-    ])
-    manifestApis.push(manifestEntry)
-    manifestShardApis.push({ path: resolvedPath, declaration: renderGeneratedValue(manifestEntry) })
-    metadataApis.push({ path: resolvedPath, declaration: renderGeneratedValue(objectLiteral(metadataEntries)) })
+    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 })
   }
 
   // Single files (plain scripts, not route.*, not tests, skip method dirs)
@@ -2427,19 +2252,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(', ')} } }`)
-    const metadataEntries: GeneratedObjectEntry[] = [
-      { name: 'moduleId', value: modId },
-      { name: 'kind', value: 'route-file' },
-      { name: 'path', value: resolvedPath },
-      { name: 'methods', value: arrayLiteral(exportedMethods, writeValue) },
-    ]
-    const manifestEntry = objectLiteral([
-      ...metadataEntries,
-      { name: 'load', value: buildManifestApiLoader(importPath) },
-    ])
-    manifestApis.push(manifestEntry)
-    manifestShardApis.push({ path: resolvedPath, declaration: renderGeneratedValue(manifestEntry) })
-    metadataApis.push({ path: resolvedPath, declaration: renderGeneratedValue(objectLiteral(metadataEntries)) })
+    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 })
   }
 
   // Legacy per-method
@@ -2481,20 +2298,11 @@ 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} }`)
-      const metadataEntries: GeneratedObjectEntry[] = [
-        { name: 'moduleId', value: modId },
-        { name: 'kind', value: 'legacy' },
-        { name: 'method', value: method },
-        { name: 'path', value: resolvedPath },
-        { name: 'methods', value: arrayLiteral([method], writeValue) },
-      ]
-      const manifestEntry = objectLiteral([
-        ...metadataEntries,
-        { name: 'load', value: buildManifestApiLoader(importPath) },
-      ])
-      manifestApis.push(manifestEntry)
-      manifestShardApis.push({ path: resolvedPath, declaration: renderGeneratedValue(manifestEntry) })
-      metadataApis.push({ path: resolvedPath, declaration: renderGeneratedValue(objectLiteral(metadataEntries)) })
+      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 })
     }
   }
 
@@ -2507,17 +2315,62 @@ async function processApiRoutes(options: {
   }
 }
 
-/**
- * Registry helper emitted for a worker that declares `metadata.onJobAbandoned`.
- *
- * Named once because two things must stay in step: the call the worker entry renders, and the import
- * the file needs for it. A generated file that references this without importing it type-checks
- * nowhere, and only fails at `build:app` — see `generated-registry-imports.test.ts`.
- */
-const ABANDON_HOOK_FACTORY = 'createLazyModuleWorkerAbandonHook'
+function processSubscribers(discovered: DiscoveredSubscriber[]): string[] {
+  const subscribers: string[] = []
+  for (const { id, importPath, metadata } of discovered) {
+    const subscriberId = metadata?.id ?? id
+    subscribers.push(
+      `{ id: ${toLiteral(subscriberId)}, event: ${toLiteral(metadata?.event ?? '')}, persistent: ${metadata?.persistent === undefined ? 'undefined' : toLiteral(metadata.persistent)}, sync: ${metadata?.sync === undefined ? 'undefined' : toLiteral(metadata.sync)}, priority: ${metadata?.priority === undefined ? 'undefined' : toLiteral(metadata.priority)}, handler: createLazyModuleSubscriber(() => ${buildDynamicImportExpression(importPath)}, ${toLiteral(subscriberId)}) }`
+    )
+  }
+  return subscribers
+}
 
-function workersDeclareAbandonHook(discovered: DiscoveredWorker[]): boolean {
-  return discovered.some(({ metadata }) => metadata.hasJobAbandonedHook === true)
+function processWorkers(discovered: DiscoveredWorker[]): string[] {
+  const workers: string[] = []
+  for (const { id, importPath, metadata } of discovered) {
+    const workerId = metadata.id ?? id
+    workers.push(
+      `{ id: ${toLiteral(workerId)}, queue: ${toLiteral(metadata.queue)}, concurrency: ${toLiteral(metadata.concurrency ?? 1)}${metadata.lockDuration === undefined ? '' : `, lockDuration: ${toLiteral(metadata.lockDuration)}`}${metadata.maxStalledCount === undefined ? '' : `, maxStalledCount: ${toLiteral(metadata.maxStalledCount)}`}, handler: createLazyModuleWorker(() => ${buildDynamicImportExpression(importPath)}, ${toLiteral(workerId)}) }`
+    )
+  }
+  return workers
+}
+
+function processTranslations(options: {
+  discovered: DiscoveredTranslation[]
+  modId: string
+  appImportBase: string
+  pkgImportBase: string
+  imports: string[]
+  extraImports?: string[]
+}): string[] {
+  const { discovered, modId, appImportBase, pkgImportBase, imports, extraImports } = options
+  const translations: string[] = []
+  for (const { locale, coreHas, appHas } of discovered) {
+    if (coreHas && appHas) {
+      const cName = `T_${toVar(modId)}_${toVar(locale)}_C`
+      const aName = `T_${toVar(modId)}_${toVar(locale)}_A`
+      imports.push(buildImportStatement(cName, `${pkgImportBase}/i18n/${locale}.json`))
+      imports.push(buildImportStatement(aName, `${appImportBase}/i18n/${locale}.json`))
+      extraImports?.push(buildImportStatement(cName, `${pkgImportBase}/i18n/${locale}.json`))
+      extraImports?.push(buildImportStatement(aName, `${appImportBase}/i18n/${locale}.json`))
+      translations.push(
+        `'${locale}': { ...( ${cName} as unknown as Record<string,string> ), ...( ${aName} as unknown as Record<string,string> ) }`
+      )
+    } else if (appHas) {
+      const aName = `T_${toVar(modId)}_${toVar(locale)}_A`
+      imports.push(buildImportStatement(aName, `${appImportBase}/i18n/${locale}.json`))
+      extraImports?.push(buildImportStatement(aName, `${appImportBase}/i18n/${locale}.json`))
+      translations.push(`'${locale}': ${aName} as unknown as Record<string,string>`)
+    } else if (coreHas) {
+      const cName = `T_${toVar(modId)}_${toVar(locale)}_C`
+      imports.push(buildImportStatement(cName, `${pkgImportBase}/i18n/${locale}.json`))
+      extraImports?.push(buildImportStatement(cName, `${pkgImportBase}/i18n/${locale}.json`))
+      translations.push(`'${locale}': ${cName} as unknown as Record<string,string>`)
+    }
+  }
+  return translations
 }
 
 /**
@@ -2664,64 +2517,6 @@ function buildModuleDashboardWidgetsValue(entries: DashboardWidgetEntry[]): Writ
   )
 }
 
-/**
- * Wraps expressions that are still produced as pre-rendered strings by collaborators this
- * change does not convert (page routes, api handlers, dashboard widgets) so they can sit
- * inside an AST-built array without being re-quoted as string literals. It disappears once
- * those producers emit writers themselves — see the follow-up noted in the spec's Non-Goals.
- */
-function preRenderedExpressionList(expressions: readonly string[]): WriterFunction {
-  return arrayLiteral(expressions.map((expression) => identifier(expression)), writeValue)
-}
-
-/**
- * `(X.<first> ?? X.<second>)` — the member-fallback shape the main registry path emits.
- * It is deliberately not `namespaceFallback`, which the app path uses: that helper walks
- * the members in an IIFE and treats only `!= null` as present, which is a different
- * expression. Converging the two is a behaviour change, not a formatting one.
- */
-function legacyNamespaceMemberFallback(importName: string, members: readonly [string, string]): WriterFunction {
-  return parenthesized(nullishCoalesce([
-    propertyAccess(identifier(importName), members[0]),
-    propertyAccess(identifier(importName), members[1]),
-  ]))
-}
-
-function buildLegacyModuleListValue(options: {
-  importName: string
-  members: readonly [string, string]
-  castType: string
-}): WriterFunction {
-  return logicalOr([
-    asExpression(legacyNamespaceMemberFallback(options.importName, options.members), options.castType),
-    emptyArray(),
-  ])
-}
-
-function buildLegacyModuleSetupValue(importName: string): WriterFunction {
-  return logicalOr([
-    legacyNamespaceMemberFallback(importName, ['default', 'setup']),
-    identifier('undefined'),
-  ])
-}
-
-function buildLegacyIntegrationListValue(
-  importName: string,
-  pluralMember: string,
-  singularMember: string,
-  castType: string,
-): WriterFunction {
-  const singular = propertyAccess(identifier(importName), singularMember)
-
-  return asExpression(
-    parenthesized(nullishCoalesce([
-      propertyAccess(identifier(importName), pluralMember),
-      parenthesized(conditionalExpression(singular, arrayLiteral([singular], writeValue), emptyArray())),
-    ])),
-    castType,
-  )
-}
-
 function buildModuleIntegrationListValue(
   importName: string,
   pluralMember: string,
@@ -2769,15 +2564,9 @@ function buildModulesInfoExpression(): WriterFunction {
 function renderAstModuleRegistryFile(options: {
   fileName: string
   generator: string
-  /**
-   * Import statements, or the structured specs generator extensions push onto the shared
-   * import array via `processStandaloneConfig`. Both shapes reach this emitter at runtime,
-   * so both are normalised here rather than at each call site.
-   */
-  imports: GeneratedImportStatement[]
+  imports: string[]
   moduleEntries: WriterFunction[]
   includeCreateElementImport?: boolean
-  includeAbandonHookImport?: boolean
 }): string {
   const sourceFile = createGeneratedSourceFile(options.fileName)
   addAutoGeneratedComment(sourceFile, options.generator)
@@ -2793,11 +2582,10 @@ function renderAstModuleRegistryFile(options: {
     namedImports: [
       { name: 'createLazyModuleSubscriber' },
       { name: 'createLazyModuleWorker' },
-      ...(options.includeAbandonHookImport ? [{ name: ABANDON_HOOK_FACTORY }] : []),
       { name: 'Module', isTypeOnly: true },
     ],
   })
-  addImportStatements(sourceFile, options.imports.map((entry) => serializeGeneratedImport(entry)))
+  addImportStatements(sourceFile, options.imports)
 
   sourceFile.addVariableStatement({
     declarationKind: VariableDeclarationKind.Const,
@@ -2828,52 +2616,6 @@ function renderAstModuleRegistryFile(options: {
   return getSourceText(sourceFile)
 }
 
-function renderAstManifestFile(options: {
-  fileName: string
-  typeName: string
-  exportName: string
-  imports?: string[]
-  entries: WriterFunction[]
-}): string {
-  const sourceFile = createGeneratedSourceFile(options.fileName)
-  addAutoGeneratedComment(sourceFile, 'registry')
-
-  const usesPageRouteMetadataHelper = options.typeName === 'FrontendRouteManifestEntry'
-    || options.typeName === 'BackendRouteManifestEntry'
-  addImportSpec(sourceFile, usesPageRouteMetadataHelper
-    ? {
-      moduleSpecifier: '@open-mercato/shared/modules/registry',
-      namedImports: [
-        { name: 'resolvePageRouteMetadata' },
-        { name: options.typeName, isTypeOnly: true },
-      ],
-    }
-    : {
-      moduleSpecifier: '@open-mercato/shared/modules/registry',
-      isTypeOnly: true,
-      namedImports: [{ name: options.typeName }],
-    })
-  addImportStatements(sourceFile, options.imports ?? [])
-
-  sourceFile.addVariableStatement({
-    declarationKind: VariableDeclarationKind.Const,
-    isExported: true,
-    declarations: [
-      {
-        name: options.exportName,
-        type: `${options.typeName}[]`,
-        initializer: arrayLiteral(options.entries, writeValue),
-      },
-    ],
-  })
-  sourceFile.addExportAssignment({
-    isExportEquals: false,
-    expression: options.exportName,
-  })
-
-  return getSourceText(sourceFile)
-}
-
 function renderAstLegacyAliasFile(options: {
   fileName: string
   exportName: string
@@ -2937,10 +2679,62 @@ function renderEnabledModuleIdsFile(moduleIds: readonly string[]): string {
   return getSourceText(sourceFile)
 }
 
+function renderLegacyCompatibleArray(entries: readonly string[]): string {
+  return `[
+  ${entries.join(',\n  ')}
+]`
+}
+
 function buildLazyRouteComponentExpression(importPath: string): string {
   return `async (props: any) => { const mod = await ${buildDynamicImportExpression(importPath)}; const Component = (mod.default ?? mod) as any; return createElement(Component, props) }`
 }
 
+function renderAstLegacyModuleRegistryOutput(options: {
+  fileName: string
+  imports: GeneratedImportStatement[]
+  moduleEntries: string[]
+  includeCreateElementImport?: boolean
+}): string {
+  const importSection = [
+    ...(options.includeCreateElementImport ? ["import { createElement } from 'react'"] : []),
+    "import { createLazyModuleSubscriber, createLazyModuleWorker, type Module } from '@open-mercato/shared/modules/registry'",
+    ...options.imports.map((entry) => serializeGeneratedImport(entry)),
+  ].join('\n')
+
+  return `// AUTO-GENERATED by mercato generate registry
+${importSection}
+
+export const modules: Module[] = ${renderLegacyCompatibleArray(options.moduleEntries)}
+export const modulesInfo = modules.map(m => ({ id: m.id, ...(m.info || {}) }))
+export default modules
+`
+}
+
+function renderAstLegacyManifestOutput(options: {
+  fileName: string
+  typeName: string
+  exportName: string
+  imports?: GeneratedImportStatement[]
+  entries: string[]
+}): string {
+  const usesPageRouteMetadataHelper = options.typeName === 'FrontendRouteManifestEntry'
+    || options.typeName === 'BackendRouteManifestEntry'
+  const importSection = [
+    usesPageRouteMetadataHelper
+      ? `import { resolvePageRouteMetadata, type ${options.typeName} } from '@open-mercato/shared/modules/registry'`
+      : `import type { ${options.typeName} } from '@open-mercato/shared/modules/registry'`,
+    ...(options.imports ?? []).map((entry) => serializeGeneratedImport(entry)),
+  ].join('\n')
+
+  return `// AUTO-GENERATED by mercato generate registry
+${importSection}
+
+export const ${options.exportName}: ${options.typeName}[] = ${renderLegacyCompatibleArray(options.entries)}
+
+export default ${options.exportName}
+`
+}
+
 function buildRuntimeRouteComponent(importPath: string): WriterFunction {
   return arrowFunction({
     async: true,
@@ -3215,21 +3009,8 @@ function processWorkersAst(discovered: DiscoveredWorker[]): WriterFunction[] {
         { name: 'id', value: workerId },
         { name: 'queue', value: metadata.queue },
         { name: 'concurrency', value: metadata.concurrency ?? 1 },
-        ...(metadata.schedulerSafe === true ? [{ name: 'schedulerSafe', value: true }] : []),
-        ...(metadata.schedulerRequiredFeatures
-          ? [{ name: 'schedulerRequiredFeatures', value: arrayLiteral(metadata.schedulerRequiredFeatures, writeValue) }]
-          : []),
         ...(metadata.lockDuration === undefined ? [] : [{ name: 'lockDuration', value: metadata.lockDuration }]),
         ...(metadata.maxStalledCount === undefined ? [] : [{ name: 'maxStalledCount', value: metadata.maxStalledCount }]),
-        ...(metadata.hasJobAbandonedHook
-          ? [{
-            name: 'onJobAbandoned',
-            value: callExpression(identifier(ABANDON_HOOK_FACTORY), [
-              arrowFunction({ body: importExpression(importPath) }),
-              workerId,
-            ]),
-          }]
-          : []),
         {
           name: 'handler',
           value: callExpression(identifier('createLazyModuleWorker'), [
@@ -3589,11 +3370,11 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
   const runtimeImports: string[] = []
   const frontendRouteManifestImports: string[] = []
   const backendRouteManifestImports: string[] = []
-  const moduleDecls: WriterFunction[] = []
-  const runtimeModuleDecls: WriterFunction[] = []
-  const frontendRouteManifestDecls: WriterFunction[] = []
-  const backendRouteManifestDecls: WriterFunction[] = []
-  const apiRouteManifestDecls: WriterFunction[] = []
+  const moduleDecls: string[] = []
+  const runtimeModuleDecls: string[] = []
+  const frontendRouteManifestDecls: string[] = []
+  const backendRouteManifestDecls: string[] = []
+  const apiRouteManifestDecls: string[] = []
   const backendRouteShardEntries: RouteManifestShardEntry[] = []
   const backendRouteMetadataEntries: RouteManifestShardEntry[] = []
   const apiRouteShardEntries: RouteManifestShardEntry[] = []
@@ -3603,7 +3384,6 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
   const requiresByModule = new Map<string, string[]>()
   const commandLoaderEntries: CommandLoaderGenerationEntry[] = []
   let hasRouteComponents = false
-  let hasAbandonHookWorkers = false
 
   // UMES conflict detection: collect file paths during module processing
   const umesConflictSources: Array<{
@@ -3626,9 +3406,9 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
     const runtimeBackendRoutes: string[] = []
     const runtimeApis: string[] = []
     let cliImportName: string | null = null
-    const translations: GeneratedObjectEntry[] = []
-    const subscribers: WriterFunction[] = []
-    const workers: WriterFunction[] = []
+    const translations: string[] = []
+    const subscribers: string[] = []
+    const workers: string[] = []
     let infoImportName: string | null = null
     let extensionsImportName: string | null = null
     let fieldsImportName: string | null = null
@@ -3842,7 +3622,7 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
     }
 
     // 16. Translations
-    translations.push(...processTranslationsAst({
+    translations.push(...processTranslations({
       discovered: discovered.translations,
       modId,
       appImportBase,
@@ -3852,12 +3632,10 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
     }))
 
     // 17. Subscribers
-    subscribers.push(...processSubscribersAst(await discovered.getSubscribers()))
+    subscribers.push(...processSubscribers(await discovered.getSubscribers()))
 
     // 18. Workers
-    const discoveredWorkersForModule = await discovered.getWorkers()
-    if (workersDeclareAbandonHook(discoveredWorkersForModule)) hasAbandonHookWorkers = true
-    workers.push(...processWorkersAst(discoveredWorkersForModule))
+    workers.push(...processWorkers(await discovered.getWorkers()))
 
     // Build combined customFieldSets expression
     {
@@ -3880,120 +3658,44 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
       }
     }
 
-    const identityEntries: GeneratedObjectEntry[] = [{ name: 'id', value: modId }]
-    if (infoImportName) {
-      identityEntries.push({ name: 'info', value: propertyAccess(identifier(infoImportName), 'metadata') })
-    }
-
-    const sharedTailEntries: GeneratedObjectEntry[] = []
-    if (translations.length > 0) {
-      sharedTailEntries.push({ name: 'translations', value: objectLiteral(translations) })
-    }
-    if (subscribers.length > 0) {
-      sharedTailEntries.push({ name: 'subscribers', value: arrayLiteral(subscribers, writeValue) })
-    }
-    if (workers.length > 0) {
-      sharedTailEntries.push({ name: 'workers', value: arrayLiteral(workers, writeValue) })
-    }
-    if (extensionsImportName) {
-      sharedTailEntries.push({
-        name: 'entityExtensions',
-        value: buildLegacyModuleListValue({
-          importName: extensionsImportName,
-          members: ['default', 'extensions'],
-          castType: "import('@open-mercato/shared/modules/entities').EntityExtension[]",
-        }),
-      })
-    }
-    sharedTailEntries.push({ name: 'customFieldSets', value: identifier(customFieldSetsExpr) })
-    if (featuresImportName) {
-      sharedTailEntries.push({
-        name: 'features',
-        value: buildLegacyModuleListValue({
-          importName: featuresImportName,
-          members: ['default', 'features'],
-          castType: 'any',
-        }),
-      })
-    }
-    if (customEntitiesImportName) {
-      sharedTailEntries.push({
-        name: 'customEntities',
-        value: buildLegacyModuleListValue({
-          importName: customEntitiesImportName,
-          members: ['default', 'entities'],
-          castType: 'any',
-        }),
-      })
-    }
-
-    const setupAndBeyondEntries: GeneratedObjectEntry[] = []
-    if (setupImportName) {
-      setupAndBeyondEntries.push({ name: 'setup', value: buildLegacyModuleSetupValue(setupImportName) })
-    }
-    if (encryptionImportName) {
-      setupAndBeyondEntries.push({
-        name: 'defaultEncryptionMaps',
-        value: buildLegacyModuleListValue({
-          importName: encryptionImportName,
-          members: ['default', 'defaultEncryptionMaps'],
-          castType: "import('@open-mercato/shared/modules/encryption').ModuleEncryptionMap[]",
-        }),
-      })
-    }
-    if (integrationExports) {
-      setupAndBeyondEntries.push({
-        name: 'integrations',
-        value: buildLegacyIntegrationListValue(
-          integrationExports,
-          'integrations',
-          'integration',
-          "import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]",
-        ),
-      })
-      setupAndBeyondEntries.push({
-        name: 'bundles',
-        value: buildLegacyIntegrationListValue(
-          integrationExports,
-          'bundles',
-          'bundle',
-          "import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]",
-        ),
-      })
-    }
-
-    const eagerEntries: GeneratedObjectEntry[] = [...identityEntries]
-    if (frontendRoutes.length > 0) {
-      eagerEntries.push({ name: 'frontendRoutes', value: preRenderedExpressionList(frontendRoutes) })
-    }
-    if (backendRoutes.length > 0) {
-      eagerEntries.push({ name: 'backendRoutes', value: preRenderedExpressionList(backendRoutes) })
-    }
-    if (apis.length > 0) {
-      eagerEntries.push({ name: 'apis', value: preRenderedExpressionList(apis) })
-    }
-    if (cliImportName) {
-      eagerEntries.push({ name: 'cli', value: identifier(cliImportName) })
-    }
-    eagerEntries.push(...sharedTailEntries)
-    if (dashboardWidgets.length > 0) {
-      eagerEntries.push({ name: 'dashboardWidgets', value: preRenderedExpressionList(dashboardWidgets) })
-    }
-    eagerEntries.push(...setupAndBeyondEntries)
-    moduleDecls.push(objectLiteral(eagerEntries))
-
-    const runtimeEntries: GeneratedObjectEntry[] = [...identityEntries]
-    if (runtimeFrontendRoutes.length > 0) {
-      runtimeEntries.push({ name: 'frontendRoutes', value: preRenderedExpressionList(runtimeFrontendRoutes) })
-    }
-    if (runtimeBackendRoutes.length > 0) {
-      runtimeEntries.push({ name: 'backendRoutes', value: preRenderedExpressionList(runtimeBackendRoutes) })
-    }
-    if (runtimeApis.length > 0) {
-      runtimeEntries.push({ name: 'apis', value: preRenderedExpressionList(runtimeApis) })
-    }
-    runtimeEntries.push(...sharedTailEntries, ...setupAndBeyondEntries)
-    runtimeModuleDecls.push(objectLiteral(runtimeEntries))
+    moduleDecls.push(`{
+      id: ${toLiteral(modId)},
+      ${infoImportName ? `info: ${infoImportName}.metadata,` : ''}
+      ${frontendRoutes.length ? `frontendRoutes: [${frontendRoutes.join(', ')}],` : ''}
+      ${backendRoutes.length ? `backendRoutes: [${backendRoutes.join(', ')}],` : ''}
+      ${apis.length ? `apis: [${apis.join(', ')}],` : ''}
+      ${cliImportName ? `cli: ${cliImportName},` : ''}
+      ${translations.length ? `translations: { ${translations.join(', ')} },` : ''}
+      ${subscribers.length ? `subscribers: [${subscribers.join(', ')}],` : ''}
+      ${workers.length ? `workers: [${workers.join(', ')}],` : ''}
+      ${extensionsImportName ? `entityExtensions: ((${extensionsImportName}.default ?? ${extensionsImportName}.extensions) as import('@open-mercato/shared/modules/entities').EntityExtension[]) || [],` : ''}
+      customFieldSets: ${customFieldSetsExpr},
+      ${featuresImportName ? `features: ((${featuresImportName}.default ?? ${featuresImportName}.features) as any) || [],` : ''}
+      ${customEntitiesImportName ? `customEntities: ((${customEntitiesImportName}.default ?? ${customEntitiesImportName}.entities) as any) || [],` : ''}
+      ${dashboardWidgets.length ? `dashboardWidgets: [${dashboardWidgets.join(', ')}],` : ''}
+      ${setupImportName ? `setup: (${setupImportName}.default ?? ${setupImportName}.setup) || undefined,` : ''}
+      ${encryptionImportName ? `defaultEncryptionMaps: ((${encryptionImportName}.default ?? ${encryptionImportName}.defaultEncryptionMaps) as import('@open-mercato/shared/modules/encryption').ModuleEncryptionMap[]) || [],` : ''}
+      ${integrationExports ? `integrations: ((${integrationExports}.integrations ?? (${integrationExports}.integration ? [${integrationExports}.integration] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]),` : ''}
+      ${integrationExports ? `bundles: ((${integrationExports}.bundles ?? (${integrationExports}.bundle ? [${integrationExports}.bundle] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]),` : ''}
+    }`)
+    runtimeModuleDecls.push(`{
+      id: ${toLiteral(modId)},
+      ${infoImportName ? `info: ${infoImportName}.metadata,` : ''}
+      ${runtimeFrontendRoutes.length ? `frontendRoutes: [${runtimeFrontendRoutes.join(', ')}],` : ''}
+      ${runtimeBackendRoutes.length ? `backendRoutes: [${runtimeBackendRoutes.join(', ')}],` : ''}
+      ${runtimeApis.length ? `apis: [${runtimeApis.join(', ')}],` : ''}
+      ${translations.length ? `translations: { ${translations.join(', ')} },` : ''}
+      ${subscribers.length ? `subscribers: [${subscribers.join(', ')}],` : ''}
+      ${workers.length ? `workers: [${workers.join(', ')}],` : ''}
+      ${extensionsImportName ? `entityExtensions: ((${extensionsImportName}.default ?? ${extensionsImportName}.extensions) as import('@open-mercato/shared/modules/entities').EntityExtension[]) || [],` : ''}
+      customFieldSets: ${customFieldSetsExpr},
+      ${featuresImportName ? `features: ((${featuresImportName}.default ?? ${featuresImportName}.features) as any) || [],` : ''}
+      ${customEntitiesImportName ? `customEntities: ((${customEntitiesImportName}.default ?? ${customEntitiesImportName}.entities) as any) || [],` : ''}
+      ${setupImportName ? `setup: (${setupImportName}.default ?? ${setupImportName}.setup) || undefined,` : ''}
+      ${encryptionImportName ? `defaultEncryptionMaps: ((${encryptionImportName}.default ?? ${encryptionImportName}.defaultEncryptionMaps) as import('@open-mercato/shared/modules/encryption').ModuleEncryptionMap[]) || [],` : ''}
+      ${integrationExports ? `integrations: ((${integrationExports}.integrations ?? (${integrationExports}.integration ? [${integrationExports}.integration] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]),` : ''}
+      ${integrationExports ? `bundles: ((${integrationExports}.bundles ?? (${integrationExports}.bundle ? [${integrationExports}.bundle] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]),` : ''}
+    }`)
   }
 
   // === UMES Conflict Detection ===
@@ -4094,37 +3796,33 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
     }
   }
 
-  const output = renderAstModuleRegistryFile({
+  const output = renderAstLegacyModuleRegistryOutput({
     fileName: 'modules.generated.ts',
-    generator: 'registry',
     imports,
     moduleEntries: moduleDecls,
     includeCreateElementImport: hasRouteComponents,
-    includeAbandonHookImport: hasAbandonHookWorkers,
   })
-  const runtimeOutput = renderAstModuleRegistryFile({
+  const runtimeOutput = renderAstLegacyModuleRegistryOutput({
     fileName: 'modules.runtime.generated.ts',
-    generator: 'registry',
     imports: runtimeImports,
     moduleEntries: runtimeModuleDecls,
     includeCreateElementImport: true,
-    includeAbandonHookImport: hasAbandonHookWorkers,
   })
-  const frontendRoutesOutput = renderAstManifestFile({
+  const frontendRoutesOutput = renderAstLegacyManifestOutput({
     fileName: 'frontend-routes.generated.ts',
     typeName: 'FrontendRouteManifestEntry',
     exportName: 'frontendRoutes',
     imports: frontendRouteManifestImports,
     entries: frontendRouteManifestDecls,
   })
-  const backendRoutesOutput = renderAstManifestFile({
+  const backendRoutesOutput = renderAstLegacyManifestOutput({
     fileName: 'backend-routes.generated.ts',
     typeName: 'BackendRouteManifestEntry',
     exportName: 'backendRoutes',
     imports: backendRouteManifestImports,
     entries: backendRouteManifestDecls,
   })
-  const apiRoutesOutput = renderAstManifestFile({
+  const apiRoutesOutput = renderAstLegacyManifestOutput({
     fileName: 'api-routes.generated.ts',
     typeName: 'ApiRouteManifestEntry',
     exportName: 'apiRoutes',
@@ -4264,11 +3962,15 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
       allRegImports.push(...reg.registrationImports)
       allCalls.push(reg.buildCall(reg.entriesExportName))
     }
-    const bootstrapRegsOutput = renderBootstrapRegistrationsFile({
-      entryImports: allEntryImports,
-      registrationImports: allRegImports,
-      calls: allCalls,
-    })
+    const uniqueImports = [...new Set([...allEntryImports, ...allRegImports])]
+    const importSection = uniqueImports.join('\n')
+    const body = `  ${allCalls.join('\n  ')}`
+    const bootstrapRegsOutput = `// AUTO-GENERATED by mercato generate registry
+${importSection ? `${importSection}\n` : ''}
+export function runBootstrapRegistrations(): void {
+${body}
+}
+`
     writeGeneratedFile({ outFile: bootstrapRegsOutFile, checksumFile: bootstrapRegsChecksumFile, content: bootstrapRegsOutput, structureChecksum, result, quiet })
   }
 
@@ -4308,7 +4010,6 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
   const requiresByModule = new Map<string, string[]>()
   const commandLoaderEntries: CommandLoaderGenerationEntry[] = []
   let hasRouteComponents = false
-  let hasAbandonHookWorkers = false
   const seenBackendRoutePatterns = new Map<string, string>()
 
   for (const discovered of discovery.modules) {
@@ -4470,9 +4171,7 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
 
     subscribers.push(...processSubscribersAst(await discovered.getSubscribers()))
 
-    const discoveredWorkersForModule = await discovered.getWorkers()
-    if (workersDeclareAbandonHook(discoveredWorkersForModule)) hasAbandonHookWorkers = true
-    workers.push(...processWorkersAst(discoveredWorkersForModule))
+    workers.push(...processWorkersAst(await discovered.getWorkers()))
 
     {
       dashboardWidgetsValue = buildModuleDashboardWidgetsValue(discovered.dashboardWidgetEntries)
@@ -4596,21 +4295,18 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
     imports,
     moduleEntries: moduleDecls,
     includeCreateElementImport: hasRouteComponents,
-    includeAbandonHookImport: hasAbandonHookWorkers,
   })
   const bootstrapOutput = renderAstModuleRegistryFile({
     fileName: 'modules.bootstrap.generated.ts',
     generator: 'registry (bootstrap version)',
     imports: bootstrapImports,
     moduleEntries: bootstrapModuleDecls,
-    includeAbandonHookImport: hasAbandonHookWorkers,
   })
   const i18nOutput = renderAstModuleRegistryFile({
     fileName: 'modules.i18n.generated.ts',
     generator: 'registry (i18n version)',
     imports: i18nImports,
     moduleEntries: i18nModuleDecls,
-    includeAbandonHookImport: hasAbandonHookWorkers,
   })
   const legacyOutput = renderAstLegacyAliasFile({
     fileName: 'bootstrap-modules.generated.ts',
@@ -4701,7 +4397,6 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
  * Excludes: frontend routes, backend routes, API handlers, injection widgets
  */
 async function generateModuleRegistryCliFromDiscovery(options: ModuleRegistryRenderOptions): Promise<GeneratorResult> {
-  let hasAbandonHookWorkers = false
   const { resolver, quiet = false } = options
   const { discovery } = options
   const result = createGeneratorResult()
@@ -4853,7 +4548,6 @@ async function generateModuleRegistryCliFromDiscovery(options: ModuleRegistryRen
     // Workers
     const discoveredWorkers = await discovered.getWorkers()
     const workerGenerationEntries = collectWorkerGenerationEntries(discoveredWorkers, modId)
-    if (workersDeclareAbandonHook(discoveredWorkers)) hasAbandonHookWorkers = true
     workers.push(...processWorkersAst(discoveredWorkers))
     devSupervisorWorkers.push(...workerGenerationEntries.map(({ importPath: _importPath, ...worker }) => worker))
 
@@ -4977,7 +4671,6 @@ async function generateModuleRegistryCliFromDiscovery(options: ModuleRegistryRen
     generator: 'registry (CLI version)',
     imports,
     moduleEntries: moduleDecls,
-    includeAbandonHookImport: hasAbandonHookWorkers,
   })
   const legacyOutput = renderAstLegacyAliasFile({
     fileName: 'cli-modules.generated.ts',