@pattern-stack/codegen 0.17.2 → 0.19.0

package/dist/src/cli/index.js

@@ -17,11 +17,13 @@ import {
   getManifestDir,
   getOrchestrationPatternNames,
   getPendingSuggestions,
+  isActiveProvider,
   isManifestStale,
   loadAppPatterns,
   loadEntities,
   loadEntitiesFromYaml,
   loadEntityFromYaml,
+  loadEntityRegistry,
   loadEventFromYaml,
   loadJunctionFromYaml,
   loadProvidersFromYaml,
@@ -36,35 +38,35 @@ import {
   validateOrchestrationProject,
   validateProviders,
   writeManifest
-} from "../../chunk-IOQMMH6C.js";
+} from "../../chunk-F7KN3U6U.js";
 import "../../chunk-KVOWSC5S.js";
-import "../../chunk-ATVGYF3D.js";
+import "../../chunk-PKDS6QIJ.js";
+import "../../chunk-PRWIX6UW.js";
 import "../../chunk-YK5JEVLX.js";
 import "../../chunk-EO2QPOKH.js";
-import "../../chunk-PRWIX6UW.js";
+import "../../chunk-SQDOBLBP.js";
+import "../../chunk-TDEHU73T.js";
+import "../../chunk-LG57S2SC.js";
 import "../../chunk-XWBK3XJK.js";
+import "../../chunk-S7C6TIIF.js";
+import "../../chunk-MZ6GV4YF.js";
+import "../../chunk-HNWZFNKP.js";
 import "../../chunk-AHV4GDYM.js";
-import "../../chunk-SQDOBLBP.js";
+import "../../chunk-43SBT72G.js";
+import "../../chunk-4MF3HKJA.js";
+import "../../chunk-TIZXQU26.js";
 import "../../chunk-JEINYUJH.js";
 import {
   isDivisibleCursor
 } from "../../chunk-5TK7MEN4.js";
 import "../../chunk-4KNXX6TI.js";
 import "../../chunk-3CJFPU6Q.js";
-import "../../chunk-TDEHU73T.js";
-import "../../chunk-S7C6TIIF.js";
-import "../../chunk-MZ6GV4YF.js";
-import "../../chunk-LG57S2SC.js";
-import "../../chunk-HNWZFNKP.js";
-import "../../chunk-I6UXRJ3Q.js";
-import "../../chunk-TIZXQU26.js";
-import "../../chunk-4MF3HKJA.js";
 import "../../chunk-U64T4YZE.js";
 import "../../chunk-2E224ZSN.js";
 
 // src/cli/index.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { join as join18 } from "path";
 import { Builtins, Cli, Command as Command13 } from "clipanion";
 
 // src/cli/noun-module.ts
@@ -1099,7 +1101,7 @@ var icons = {
 
 // src/cli/commands/entity.ts
 import fs10 from "fs";
-import path13 from "path";
+import path14 from "path";
 import { Command as Command2, Option as Option2 } from "clipanion";
 
 // src/cli/shared/hygen.ts
@@ -3847,8 +3849,8 @@ function generateIntegrationAggregator(surface, entries) {
   );
   const importLines = sorted.map((e) => {
     const cls = assemblyModuleClass(e.entityName, e.provider);
-    const path35 = `./modules/${e.provider}/${e.entityName}-integration.module`;
-    return `import { ${cls} } from '${path35}';`;
+    const path36 = `./modules/${e.provider}/${e.entityName}-integration.module`;
+    return `import { ${cls} } from '${path36}';`;
   }).join("\n");
   const membersInline = moduleClasses.join(", ");
   return `${generatedBanner(`surface: ${surface}`)}
@@ -4414,8 +4416,9 @@ function emitAdapters(opts) {
   };
   const entitiesBySurface = collectEntitiesBySurface(opts.entities);
   const entityByName = new Map(opts.entities.map((e) => [e.entity.name, e]));
+  const activeProviders = opts.providers.filter((p) => isActiveProvider(p.definition));
   const bySurface = /* @__PURE__ */ new Map();
-  for (const { definition } of opts.providers) {
+  for (const { definition } of activeProviders) {
     for (const surface of definition.surfaces) {
       if (!SURFACE_REGISTRY[surface]) {
         result.skippedSurfaces.push({
@@ -4430,7 +4433,7 @@ function emitAdapters(opts) {
       bySurface.set(surface, list);
     }
   }
-  const defBySlug = new Map(opts.providers.map((p) => [p.definition.slug, p.definition]));
+  const defBySlug = new Map(activeProviders.map((p) => [p.definition.slug, p.definition]));
   for (const [surface, slugs] of bySurface) {
     const surfaceDir = join8(opts.outputRoot, surface);
     const adaptersDir = join8(surfaceDir, "adapters");
@@ -4472,9 +4475,9 @@ function emitAdapters(opts) {
       [aggregatorPath, generateSurfaceAggregator(surface, slugs, mode)],
       [typedViewPath, generateTypedView(surface, slugs, entitiesBySurface.get(surface) ?? [])]
     ];
-    for (const [path35, content] of files) {
-      if (!opts.dryRun) writeIfChanged(path35, content);
-      result.written.push(path35);
+    for (const [path36, content] of files) {
+      if (!opts.dryRun) writeIfChanged(path36, content);
+      result.written.push(path36);
     }
     if (opts.backendSrcAbs) {
       const aliases = opts.aliases ?? {};
@@ -4792,6 +4795,7 @@ function generateProviderModules(opts) {
   const mode = opts.mode ?? "package";
   const written = [];
   for (const { definition, filePath } of loaded) {
+    if (!isActiveProvider(definition)) continue;
     const sourceYaml = relativeSource(filePath);
     const content = generateProviderModule(definition, sourceYaml, mode);
     const outPath = join9(
@@ -4819,15 +4823,1199 @@ function relativeSource(filePath) {
   return slash === -1 ? filePath : `definitions/providers/${filePath.slice(slash + 1)}`;
 }
 
-// src/cli/shared/events-path.ts
+// src/emitters/frontend/emit-base.ts
+import { join as join10 } from "path";
+
+// src/emitters/frontend/types.ts
+function sortEntities(entities) {
+  return [...entities].sort((a, b) => a.name.localeCompare(b.name));
+}
+function resolveSyncMode(entity, config) {
+  return entity.sync ?? config.globalSyncMode;
+}
+
+// src/emitters/frontend/emit-utils.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+function generatedBanner3(sourceDesc) {
+  return `// @generated by @pattern-stack/codegen from ${sourceDesc} \u2014 DO NOT EDIT.
+// Hand edits are overwritten on re-emit. Regenerate with \`bun run codegen\`.`;
+}
+function withBanner(sourceDesc, body) {
+  return `${generatedBanner3(sourceDesc)}
+
+${body}`;
+}
+function writeFile2(outPath, content) {
+  mkdirSync3(dirname3(outPath), { recursive: true });
+  writeFileSync3(outPath, content);
+}
+
+// src/emitters/frontend/emit-base.ts
+var SOURCE_DESC = "the entity set";
+function buildQueryClientFile() {
+  const body = `import { QueryClient } from '@tanstack/react-query';
+
+/**
+ * Shared QueryClient for REST-backed (\`api\` sync mode) collections.
+ *
+ * Replaceable: swap this for your app's own QueryClient if you already create
+ * one \u2014 every generated collection imports \`queryClient\` from this module.
+ */
+export const queryClient = new QueryClient({
+	defaultOptions: {
+		queries: {
+			staleTime: 60 * 1000, // 60s
+			gcTime: 5 * 60 * 1000, // 5m
+		},
+	},
+});
+`;
+  return withBanner(SOURCE_DESC, body);
+}
+function buildConfigFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const entityNameUnion = entities.length > 0 ? entities.map((e) => `'${e.name}'`).join(" | ") : "string";
+  const defaultEntries = entities.map((e) => `	${e.name}: { mode: '${resolveSyncMode(e, ctx.config)}' },`).join("\n");
+  const body = `/**
+ * Per-entity sync configuration + runtime overrides.
+ *
+ * \`mode\` selects the collection backing for an entity:
+ *   - 'electric' \u2192 real-time shape sync (electricCollectionOptions)
+ *   - 'api'      \u2192 REST via TanStack Query (queryCollectionOptions)
+ *
+ * The offline mode (Electric + Dexie) is deferred \u2014 see
+ * docs/specs/2026-06-04-frontend-pipeline-rebuild.md OQ-6.
+ */
+
+export type SyncMode = 'api' | 'electric';
+
+export type EntityName = ${entityNameUnion};
+
+export interface EntitySyncConfig {
+	mode: SyncMode;
+}
+
+/** Resolved per-entity sync modes (per-entity \`sync:\` over global default). */
+export const defaultConfig: Record<EntityName, EntitySyncConfig> = {
+${defaultEntries}
+};
+
+/** Runtime overrides, layered over \`defaultConfig\`. */
+const overrides: Partial<Record<EntityName, EntitySyncConfig>> = {};
+
+/** Resolve an entity's effective sync mode (override wins over default). */
+export function getSyncMode(entity: EntityName): SyncMode {
+	return (overrides[entity] ?? defaultConfig[entity]).mode;
+}
+
+/** Override an entity's sync config at runtime. */
+export function setEntityConfig(entity: EntityName, config: EntitySyncConfig): void {
+	overrides[entity] = config;
+}
+`;
+  return withBanner(SOURCE_DESC, body);
+}
+function emitBase(ctx, outDir) {
+  const written = [];
+  const queryClientPath = join10(outDir, "query-client.ts");
+  writeFile2(queryClientPath, buildQueryClientFile());
+  written.push(queryClientPath);
+  const configPath = join10(outDir, "config.ts");
+  writeFile2(configPath, buildConfigFile(ctx));
+  written.push(configPath);
+  return written;
+}
+
+// src/emitters/frontend/emit-api.ts
+import { join as join11 } from "path";
+var SOURCE_DESC_SET = "the entity set";
+function updateVerb(architecture) {
+  return architecture === "clean-lite-ps" ? "PATCH" : "PUT";
+}
+function buildClientFile(ctx) {
+  const { config } = ctx;
+  const importLines = [];
+  if (config.apiBaseUrlImport) {
+    importLines.push(`import { API_BASE_URL } from '${config.apiBaseUrlImport}';`);
+  }
+  if (config.authFunction) {
+    importLines.push(`import { ${config.authFunction} } from '${config.authImport}';`);
+  }
+  const baseUrlConst = config.apiBaseUrlImport ? "const BASE_URL = API_BASE_URL;" : `const BASE_URL = '${config.apiUrl}';`;
+  const authHeaderBlock = config.authFunction ? `	const headers: Record<string, string> = {
+		'Content-Type': 'application/json',
+		Authorization: ${config.authFunction}(),
+	};` : `	const headers: Record<string, string> = {
+		'Content-Type': 'application/json',
+	};`;
+  const imports = importLines.length > 0 ? `${importLines.join("\n")}
+
+` : "";
+  const body = `${imports}${baseUrlConst}
+
+/**
+ * Base REST transport for \`api\` sync-mode collections and entity api clients.
+ * Throws on non-2xx; returns parsed JSON, or \`undefined\` for 204 No Content.
+ */
+export async function request<T>(
+	method: string,
+	path: string,
+	body?: unknown,
+): Promise<T> {
+${authHeaderBlock}
+
+	const res = await fetch(\`\${BASE_URL}\${path}\`, {
+		method,
+		headers,
+		body: body === undefined ? undefined : JSON.stringify(body),
+	});
+
+	if (!res.ok) {
+		throw new Error(\`\${method} \${path} \u2192 \${res.status} \${res.statusText}\`);
+	}
+
+	if (res.status === 204) {
+		return undefined as T;
+	}
+
+	return res.json() as Promise<T>;
+}
+`;
+  return withBanner(SOURCE_DESC_SET, body);
+}
+function buildEntityApiFile(entity, ctx) {
+  const { config } = ctx;
+  const { camelName, plural, className, name } = entity;
+  const verb = updateVerb(config.architecture);
+  const body = `import { request } from './client';
+import type { ${className} } from '${config.dbEntitiesImport}/${name}';
+
+export const ${camelName}Api = {
+	list: (): Promise<${className}[]> => request<${className}[]>('GET', '/${plural}'),
+
+	get: (id: string): Promise<${className}> =>
+		request<${className}>('GET', \`/${plural}/\${id}\`),
+
+	create: (data: Partial<${className}>): Promise<${className}> =>
+		request<${className}>('POST', '/${plural}', data),
+
+	update: (id: string, data: Partial<${className}>): Promise<${className}> =>
+		request<${className}>('${verb}', \`/${plural}/\${id}\`, data),
+
+	delete: (id: string): Promise<void> =>
+		request<void>('DELETE', \`/${plural}/\${id}\`),
+};
+`;
+  return withBanner(`entities/${name}.yaml`, body);
+}
+function buildApiIndexFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const lines = [
+    "export * from './client';",
+    ...entities.map((e) => `export * from './${e.name}';`)
+  ];
+  return withBanner(SOURCE_DESC_SET, `${lines.join("\n")}
+`);
+}
+function emitApi(ctx, outDir) {
+  const apiDir = join11(outDir, "api");
+  const entities = sortEntities(ctx.entities);
+  const written = [];
+  const clientPath = join11(apiDir, "client.ts");
+  writeFile2(clientPath, buildClientFile(ctx));
+  written.push(clientPath);
+  for (const entity of entities) {
+    const entityPath = join11(apiDir, `${entity.name}.ts`);
+    writeFile2(entityPath, buildEntityApiFile(entity, ctx));
+    written.push(entityPath);
+  }
+  const indexPath = join11(apiDir, "index.ts");
+  writeFile2(indexPath, buildApiIndexFile(ctx));
+  written.push(indexPath);
+  return written;
+}
+
+// src/emitters/frontend/emit-collections.ts
+import { join as join12 } from "path";
+var SOURCE_DESC_SET2 = "the entity set";
+function baseUrlExpr(base, plural, apiBaseUrlImport) {
+  return apiBaseUrlImport ? `\`\${API_BASE_URL}/${plural}\`` : `\`${base}/${plural}\``;
+}
+var SSR_ORIGIN_EXPR = "typeof window !== 'undefined' ? window.location.origin : ''";
+function buildElectricCollection(entity, ctx) {
+  const { config } = ctx;
+  const { camelName, plural, name } = entity;
+  const imports = [
+    "import { electricCollectionOptions } from '@tanstack/electric-db-collection';",
+    "import { createCollection } from '@tanstack/react-db';"
+  ];
+  if (config.columnMapper) {
+    imports.push(`import { ${config.columnMapper} } from '@electric-sql/client';`);
+  }
+  if (config.authFunction) {
+    imports.push(`import { ${config.authFunction} } from '${config.authImport}';`);
+  }
+  if (config.apiBaseUrlImport) {
+    imports.push(`import { API_BASE_URL } from '${config.apiBaseUrlImport}';`);
+  }
+  imports.push(`import { ${camelName}Schema } from '${config.dbEntitiesImport}/${name}';`);
+  let urlBlock;
+  if (config.useTableParam) {
+    urlBlock = `			url: new URL(
+				'${config.shapeUrl}',
+				${SSR_ORIGIN_EXPR},
+			).toString(),
+			params: {
+				table: '${plural}',
+			},`;
+  } else {
+    const shapeUrl = baseUrlExpr(config.shapeUrl, plural, config.apiBaseUrlImport);
+    urlBlock = `			url: new URL(
+				${shapeUrl},
+				${SSR_ORIGIN_EXPR},
+			).toString(),`;
+  }
+  const headersBlock = config.authFunction ? `
+			headers: {
+				Authorization: ${config.authFunction}(),
+			},` : "";
+  const parserEntries = Object.entries(config.parsers).map(([type, fn]) => `				${type}: ${fn},`).join("\n");
+  const parserBlock = parserEntries ? `
+			parser: {
+${parserEntries}
+			},` : `
+			parser: {},`;
+  let columnMapperBlock = "";
+  if (config.columnMapper) {
+    const mapperExpr = config.columnMapperNeedsCall ? `${config.columnMapper}()` : config.columnMapper;
+    columnMapperBlock = `
+			columnMapper: ${mapperExpr},`;
+  }
+  const body = `${imports.join("\n")}
+
+export const ${camelName}Collection = createCollection(
+	electricCollectionOptions({
+		id: '${plural}',
+		shapeOptions: {
+${urlBlock}${headersBlock}${parserBlock}${columnMapperBlock}
+		},
+		schema: ${camelName}Schema,
+		getKey: (item) => item.id,
+	}),
+);
+`;
+  return withBanner(`entities/${name}.yaml`, body);
+}
+function buildApiCollection(entity, ctx) {
+  const { config } = ctx;
+  const { camelName, plural, name } = entity;
+  const imports = [
+    "import { queryCollectionOptions } from '@tanstack/query-db-collection';",
+    "import { createCollection } from '@tanstack/react-db';",
+    "import { queryClient } from '../query-client';",
+    `import { ${camelName}Api } from '../api/${name}';`,
+    `import { ${camelName}Schema } from '${config.dbEntitiesImport}/${name}';`
+  ];
+  const body = `${imports.join("\n")}
+
+export const ${camelName}Collection = createCollection(
+	queryCollectionOptions({
+		id: '${plural}',
+		queryKey: ['${plural}'],
+		queryClient,
+		queryFn: () => ${camelName}Api.list(),
+		getKey: (item) => item.id,
+		schema: ${camelName}Schema,
+	}),
+);
+`;
+  return withBanner(`entities/${name}.yaml`, body);
+}
+function buildCollectionFile(entity, ctx) {
+  const mode = resolveSyncMode(entity, ctx.config);
+  return mode === "api" ? buildApiCollection(entity, ctx) : buildElectricCollection(entity, ctx);
+}
+function buildCollectionsIndexFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const lines = entities.map((e) => `export * from './${e.name}';`);
+  return withBanner(SOURCE_DESC_SET2, `${lines.join("\n")}
+`);
+}
+function emitCollections(ctx, outDir) {
+  const collectionsDir = join12(outDir, "collections");
+  const entities = sortEntities(ctx.entities);
+  const written = [];
+  for (const entity of entities) {
+    const filePath = join12(collectionsDir, `${entity.name}.ts`);
+    writeFile2(filePath, buildCollectionFile(entity, ctx));
+    written.push(filePath);
+  }
+  const indexPath = join12(collectionsDir, "index.ts");
+  writeFile2(indexPath, buildCollectionsIndexFile(ctx));
+  written.push(indexPath);
+  return written;
+}
+
+// src/emitters/frontend/emit-entities.ts
+import { join as join13 } from "path";
+var SOURCE_DESC_SET3 = "the entity set";
+function buildEntityHooksFile(entity, ctx) {
+  const { camelName, className, name } = entity;
+  const body = `import { createEntityHooks } from '@pattern-stack/frontend-patterns';
+import { ${camelName}Collection } from '../collections/${name}';
+import { ${camelName}Api } from '../api/${name}';
+import { getSyncMode } from '../config';
+import type { ${className} } from '${ctx.config.dbEntitiesImport}/${name}';
+
+/**
+ * Typed hooks for ${className}, wired via the framework factory.
+ *
+ * \`localFirst\` is resolved at call time from the entity's runtime sync mode
+ * (\`getSyncMode('${name}')\`) \u2014 \`api\` mode is confirmed-write, everything else
+ * is local-first (optimistic).
+ */
+export const ${camelName}Hooks = createEntityHooks<${className}>({
+	name: '${name}',
+	collection: ${camelName}Collection,
+	api: ${camelName}Api,
+	localFirst: () => getSyncMode('${name}') !== 'api',
+});
+
+// Per-entity hook re-exports for direct imports.
+export const {
+	useList: use${className}List,
+	useGet: use${className},
+	useCreate: useCreate${className},
+	useUpdate: useUpdate${className},
+	useDelete: useDelete${className},
+	keys: ${camelName}Keys,
+} = ${camelName}Hooks;
+`;
+  return withBanner(`entities/${name}.yaml`, body);
+}
+function buildEntitiesIndexFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const blocks = entities.map((e) => {
+    const { camelName, className, name } = e;
+    return `export {
+	${camelName}Hooks,
+	use${className}List,
+	use${className},
+	useCreate${className},
+	useUpdate${className},
+	useDelete${className},
+	${camelName}Keys,
+} from './${name}';`;
+  });
+  return withBanner(SOURCE_DESC_SET3, `${blocks.join("\n\n")}
+`);
+}
+function emitEntities(ctx, outDir) {
+  const entitiesDir = join13(outDir, "entities");
+  const entities = sortEntities(ctx.entities);
+  const written = [];
+  for (const entity of entities) {
+    const filePath = join13(entitiesDir, `${entity.name}.ts`);
+    writeFile2(filePath, buildEntityHooksFile(entity, ctx));
+    written.push(filePath);
+  }
+  const indexPath = join13(entitiesDir, "index.ts");
+  writeFile2(indexPath, buildEntitiesIndexFile(ctx));
+  written.push(indexPath);
+  return written;
+}
+
+// src/emitters/frontend/emit-store.ts
+import { join as join14 } from "path";
+var SOURCE_DESC_SET4 = "the entity set";
+var CAMEL = (s) => s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+function resolvableRels(entity, ctx) {
+  const parsed = ctx.parsed.get(entity.name);
+  if (!parsed) return [];
+  const registryByName = new Map(ctx.entities.map((e) => [e.name, e]));
+  const out = [];
+  for (const rel2 of parsed.relationships.values()) {
+    if (rel2.type !== "belongs_to") continue;
+    const target = registryByName.get(rel2.target);
+    if (!target) continue;
+    out.push({
+      propertyName: CAMEL(rel2.name),
+      fieldNameCamel: CAMEL(fkField(rel2)),
+      target
+    });
+  }
+  out.sort((a, b) => a.propertyName.localeCompare(b.propertyName));
+  return out;
+}
+function fkField(rel2) {
+  return rel2.foreignKey && rel2.foreignKey.length > 0 ? rel2.foreignKey : `${rel2.target}_id`;
+}
+function buildStoreIndexFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const hookImports = entities.map((e) => `import { ${e.camelName}Hooks } from '../entities/${e.name}';`).join("\n");
+  const collectionImports = entities.map((e) => `import { ${e.camelName}Collection } from '../collections/${e.name}';`).join("\n");
+  const entityEntries = entities.map((e) => `		${e.plural}: ${e.camelName}Hooks,`).join("\n");
+  const collectionEntries = entities.map((e) => `		${e.plural}: ${e.camelName}Collection,`).join("\n");
+  const body = `import { createStore } from '@pattern-stack/frontend-patterns';
+
+${hookImports}
+
+${collectionImports}
+
+/**
+ * The application store \u2014 unified access to every entity.
+ *
+ * Entities and collections are keyed by their plural name:
+ *   store.${entities[0]?.plural ?? "things"}.useList()
+ *   store.resolve.<entity>(id)
+ *   store.lookups.build()
+ */
+export const store = createStore({
+	entities: {
+${entityEntries}
+	},
+	collections: {
+${collectionEntries}
+	},
+});
+
+/** Store type for the \`useStore\` hook. */
+export type AppStore = typeof store;
+`;
+  return withBanner(SOURCE_DESC_SET4, body);
+}
+function buildResolversFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const collectionImports = entities.map((e) => `import { ${e.camelName}Collection } from '../collections/${e.name}';`).join("\n");
+  const typeImports = entities.map((e) => `import type { ${e.className} } from '${ctx.config.dbEntitiesImport}/${e.name}';`).join("\n");
+  const resolverIface = entities.map(
+    (e) => `	${e.camelName}: (id: string | null | undefined) => ${e.className} | undefined;`
+  ).join("\n");
+  const resolverImpls = entities.map(
+    (e) => `		${e.camelName}: (id) => {
+			if (!id) return undefined;
+			return ${e.camelName}Collection.state.get(id) as ${e.className} | undefined;
+		},`
+  ).join("\n");
+  const refBlocks = [];
+  for (const e of entities) {
+    const rels = resolvableRels(e, ctx);
+    if (rels.length === 0) continue;
+    const refFields = rels.map(
+      (r) => `	${r.propertyName}: ${r.target.className} | undefined;`
+    ).join("\n");
+    const hydrateFields = rels.map(
+      (r) => `		${r.propertyName}: resolvers.${r.target.camelName}(entity.${r.fieldNameCamel}),`
+    ).join("\n");
+    refBlocks.push(`/** Resolved FK references for ${e.className}. */
+export interface ${e.className}Refs {
+${refFields}
+}
+
+/** Hydrate a ${e.className} with its resolved FK references. */
+export function resolve${e.className}Refs(
+	entity: ${e.className},
+	resolvers: Resolvers,
+): ${e.className} & ${e.className}Refs {
+	return {
+		...entity,
+${hydrateFields}
+	};
+}`);
+  }
+  const refsSection = refBlocks.length > 0 ? `
+// ${"=".repeat(73)}
+// WithResolved helpers \u2014 hydrate entities with resolved FKs
+// ${"=".repeat(73)}
+
+${refBlocks.join("\n\n")}
+` : "";
+  const body = `${collectionImports}
+${typeImports}
+
+/**
+ * FK resolvers \u2014 resolve a foreign-key id to the full entity object via the
+ * backing collection's local state (\`O(1)\` \`Map.get\`).
+ *
+ * Usage:
+ *   const ${entities[0]?.camelName ?? "thing"} = resolvers.${entities[0]?.camelName ?? "thing"}(other.${entities[0]?.camelName ?? "thing"}Id);
+ */
+export interface Resolvers {
+${resolverIface}
+}
+
+/** Build the resolver table over the generated collections. */
+export function createResolvers(): Resolvers {
+	return {
+${resolverImpls}
+	};
+}
+${refsSection}`;
+  return withBanner(SOURCE_DESC_SET4, body);
+}
+function buildLookupsFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const collectionImports = entities.map((e) => `import { ${e.camelName}Collection } from '../collections/${e.name}';`).join("\n");
+  const typeImports = entities.map((e) => `import type { ${e.className} } from '${ctx.config.dbEntitiesImport}/${e.name}';`).join("\n");
+  const lookupIface = entities.map((e) => `	${e.plural}: Map<string, ${e.className}>;`).join("\n");
+  const lookupBuild = entities.map(
+    (e) => `		${e.plural}: new Map(
+			Array.from(${e.camelName}Collection.state.values()).map((item) => [
+				(item as ${e.className}).id as string,
+				item as ${e.className},
+			]),
+		),`
+  ).join("\n");
+  const body = `${collectionImports}
+${typeImports}
+
+/** All entity lookup maps, keyed by plural entity name (id \u2192 entity). */
+export interface EntityLookups {
+${lookupIface}
+}
+
+/** Build fresh lookup maps from current collection state. */
+export function buildLookups(): EntityLookups {
+	return {
+${lookupBuild}
+	};
+}
+
+/** Caching lookup factory: \`build()\` (re)computes, \`current\` reads, \`clear()\` resets. */
+export function createLookups() {
+	let cache: EntityLookups | null = null;
+	return {
+		build: (): EntityLookups => {
+			cache = buildLookups();
+			return cache;
+		},
+		get current(): EntityLookups | null {
+			return cache;
+		},
+		clear: (): void => {
+			cache = null;
+		},
+	};
+}
+`;
+  return withBanner(SOURCE_DESC_SET4, body);
+}
+function buildStoreModuleIndexFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const lines = [
+    "export { store, type AppStore } from './index';",
+    "export { createResolvers, type Resolvers } from './resolvers';",
+    "export { buildLookups, createLookups, type EntityLookups } from './lookups';"
+  ];
+  const refExports = entities.filter((e) => resolvableRels(e, ctx).length > 0).map(
+    (e) => `export { resolve${e.className}Refs, type ${e.className}Refs } from './resolvers';`
+  );
+  if (refExports.length > 0) {
+    lines.push("", ...refExports);
+  }
+  return withBanner(SOURCE_DESC_SET4, `${lines.join("\n")}
+`);
+}
+function emitStore(ctx, outDir) {
+  const storeDir = join14(outDir, "store");
+  const written = [];
+  const files = [
+    ["index.ts", buildStoreIndexFile(ctx)],
+    ["resolvers.ts", buildResolversFile(ctx)],
+    ["lookups.ts", buildLookupsFile(ctx)],
+    ["module-index.ts", buildStoreModuleIndexFile(ctx)]
+  ];
+  for (const [fileName, content] of files) {
+    const filePath = join14(storeDir, fileName);
+    writeFile2(filePath, content);
+    written.push(filePath);
+  }
+  return written;
+}
+
+// src/emitters/frontend/emit-fields.ts
+import { join as join15 } from "path";
+
+// src/emitters/frontend/field-meta.ts
+var CAMEL2 = (s) => s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+function formatLabel(fieldName) {
+  return fieldName.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function inferUiType(field) {
+  if (field.ui.type) return field.ui.type;
+  if (Array.isArray(field.choices) && field.choices.length > 0) return "enum";
+  if (field.foreignKey) return "reference";
+  const nameLower = field.name.toLowerCase();
+  if (nameLower.includes("email")) return "email";
+  if (nameLower.includes("url") || nameLower.includes("website")) return "url";
+  if (nameLower.includes("password")) return "password";
+  if (nameLower.includes("price") || nameLower.includes("amount") || nameLower.includes("cost") || nameLower.includes("value") || nameLower.includes("revenue")) {
+    return "money";
+  }
+  if (nameLower.includes("percent") || nameLower.includes("rate")) {
+    return "percentage";
+  }
+  switch (field.type) {
+    case "string":
+      return field.constraints.maxLength && field.constraints.maxLength > 500 ? "textarea" : "text";
+    case "integer":
+    case "decimal":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "uuid":
+      return "text";
+    case "date":
+      return "date";
+    case "datetime":
+      return "datetime";
+    case "json":
+      return "json";
+    default:
+      return "text";
+  }
+}
+function inferUiImportance(field) {
+  if (field.ui.importance) return field.ui.importance;
+  const nameLower = field.name.toLowerCase();
+  if (["id", "created_at", "updated_at", "deleted_at"].includes(nameLower)) {
+    return "tertiary";
+  }
+  if (field.foreignKey && nameLower.endsWith("_id")) return "secondary";
+  if (field.required) return "primary";
+  if (nameLower.includes("name") || nameLower.includes("title")) return "primary";
+  return "secondary";
+}
+function isEntityRefField(field) {
+  if (field.type === "entity_ref") return true;
+  return field.name.endsWith("_entity_type") || field.name.endsWith("_entity_id");
+}
+function deriveFieldMeta(field) {
+  const hasChoices = Array.isArray(field.choices) && field.choices.length > 0;
+  const meta = {
+    field: CAMEL2(field.name),
+    label: field.ui.label ?? formatLabel(field.name),
+    type: inferUiType(field),
+    importance: inferUiImportance(field),
+    sortable: field.ui.sortable ?? false,
+    filterable: field.ui.filterable ?? false
+  };
+  if (hasChoices) meta.choices = field.choices;
+  if (field.foreignKey) meta.reference = field.foreignKey.table;
+  return meta;
+}
+
+// src/emitters/frontend/emit-fields.ts
+var SOURCE_DESC_SET5 = "the entity set";
+function buildFieldMetaTypeFile() {
+  const body = `/**
+ * Field metadata types for DataGrid, forms, and admin surfaces.
+ */
+
+export type FieldType =
+	| 'text'
+	| 'textarea'
+	| 'number'
+	| 'boolean'
+	| 'date'
+	| 'datetime'
+	| 'email'
+	| 'url'
+	| 'password'
+	| 'money'
+	| 'percentage'
+	| 'json'
+	| 'enum'
+	| 'reference'
+	| 'entity';
+
+export type FieldImportance = 'primary' | 'secondary' | 'tertiary';
+
+export interface FieldMeta<T = unknown> {
+	/** Property key on the entity (\`keyof T\` for typed access). */
+	field: keyof T & string;
+	label: string;
+	type: FieldType;
+	importance: FieldImportance;
+	sortable?: boolean;
+	filterable?: boolean;
+	format?: Record<string, unknown>;
+	choices?: string[];
+	reference?: string;
+}
+`;
+  return withBanner(SOURCE_DESC_SET5, body);
+}
+function hasTimestamps(parsed) {
+  return parsed?.behaviors.includes("timestamps") ?? false;
+}
+function displayFields(parsed) {
+  if (!parsed) return [];
+  const out = [];
+  for (const field of parsed.fields.values()) {
+    if (field.name === "id") continue;
+    if (isEntityRefField(field)) continue;
+    out.push(deriveFieldMeta(field));
+  }
+  return out;
+}
+function renderFieldMeta(meta) {
+  const lines = [
+    `		field: '${meta.field}',`,
+    `		label: '${meta.label}',`,
+    `		type: '${meta.type}' as FieldType,`,
+    `		importance: '${meta.importance}' as FieldImportance,`
+  ];
+  if (meta.sortable) lines.push("		sortable: true,");
+  if (meta.filterable) lines.push("		filterable: true,");
+  if (meta.choices) lines.push(`		choices: ${JSON.stringify(meta.choices)},`);
+  if (meta.reference) lines.push(`		reference: '${meta.reference}',`);
+  return `	${meta.field}: {
+${lines.join("\n")}
+	},`;
+}
+function humanizeClass(className) {
+  return className.replace(/([A-Z])/g, " $1").trim();
+}
+function buildEntityFieldsFile(entity, ctx) {
+  const parsed = ctx.parsed.get(entity.name);
+  const { camelName, className, classNamePlural, name, plural } = entity;
+  const fields = displayFields(parsed);
+  const rels = resolvableRels(entity, ctx);
+  const ts3 = hasTimestamps(parsed);
+  const fieldEntries = fields.map(renderFieldMeta);
+  const relEntries = rels.map(
+    (r) => `	${r.propertyName}: {
+		field: '${r.propertyName}',
+		label: '${humanizeClass(r.target.className)}',
+		type: 'entity' as FieldType,
+		importance: 'secondary' as FieldImportance,
+		reference: '${r.target.plural}',
+	},`
+  );
+  const tsEntries = ts3 ? [
+    `	createdAt: {
+		field: 'createdAt',
+		label: 'Created',
+		type: 'datetime' as FieldType,
+		importance: 'tertiary' as FieldImportance,
+		format: { dateFormat: 'relative' },
+	},`,
+    `	updatedAt: {
+		field: 'updatedAt',
+		label: 'Updated',
+		type: 'datetime' as FieldType,
+		importance: 'tertiary' as FieldImportance,
+		format: { dateFormat: 'relative' },
+	},`
+  ] : [];
+  const allEntries = [...fieldEntries, ...relEntries, ...tsEntries].join("\n");
+  const primaryFields = fields.filter((f) => f.importance === "primary").map((f) => `		'${f.field}',`).join("\n");
+  const searchFields = fields.filter((f) => f.filterable).map((f) => `		'${f.field}',`).join("\n");
+  const defaultSortField = ts3 ? "createdAt" : "id";
+  const expose = parsed?.expose ?? ["repository", "rest", "trpc"];
+  const canWrite = expose.includes("repository") || expose.includes("trpc");
+  const body = `import type { FieldMeta, FieldType, FieldImportance } from './field-meta';
+import type { ${className} } from '${ctx.config.dbEntitiesImport}/${name}';
+
+export const ${camelName}Fields: Record<string, FieldMeta<${className}>> = {
+${allEntries}
+};
+
+export const ${camelName}Metadata = {
+	name: '${name}',
+	plural: '${plural}',
+	displayName: '${humanizeClass(className)}',
+	displayNamePlural: '${humanizeClass(classNamePlural)}',
+
+	fields: ${camelName}Fields,
+
+	primaryFields: [
+${primaryFields}
+	],
+	searchFields: [
+${searchFields}
+	],
+	defaultSort: { field: '${defaultSortField}', direction: 'desc' as const },
+
+	capabilities: {
+		create: ${canWrite},
+		update: ${canWrite},
+		delete: ${canWrite},
+		list: true,
+		get: true,
+	},
+} as const;
+`;
+  return withBanner(`entities/${name}.yaml`, body);
+}
+function buildFieldsIndexFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const lines = entities.map((e) => `export * from './${e.name}';`);
+  return withBanner(SOURCE_DESC_SET5, `${lines.join("\n")}
+`);
+}
+function emitFields(ctx, outDir) {
+  const fieldsDir = join15(outDir, "fields");
+  const entities = sortEntities(ctx.entities);
+  const written = [];
+  const typePath = join15(fieldsDir, "field-meta.ts");
+  writeFile2(typePath, buildFieldMetaTypeFile());
+  written.push(typePath);
+  for (const entity of entities) {
+    const filePath = join15(fieldsDir, `${entity.name}.ts`);
+    writeFile2(filePath, buildEntityFieldsFile(entity, ctx));
+    written.push(filePath);
+  }
+  const indexPath = join15(fieldsDir, "index.ts");
+  writeFile2(indexPath, buildFieldsIndexFile(ctx));
+  written.push(indexPath);
+  return written;
+}
+
+// src/emitters/frontend/emit-providers.ts
+import { join as join16 } from "path";
+var SOURCE_DESC2 = "definitions/providers";
+function vendorLiteral(p, indent) {
+  const lines = [
+    `${indent}{`,
+    `${indent}	provider: '${p.slug}',`,
+    `${indent}	name: '${(p.displayName ?? p.slug).replace(/'/g, "\\'")}',`,
+    `${indent}	planned: ${p.status === "planned"},`,
+    `${indent}	surfaces: [${p.surfaces.map((s) => `'${s}'`).join(", ")}],`
+  ];
+  if (p.display?.blurb) {
+    lines.push(`${indent}	blurb: '${p.display.blurb.replace(/'/g, "\\'")}',`);
+  }
+  if (p.display?.hint) {
+    lines.push(`${indent}	hint: '${p.display.hint.replace(/'/g, "\\'")}',`);
+  }
+  lines.push(`${indent}},`);
+  return lines.join("\n");
+}
+function sortProviders(providers) {
+  return [...providers].sort((a, b) => a.slug.localeCompare(b.slug));
+}
+function buildProvidersFile(ctx) {
+  const providers = sortProviders(ctx.providers ?? []);
+  const categories = ctx.config.catalogCategories;
+  const flat = providers.map((p) => vendorLiteral(p, "	")).join("\n");
+  const groups = categories.map((cat) => {
+    const vendors = providers.filter((p) => p.display?.category === cat.id);
+    const vendorBlock = vendors.map((p) => vendorLiteral(p, "			")).join("\n");
+    return [
+      "	{",
+      `		id: '${cat.id}',`,
+      `		name: '${cat.name.replace(/'/g, "\\'")}',`,
+      `		blurb: '${cat.blurb.replace(/'/g, "\\'")}',`,
+      vendors.length > 0 ? `		vendors: [
+${vendorBlock}
+		],` : "		vendors: [],",
+      "	},"
+    ].join("\n");
+  }).join("\n");
+  const body = `/**
+ * Providers catalog \u2014 emitted from \`definitions/providers/*.yaml\` (slug,
+ * display_name, surfaces, status, display) + \`frontend.catalog.categories\`
+ * (codegen.config.yaml). Provider truth lives in the definitions; this file
+ * is a projection \u2014 never hand-edit, never hand-duplicate.
+ *
+ * \`planned: true\` vendors are roadmap stubs (no backend integration yet) \u2014
+ * render them as unconnectable tiles. Join live rows on \`provider\` (the
+ * canonical slug, e.g. \`Connection.provider\`).
+ */
+
+export type ProviderStatus = 'active' | 'planned';
+
+export interface CatalogVendor {
+	/** Provider slug \u2014 joins to \`Connection.provider\` / STRATEGY_REGISTRY keys. */
+	provider: string;
+	name: string;
+	/** True for roadmap stubs (\`status: planned\`) \u2014 no backend integration yet. */
+	planned: boolean;
+	/** Surfaces this provider serves (ADR-0006). */
+	surfaces: string[];
+	blurb?: string;
+	/** Sub-line shown on an unconnected ("available") tile. */
+	hint?: string;
+}
+
+export interface CatalogCategory {
+	id: string;
+	name: string;
+	blurb: string;
+	vendors: CatalogVendor[];
+}
+
+/** Every provider definition, flat (active + planned), slug-sorted. */
+export const PROVIDERS: CatalogVendor[] = [
+${flat}
+];
+
+/**
+ * Category-grouped catalog (\`frontend.catalog.categories\` order). Providers
+ * join a group via \`display.category\`; uncategorized providers appear only
+ * in \`PROVIDERS\`.
+ */
+export const PROVIDER_CATALOG: CatalogCategory[] = [
+${groups}
+];
+`;
+  return withBanner(SOURCE_DESC2, body);
+}
+function emitProviders(ctx, outDir) {
+  if (!ctx.providers || ctx.providers.length === 0) return [];
+  const path36 = join16(outDir, "providers.ts");
+  writeFile2(path36, buildProvidersFile(ctx));
+  return [path36];
+}
+
+// src/emitters/frontend/emit-index.ts
+import { join as join17 } from "path";
+
+// src/emitters/frontend/deps.ts
+var FRONTEND_EMITTED_DEPS = {
+  "@pattern-stack/frontend-patterns": "^0.2.0-alpha.18",
+  "@tanstack/react-db": "^0.1.55",
+  "@tanstack/electric-db-collection": "^0.2.11",
+  "@tanstack/query-db-collection": "^1.0.6",
+  "@tanstack/react-query": "^5.0.0"
+};
+
+// src/emitters/frontend/emit-index.ts
+var SOURCE_DESC_SET6 = "the entity set";
+function buildVersionPairingComment() {
+  const entries = Object.entries(FRONTEND_EMITTED_DEPS);
+  const nameWidth = Math.max(...entries.map(([name]) => name.length));
+  const rows = entries.map(([name, range]) => ` *   ${name.padEnd(nameWidth)}  ${range}`).join("\n");
+  return ` * Version pairing \u2014 the emitted imports require these package ranges in the
+ * consumer's frontend package.json:
+ *
+${rows}`;
+}
+function buildRootIndexFile(ctx) {
+  const entities = sortEntities(ctx.entities);
+  const entityList = entities.map((e) => ` * - ${e.className}`).join("\n");
+  const body = `/**
+ * Generated frontend data layer.
+ *
+ * Entities:
+${entityList || " * (none)"}
+ *
+${buildVersionPairingComment()}
+ */
+
+// Per-entity sync configuration + runtime overrides
+export * from './config';
+
+// Shared TanStack QueryClient
+export * from './query-client';
+
+// REST api client
+export * from './api/index';
+
+// TanStack DB collections (per-entity sync mode)
+export * from './collections/index';
+
+// Entity hooks (createEntityHooks wiring)
+export * from './entities/index';
+
+// Field metadata (DataGrid / forms / admin)
+export * from './fields/index';
+${ctx.providers && ctx.providers.length > 0 ? `
+// Providers catalog (definitions/providers + frontend.catalog.categories)
+export * from './providers';
+` : ""}
+// Unified store (entities + collections + resolvers + lookups)
+export * from './store/module-index';
+`;
+  return withBanner(SOURCE_DESC_SET6, body);
+}
+function emitIndex(ctx, outDir) {
+  const indexPath = join17(outDir, "index.ts");
+  writeFile2(indexPath, buildRootIndexFile(ctx));
+  return [indexPath];
+}
+
+// src/emitters/frontend/load-context.ts
+import { existsSync as existsSync8, statSync as statSync5 } from "fs";
 import path12 from "path";
+
+// src/schema/codegen-config.schema.ts
+import { z } from "zod";
+var GenerateConfigSchema = z.object({
+  /**
+   * Backend architecture to generate. One of:
+   * - 'clean'          — Full Clean Architecture (domain + application + infrastructure + presentation)
+   * - 'clean-lite-ps'  — Clean-Lite-PS modules/{plural}/ layout
+   *
+   * Default: 'clean'.
+   */
+  architecture: z.enum(["clean", "clean-lite-ps"]).default("clean"),
+  /**
+   * Whether to emit the frontend pipeline (collections, hooks, entity metadata).
+   * Default: false — backend-only projects opt out by default.
+   */
+  frontend: z.boolean().default(false),
+  /**
+   * Analytics backend to generate.
+   * - 'none': no analytics layer (default)
+   * - 'cube': generate cube.js semantic layer and analytics providers
+   */
+  analytics: z.enum(["none", "cube"]).default("none")
+}).passthrough();
+var PathsConfigSchema = z.object({
+  events_dir: z.string().optional(),
+  generated: z.string().default("src/generated")
+}).passthrough();
+var PatternsConfigSchema = z.array(z.string()).optional().default(["src/patterns/*.pattern.ts"]);
+var RuntimeModeSchema = z.enum(["package", "vendored"]).default("package");
+var FrontendAuthConfigSchema = z.object({
+  function: z.string().nullable().default("getAuthorizationHeader")
+}).default({ function: "getAuthorizationHeader" });
+var FrontendSyncConfigSchema = z.object({
+  mode: z.enum(["api", "electric"]).default("electric"),
+  shapeUrl: z.string().default("/v1/shape"),
+  useTableParam: z.boolean().default(true),
+  columnMapper: z.string().nullable().default("snakeCamelMapper"),
+  columnMapperNeedsCall: z.boolean().default(true),
+  apiBaseUrlImport: z.string().nullable().default(null),
+  apiUrl: z.string().default("/api")
+}).default({});
+var FrontendCatalogConfigSchema = z.object({
+  categories: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      blurb: z.string().default("")
+    }).strict()
+  ).default([])
+}).default({});
+var FrontendConfigSchema = z.object({
+  auth: FrontendAuthConfigSchema,
+  parsers: z.record(z.string()).default({ timestamptz: "(date: string) => new Date(date)" }),
+  sync: FrontendSyncConfigSchema,
+  catalog: FrontendCatalogConfigSchema
+}).strict().default({});
+
+// src/emitters/frontend/load-context.ts
+var DEFAULT_DB_ENTITIES = {
+  path: "packages/db/src/entities",
+  import: "@repo/db/entities"
+};
+var DEFAULT_FRONTEND_GENERATED = {
+  path: "apps/frontend/src/generated",
+  import: "@/generated"
+};
+var DEFAULT_FRONTEND_COLLECTIONS_AUTH = {
+  path: "apps/frontend/src/lib/collections/auth",
+  import: "@/lib/collections/auth"
+};
+function resolveLocation(config, key, fallback) {
+  const override = config.locations?.[key];
+  return {
+    path: override?.path ?? fallback.path,
+    import: override?.import ?? fallback.import
+  };
+}
+function mapFrontendEmitConfig(config) {
+  const parsed = FrontendConfigSchema.safeParse(config.frontend ?? {});
+  const fe = parsed.success ? parsed.data : FrontendConfigSchema.parse({});
+  const dbEntities = resolveLocation(config, "dbEntities", DEFAULT_DB_ENTITIES);
+  const collectionsAuth = resolveLocation(
+    config,
+    "frontendCollectionsAuth",
+    DEFAULT_FRONTEND_COLLECTIONS_AUTH
+  );
+  const architecture = config.generate?.architecture === "clean-lite-ps" ? "clean-lite-ps" : "clean";
+  return {
+    globalSyncMode: fe.sync.mode,
+    // auth.function: absent → 'getAuthorizationHeader' (schema default), explicit
+    // null → disabled (no header lines emitted).
+    authFunction: fe.auth.function,
+    authImport: collectionsAuth.import,
+    shapeUrl: fe.sync.shapeUrl,
+    useTableParam: fe.sync.useTableParam,
+    columnMapper: fe.sync.columnMapper,
+    columnMapperNeedsCall: fe.sync.columnMapperNeedsCall,
+    apiUrl: fe.sync.apiUrl,
+    apiBaseUrlImport: fe.sync.apiBaseUrlImport,
+    parsers: fe.parsers,
+    architecture,
+    dbEntitiesImport: dbEntities.import,
+    catalogCategories: fe.catalog.categories
+  };
+}
+function loadProviderCatalogInputs(cwd, config) {
+  const providersDir = path12.resolve(
+    cwd,
+    config.paths?.providers ?? "definitions/providers"
+  );
+  if (!existsSync8(providersDir) || !statSync5(providersDir).isDirectory()) {
+    return [];
+  }
+  const files = findYamlFiles(providersDir);
+  if (files.length === 0) return [];
+  return loadProvidersFromYaml(files).successes.map((s) => ({
+    slug: s.definition.slug,
+    displayName: s.definition.display_name,
+    surfaces: s.definition.surfaces,
+    status: s.definition.status,
+    display: s.definition.display
+  }));
+}
+function loadFrontendEmitContext(cwd, config, opts = {}) {
+  const entitiesDir = opts.entitiesDir ?? path12.resolve(cwd, config.paths?.entities_dir ?? "entities");
+  const { registry } = loadEntityRegistry(entitiesDir);
+  const entities = sortEntities([...registry.values()]);
+  if (entities.length === 0) {
+    return {
+      skip: `no entities found in ${path12.relative(cwd, entitiesDir) || entitiesDir}`
+    };
+  }
+  const parsedList = loadEntities(entitiesDir).entities;
+  const parsed = new Map(
+    parsedList.map((p) => [p.name, p])
+  );
+  const emitConfig = mapFrontendEmitConfig(config);
+  const providers = loadProviderCatalogInputs(cwd, config);
+  const generated = resolveLocation(
+    config,
+    "frontendGenerated",
+    DEFAULT_FRONTEND_GENERATED
+  );
+  const outDir = path12.resolve(cwd, generated.path);
+  return {
+    skip: void 0,
+    ctx: { entities, parsed, config: emitConfig, providers },
+    outDir
+  };
+}
+
+// src/emitters/frontend/index.ts
+function emitFrontendSet(ctx, outDir) {
+  return [
+    ...emitBase(ctx, outDir),
+    ...emitApi(ctx, outDir),
+    ...emitCollections(ctx, outDir),
+    ...emitEntities(ctx, outDir),
+    ...emitStore(ctx, outDir),
+    ...emitFields(ctx, outDir),
+    ...emitProviders(ctx, outDir),
+    ...emitIndex(ctx, outDir)
+  ];
+}
+
+// src/cli/shared/events-path.ts
+import path13 from "path";
 var FALLBACK = "events";
 function resolveEventsDirFromConfig(cwd, config) {
   const configured = config?.paths?.events_dir;
   if (typeof configured === "string" && configured.length > 0) {
-    return path12.resolve(cwd, configured);
+    return path13.resolve(cwd, configured);
   }
-  return path12.resolve(cwd, FALLBACK);
+  return path13.resolve(cwd, FALLBACK);
 }
 function resolveEventsDir(ctx) {
   return resolveEventsDirFromConfig(ctx.cwd, ctx.config);
@@ -4856,7 +6044,7 @@ function printInfo(msg) {
 // src/cli/commands/entity.ts
 function resolveProvidersDir(ctx) {
   const fromConfig = ctx.config?.paths?.providers;
-  return fromConfig != null ? path13.resolve(ctx.cwd, fromConfig) : path13.resolve(ctx.cwd, "definitions/providers");
+  return fromConfig != null ? path14.resolve(ctx.cwd, fromConfig) : path14.resolve(ctx.cwd, "definitions/providers");
 }
 function listEntityYamls2(dir, providersDir) {
   if (!fs10.existsSync(dir)) return [];
@@ -4938,10 +6126,10 @@ async function hints(ctx) {
     { command: "codegen entity validate", description: "Validate YAML definitions" },
     { command: "codegen entity list", description: "List entities as a table" }
   ];
-  const providersDir = ctx.config?.paths?.providers != null ? path13.resolve(
+  const providersDir = ctx.config?.paths?.providers != null ? path14.resolve(
     ctx.cwd,
     ctx.config.paths.providers
-  ) : path13.resolve(ctx.cwd, "definitions/providers");
+  ) : path14.resolve(ctx.cwd, "definitions/providers");
   if (fs10.existsSync(providersDir)) {
     baseHints.push({
       command: "codegen entity new --all",
@@ -4997,14 +6185,14 @@ var EntityNewCommand = class extends Command2 {
     }
     let targets = [];
     if (this.all) {
-      const dir = ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
+      const dir = ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
       targets = listEntityYamls2(dir, resolveProvidersDir(ctx));
       if (targets.length === 0) {
         printError(`No entity YAML files found in ${dir}`);
         return 1;
       }
     } else if (this.yaml) {
-      targets = [path13.resolve(ctx.cwd, this.yaml)];
+      targets = [path14.resolve(ctx.cwd, this.yaml)];
     } else {
       printError("Missing YAML path. Pass a file or --all.");
       return 2;
@@ -5021,7 +6209,7 @@ var EntityNewCommand = class extends Command2 {
     }
     if (invalid.length > 0 && !this.continueOnError) {
       for (const i of invalid) {
-        printError(`${path13.basename(i.file)} \u2014 ${i.message}`);
+        printError(`${path14.basename(i.file)} \u2014 ${i.message}`);
         for (const detail of i.details ?? []) {
           printError(`   \u2022 ${detail}`);
         }
@@ -5030,7 +6218,7 @@ var EntityNewCommand = class extends Command2 {
         return 1;
       }
     }
-    const entitiesDirForEmits = ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
+    const entitiesDirForEmits = ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
     const eventsDirForEmits = resolveEventsDir(ctx);
     const allEntitiesForEmits = loadEntities(entitiesDirForEmits, {
       excludeDirs: [resolveProvidersDir(ctx)]
@@ -5079,29 +6267,29 @@ var EntityNewCommand = class extends Command2 {
         if (!isJsonMode()) return 1;
       }
     }
-    const entitiesDir = ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
-    const relationshipsDir = path13.resolve(ctx.cwd, "relationships");
+    const entitiesDir = ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
+    const relationshipsDir = path14.resolve(ctx.cwd, "relationships");
     const generatedDir = resolveGeneratedDir(ctx);
     const architecture = resolveArchitecture(ctx);
     const subsystemsRoot = resolveSubsystemsRoot(ctx);
     const runtimeMode = resolveRuntimeMode(ctx.config);
-    const scopeEntityTypePath = runtimeMode === "package" ? path13.resolve(generatedDir, "scope-entity-type.ts") : path13.resolve(subsystemsRoot, "jobs/generated/scope-entity-type.ts");
+    const scopeEntityTypePath = runtimeMode === "package" ? path14.resolve(generatedDir, "scope-entity-type.ts") : path14.resolve(subsystemsRoot, "jobs/generated/scope-entity-type.ts");
     const eventsDir = resolveEventsDir(ctx);
-    const eventCodegenOutputDir = runtimeMode === "package" ? path13.resolve(generatedDir, "events") : path13.resolve(subsystemsRoot, "events/generated");
+    const eventCodegenOutputDir = runtimeMode === "package" ? path14.resolve(generatedDir, "events") : path14.resolve(subsystemsRoot, "events/generated");
     const bridgeInstalledForRegistry = configuredSubsystemNames(
       ctx.config
     ).includes("bridge");
-    const bridgeRegistryOutputDir = runtimeMode === "package" ? generatedDir : path13.resolve(subsystemsRoot, "bridge/generated");
+    const bridgeRegistryOutputDir = runtimeMode === "package" ? generatedDir : path14.resolve(subsystemsRoot, "bridge/generated");
     const backendSrcForHandlers = ctx.config?.paths?.backend_src ?? "src";
-    const bridgeHandlersDir = path13.resolve(
+    const bridgeHandlersDir = path14.resolve(
       ctx.cwd,
       backendSrcForHandlers,
       "jobs"
     );
     const orchestrationConfigured = ctx.config?.paths?.orchestration_src;
-    const orchestrationOutputRoot = path13.resolve(
+    const orchestrationOutputRoot = path14.resolve(
       ctx.cwd,
-      typeof orchestrationConfigured === "string" && orchestrationConfigured.length > 0 ? orchestrationConfigured : path13.join(backendSrcForHandlers, "orchestration")
+      typeof orchestrationConfigured === "string" && orchestrationConfigured.length > 0 ? orchestrationConfigured : path14.join(backendSrcForHandlers, "orchestration")
     );
     const orchestrationGlobs = (() => {
       const fromCfg = ctx.config?.patterns;
@@ -5232,7 +6420,7 @@ var EntityNewCommand = class extends Command2 {
         }
         if (invalid.length > 0) {
           for (const i of invalid) {
-            printWarning(`${path13.basename(i.file)} \u2014 ${i.message}`);
+            printWarning(`${path14.basename(i.file)} \u2014 ${i.message}`);
           }
         }
         console.log("");
@@ -5250,7 +6438,7 @@ var EntityNewCommand = class extends Command2 {
     }
     const succeeded = [];
     const failed = [
-      ...invalid.map((i) => ({ name: path13.basename(i.file), file: i.file, message: i.message }))
+      ...invalid.map((i) => ({ name: path14.basename(i.file), file: i.file, message: i.message }))
     ];
     for (const v of validated) {
       if (!isJsonMode()) {
@@ -5373,10 +6561,40 @@ var EntityNewCommand = class extends Command2 {
         }
       }
     }
+    let frontendResult = null;
+    const frontendEnabled = ctx.config?.generate?.frontend === true;
+    if (frontendEnabled) {
+      try {
+        const loaded = loadFrontendEmitContext(
+          ctx.cwd,
+          ctx.config,
+          { entitiesDir }
+        );
+        if (loaded.skip !== void 0) {
+          if (!isJsonMode()) {
+            printInfo(`frontend emission skipped \u2014 ${loaded.skip}`);
+          }
+        } else {
+          const { ctx: frontendCtx, outDir: frontendOutDir } = loaded;
+          const written = emitFrontendSet(frontendCtx, frontendOutDir);
+          frontendResult = { written, outDir: frontendOutDir };
+          if (!isJsonMode()) {
+            printInfo(
+              `frontend emitted (${written.length} files) \u2192 ${path14.relative(ctx.cwd, frontendOutDir)}`
+            );
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!isJsonMode()) {
+          printWarning(`frontend emission failed \u2014 ${msg}`);
+        }
+      }
+    }
     let providerResult = null;
     try {
       const providersDir = resolveProvidersDir(ctx);
-      const providerOutputRoot = path13.resolve(
+      const providerOutputRoot = path14.resolve(
         ctx.cwd,
         backendSrcForHandlers,
         "integrations/providers"
@@ -5418,7 +6636,7 @@ var EntityNewCommand = class extends Command2 {
     try {
       if (providerResult && !providerResult.skipped && providerResult.issues.length === 0) {
         const providersDir = providerResult.providersDir;
-        const adapterOutputRoot = path13.resolve(
+        const adapterOutputRoot = path14.resolve(
           ctx.cwd,
           backendSrcForHandlers,
           "integrations"
@@ -5437,7 +6655,7 @@ var EntityNewCommand = class extends Command2 {
           providers: loadedProviders,
           entities: entityDefs,
           outputRoot: adapterOutputRoot,
-          backendSrcAbs: path13.resolve(ctx.cwd, backendSrcForHandlers),
+          backendSrcAbs: path14.resolve(ctx.cwd, backendSrcForHandlers),
           aliases: assemblyTsAliases?.aliases ?? {},
           mode: runtimeMode
         });
@@ -5514,6 +6732,11 @@ var EntityNewCommand = class extends Command2 {
             relativePath: f.relativePath
           }))
         } : null,
+        frontend: frontendResult ? {
+          outDir: frontendResult.outDir,
+          written: frontendResult.written,
+          fileCount: frontendResult.written.length
+        } : null,
         emits: {
           warnings: emitsWarnings.map((w) => ({
             entity: w.entity ?? null,
@@ -5539,22 +6762,27 @@ var EntityNewCommand = class extends Command2 {
       }
       if (barrelResult) {
         printInfo(
-          `barrels regenerated (${barrelResult.entityCount} entities) \u2192 ${path13.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path13.relative(ctx.cwd, barrelResult.schemaBarrel)}`
+          `barrels regenerated (${barrelResult.entityCount} entities) \u2192 ${path14.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path14.relative(ctx.cwd, barrelResult.schemaBarrel)}`
         );
       }
       if (scopeResult) {
         printInfo(
-          `scope-entity-type regenerated (${scopeResult.scopeableNames.length} scopeable) \u2192 ${path13.relative(ctx.cwd, scopeResult.outputPath)}`
+          `scope-entity-type regenerated (${scopeResult.scopeableNames.length} scopeable) \u2192 ${path14.relative(ctx.cwd, scopeResult.outputPath)}`
         );
       }
       if (eventCodegenResult) {
         printInfo(
-          `event codegen regenerated (${eventCodegenResult.eventCount} events) \u2192 ${path13.relative(ctx.cwd, eventCodegenResult.outputDir)}`
+          `event codegen regenerated (${eventCodegenResult.eventCount} events) \u2192 ${path14.relative(ctx.cwd, eventCodegenResult.outputDir)}`
         );
       }
       if (orchestrationResult && orchestrationResult.patterns.length > 0) {
         printInfo(
-          `orchestration regenerated (${orchestrationResult.patterns.length} patterns, ${orchestrationResult.files.length} files) \u2192 ${path13.relative(ctx.cwd, orchestrationResult.outputRoot)}`
+          `orchestration regenerated (${orchestrationResult.patterns.length} patterns, ${orchestrationResult.files.length} files) \u2192 ${path14.relative(ctx.cwd, orchestrationResult.outputRoot)}`
+        );
+      }
+      if (frontendResult) {
+        printInfo(
+          `frontend regenerated (${frontendResult.written.length} files) \u2192 ${path14.relative(ctx.cwd, frontendResult.outDir)}`
         );
       }
     }
@@ -5640,7 +6868,7 @@ var EntityValidateCommand = class extends Command2 {
       json: this.json,
       skipDetection: true
     });
-    const targetDir = this.dir ? path13.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
+    const targetDir = this.dir ? path14.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
     if (!fs10.existsSync(targetDir)) {
       printError(`Directory not found: ${targetDir}`);
       return 1;
@@ -5693,7 +6921,7 @@ var entity_default = entityNoun;
 
 // src/cli/commands/subsystem.ts
 import fs13 from "fs";
-import path23 from "path";
+import path24 from "path";
 import { Command as Command3, Option as Option3 } from "clipanion";
 
 // src/cli/shared/config-block-detect.ts
@@ -5726,26 +6954,26 @@ function stripConfigBlock(yamlSource, subsystem) {
 }
 
 // src/cli/shared/events-scaffold-locals.ts
-import path14 from "path";
+import path15 from "path";
 function resolveEventsScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const eventsBlock = config?.events ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const configPath = path14.resolve(cwd, "codegen.config.yaml");
-  const schemaPath = path14.resolve(
+  const configPath = path15.resolve(cwd, "codegen.config.yaml");
+  const schemaPath = path15.resolve(
     subsystemsRoot,
     "events",
     "domain-events.schema.ts"
   );
-  const generatedKeepPath = path14.resolve(
+  const generatedKeepPath = path15.resolve(
     subsystemsRoot,
     "events",
     "generated",
     ".gitkeep"
   );
   return {
-    appName: path14.basename(cwd),
+    appName: path15.basename(cwd),
     multiTenant: normaliseMultiTenant(eventsBlock.multi_tenant),
     configPath,
     schemaPath,
@@ -5771,7 +6999,7 @@ function localsToHygenArgs(locals) {
 }
 
 // src/cli/shared/jobs-scaffold-locals.ts
-import path15 from "path";
+import path16 from "path";
 var MAIN_HOOK_SENTINEL = "JOBS \u2014 Embedded worker mode (optional)";
 function workerSkipValue(exists) {
   return exists ? "true" : "";
@@ -5780,10 +7008,10 @@ function resolveJobsScaffoldLocals(input) {
   const { cwd, config, fileExists, readFile } = input;
   const jobsBlock = config?.jobs ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const workerPath = path15.resolve(cwd, "worker.ts");
-  const mainTsPath = path15.resolve(cwd, "src/main.ts");
-  const configPath = path15.resolve(cwd, "codegen.config.yaml");
-  const schemaPath = path15.resolve(
+  const workerPath = path16.resolve(cwd, "worker.ts");
+  const mainTsPath = path16.resolve(cwd, "src/main.ts");
+  const configPath = path16.resolve(cwd, "codegen.config.yaml");
+  const schemaPath = path16.resolve(
     subsystemsRoot,
     "jobs",
     "job-orchestration.schema.ts"
@@ -5791,7 +7019,7 @@ function resolveJobsScaffoldLocals(input) {
   const mainContent = readFile(mainTsPath);
   const mainHookInjected = mainContent !== null && mainContent.includes(MAIN_HOOK_SENTINEL);
   return {
-    appName: path15.basename(cwd),
+    appName: path16.basename(cwd),
     workerMode: normaliseWorkerMode(jobsBlock.worker_mode),
     multiTenant: normaliseMultiTenant2(jobsBlock.multi_tenant),
     mainTsPath,
@@ -5833,20 +7061,20 @@ function localsToHygenArgs2(locals) {
 }
 
 // src/cli/shared/integration-scaffold-locals.ts
-import path16 from "path";
+import path17 from "path";
 function resolveIntegrationScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const integrationBlock = config?.integration ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const configPath = path16.resolve(cwd, "codegen.config.yaml");
-  const schemaPath = path16.resolve(
+  const configPath = path17.resolve(cwd, "codegen.config.yaml");
+  const schemaPath = path17.resolve(
     subsystemsRoot,
     "integration",
     "integration-audit.schema.ts"
   );
   return {
-    appName: path16.basename(cwd),
+    appName: path17.basename(cwd),
     multiTenant: normaliseMultiTenant3(integrationBlock.multi_tenant),
     configPath,
     schemaPath
@@ -5869,21 +7097,21 @@ function localsToHygenArgs3(locals) {
 }
 
 // src/cli/shared/bridge-scaffold-locals.ts
-import path17 from "path";
+import path18 from "path";
 function resolveBridgeScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const bridgeBlock = config?.bridge ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const configPath = path17.resolve(cwd, "codegen.config.yaml");
-  const generatedKeepPath = path17.resolve(
+  const configPath = path18.resolve(cwd, "codegen.config.yaml");
+  const generatedKeepPath = path18.resolve(
     subsystemsRoot,
     "bridge",
     "generated",
     ".gitkeep"
   );
   return {
-    appName: path17.basename(cwd),
+    appName: path18.basename(cwd),
     multiTenant: normaliseMultiTenant4(bridgeBlock.multi_tenant),
     configPath,
     generatedKeepPath
@@ -5906,19 +7134,19 @@ function localsToHygenArgs4(locals) {
 }
 
 // src/cli/shared/observability-scaffold-locals.ts
-import path18 from "path";
+import path19 from "path";
 var FALLBACK_BACKEND_SRC2 = "src";
 function resolveObservabilityScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const backendSrc = typeof config?.paths?.backend_src === "string" && config.paths.backend_src.length > 0 ? config.paths.backend_src : FALLBACK_BACKEND_SRC2;
-  const appModulePath = path18.resolve(cwd, backendSrc, "app.module.ts");
-  const configPath = path18.resolve(cwd, "codegen.config.yaml");
+  const appModulePath = path19.resolve(cwd, backendSrc, "app.module.ts");
+  const configPath = path19.resolve(cwd, "codegen.config.yaml");
   const obsBlock = config?.observability ?? {};
   const reporters = obsBlock.reporters ?? {};
   const bridgeMetrics = reporters.bridgeMetrics ?? {};
   return {
-    appName: path18.basename(cwd),
+    appName: path19.basename(cwd),
     appModulePath,
     configPath,
     bridgeMetricsEnabled: bridgeMetrics.enabled === true
@@ -5939,7 +7167,7 @@ function localsToHygenArgs5(locals) {
 
 // src/cli/shared/auth-scaffold-locals.ts
 import crypto from "crypto";
-import path19 from "path";
+import path20 from "path";
 var FALLBACK_BACKEND_SRC3 = "src";
 var DEFAULT_REDIRECT_URI_BASE = "http://localhost:3000";
 function resolveAuthScaffoldLocals(input) {
@@ -5951,15 +7179,15 @@ function resolveAuthScaffoldLocals(input) {
   const redirectUriBase = typeof redirectRaw === "string" && redirectRaw.length > 0 ? redirectRaw : DEFAULT_REDIRECT_URI_BASE;
   const tokenEncryptionKey = crypto.randomBytes(32).toString("base64");
   return {
-    appName: path19.basename(cwd),
-    configPath: path19.resolve(cwd, "codegen.config.yaml"),
-    schemaPath: path19.resolve(
+    appName: path20.basename(cwd),
+    configPath: path20.resolve(cwd, "codegen.config.yaml"),
+    schemaPath: path20.resolve(
       subsystemsRoot,
       "auth",
       "auth-oauth-state.schema.ts"
     ),
-    appModulePath: path19.resolve(cwd, backendSrc, "app.module.ts"),
-    envConfigPath: path19.resolve(cwd, ".env.config"),
+    appModulePath: path20.resolve(cwd, backendSrc, "app.module.ts"),
+    envConfigPath: path20.resolve(cwd, ".env.config"),
     redirectUriBase,
     tokenEncryptionKey
   };
@@ -5984,7 +7212,7 @@ function localsToHygenArgs6(locals) {
 }
 
 // src/cli/shared/auth-integrations-scaffold-locals.ts
-import path20 from "path";
+import path21 from "path";
 var FALLBACK_BACKEND_SRC4 = "src";
 var DEFAULT_MODULES_DIR = "modules";
 var DEFAULT_DEFINITIONS_DIR = "definitions/entities";
@@ -5993,17 +7221,17 @@ function resolveAuthIntegrationsScaffoldLocals(input) {
   const backendSrc = typeof config?.paths?.backend_src === "string" && config.paths.backend_src.length > 0 ? config.paths.backend_src : FALLBACK_BACKEND_SRC4;
   const pathsAny = config?.paths;
   const modulesConfigured = pathsAny?.modules_dir;
-  const vendorRoot = typeof modulesConfigured === "string" && modulesConfigured.length > 0 ? path20.resolve(cwd, modulesConfigured) : path20.resolve(cwd, backendSrc, DEFAULT_MODULES_DIR);
+  const vendorRoot = typeof modulesConfigured === "string" && modulesConfigured.length > 0 ? path21.resolve(cwd, modulesConfigured) : path21.resolve(cwd, backendSrc, DEFAULT_MODULES_DIR);
   const entitiesConfigured = typeof pathsAny?.entities === "string" && pathsAny.entities.length > 0 ? pathsAny.entities : typeof pathsAny?.entities_dir === "string" && pathsAny.entities_dir.length > 0 ? pathsAny.entities_dir : null;
-  const definitionsPath = entitiesConfigured !== null ? path20.resolve(cwd, entitiesConfigured, "connection.yaml") : path20.resolve(cwd, DEFAULT_DEFINITIONS_DIR, "connection.yaml");
-  const appModulePath = path20.resolve(cwd, backendSrc, "app.module.ts");
+  const definitionsPath = entitiesConfigured !== null ? path21.resolve(cwd, entitiesConfigured, "connection.yaml") : path21.resolve(cwd, DEFAULT_DEFINITIONS_DIR, "connection.yaml");
+  const appModulePath = path21.resolve(cwd, backendSrc, "app.module.ts");
   let authModuleRegistered = false;
   const appModuleSource = input.readFile(appModulePath);
   if (appModuleSource && appModuleSource.includes("AuthModule.forRoot")) {
     authModuleRegistered = true;
   }
   return {
-    appName: path20.basename(cwd),
+    appName: path21.basename(cwd),
     appModulePath,
     vendorRoot,
     definitionsPath,
@@ -6021,7 +7249,7 @@ function localsToHygenArgs7(locals) {
 
 // src/cli/shared/runtime-copier.ts
 import fs11 from "fs";
-import path21 from "path";
+import path22 from "path";
 function readIfExists(p) {
   try {
     return fs11.readFileSync(p, "utf-8");
@@ -6039,8 +7267,8 @@ function extractRelativeImports(source) {
   return out;
 }
 function resolveSourceImport(sourceFile, specifier) {
-  const base = path21.resolve(path21.dirname(sourceFile), specifier);
-  const candidates = [base + ".ts", base + ".tsx", path21.join(base, "index.ts")];
+  const base = path22.resolve(path22.dirname(sourceFile), specifier);
+  const candidates = [base + ".ts", base + ".tsx", path22.join(base, "index.ts")];
   for (const c of candidates) {
     if (fs11.existsSync(c)) return c;
   }
@@ -6051,8 +7279,8 @@ async function copyRuntime(opts) {
   if (!fs11.existsSync(sourceDir) || !fs11.statSync(sourceDir).isDirectory()) {
     throw new Error(`runtime source directory not found: ${sourceDir}`);
   }
-  const runtimeRoot4 = opts.runtimeRoot ? path21.resolve(opts.runtimeRoot) : path21.resolve(sourceDir, "..", "..");
-  const depsTargetRoot = opts.depsTargetRoot ?? path21.resolve(targetDir, "..");
+  const runtimeRoot4 = opts.runtimeRoot ? path22.resolve(opts.runtimeRoot) : path22.resolve(sourceDir, "..", "..");
+  const depsTargetRoot = opts.depsTargetRoot ?? path22.resolve(targetDir, "..");
   const result = {
     written: [],
     updated: [],
@@ -6063,7 +7291,7 @@ async function copyRuntime(opts) {
   const queue = [];
   function walk(dir) {
     for (const entry of fs11.readdirSync(dir)) {
-      const src = path21.join(dir, entry);
+      const src = path22.join(dir, entry);
       const stat = fs11.statSync(src);
       if (stat.isDirectory()) {
         if (entry === "generated") continue;
@@ -6072,9 +7300,9 @@ async function copyRuntime(opts) {
       }
       if (!stat.isFile()) continue;
       if (!entry.endsWith(".ts") && !entry.endsWith(".tsx")) continue;
-      const rel2 = path21.relative(sourceDir, src);
+      const rel2 = path22.relative(sourceDir, src);
       if (filter && !filter(rel2) && !filter(entry)) continue;
-      queue.push({ src, dest: path21.join(targetDir, rel2), isDep: false });
+      queue.push({ src, dest: path22.join(targetDir, rel2), isDep: false });
     }
   }
   walk(sourceDir);
@@ -6095,18 +7323,18 @@ async function copyRuntime(opts) {
     else result.unchanged.push(next.dest);
     if (next.isDep) result.dependenciesCopied.push(next.dest);
     if (!dryRun && status !== "unchanged") {
-      fs11.mkdirSync(path21.dirname(next.dest), { recursive: true });
+      fs11.mkdirSync(path22.dirname(next.dest), { recursive: true });
       fs11.writeFileSync(next.dest, content);
     }
     if (resolveDeps) {
       for (const spec of extractRelativeImports(content)) {
         const resolvedSrc = resolveSourceImport(next.src, spec);
         if (!resolvedSrc) continue;
-        const relToRuntime = path21.relative(runtimeRoot4, resolvedSrc);
-        if (relToRuntime.startsWith("..") || path21.isAbsolute(relToRuntime)) continue;
-        const relToSource = path21.relative(sourceDir, resolvedSrc);
-        if (!relToSource.startsWith("..") && !path21.isAbsolute(relToSource)) continue;
-        const depDest = path21.join(depsTargetRoot, relToRuntime);
+        const relToRuntime = path22.relative(runtimeRoot4, resolvedSrc);
+        if (relToRuntime.startsWith("..") || path22.isAbsolute(relToRuntime)) continue;
+        const relToSource = path22.relative(sourceDir, resolvedSrc);
+        if (!relToSource.startsWith("..") && !path22.isAbsolute(relToSource)) continue;
+        const depDest = path22.join(depsTargetRoot, relToRuntime);
         queue.push({ src: resolvedSrc, dest: depDest, isDep: true });
       }
     }
@@ -6116,7 +7344,7 @@ async function copyRuntime(opts) {
 
 // src/cli/shared/subsystems-install-config.ts
 import fs12 from "fs";
-import path22 from "path";
+import path23 from "path";
 import yaml2 from "yaml";
 function readInstallList(config) {
   const raw = config?.subsystems?.install;
@@ -6125,7 +7353,7 @@ function readInstallList(config) {
 }
 function ensureSubsystemInstalled(configPath, name) {
   if (!fs12.existsSync(configPath)) {
-    fs12.mkdirSync(path22.dirname(configPath), { recursive: true });
+    fs12.mkdirSync(path23.dirname(configPath), { recursive: true });
     fs12.writeFileSync(
       configPath,
       `subsystems:
@@ -6176,13 +7404,13 @@ ${indent}- ${name}${after}`;
 
 // src/cli/commands/subsystem.ts
 function runtimeRoot() {
-  const pkgRoot = path23.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path23.join(pkgRoot, "runtime");
+  const pkgRoot = path24.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path24.join(pkgRoot, "runtime");
   if (fs13.existsSync(topLevel)) return topLevel;
-  return path23.join(pkgRoot, "dist", "runtime");
+  return path24.join(pkgRoot, "dist", "runtime");
 }
 function subsystemSource(name) {
-  return path23.join(runtimeRoot(), "subsystems", name);
+  return path24.join(runtimeRoot(), "subsystems", name);
 }
 function describeSubsystem(name) {
   return SUBSYSTEMS.find((s) => s.name === name) ?? null;
@@ -6217,7 +7445,7 @@ async function summary2(ctx) {
   }
   body.push(theme.muted("Installed:"));
   for (const i of installed) {
-    const rel2 = path23.relative(ctx.cwd, i.path) || i.path;
+    const rel2 = path24.relative(ctx.cwd, i.path) || i.path;
     body.push(
       `  ${theme.success(icons.check)} ${i.name.padEnd(10)} ${theme.muted(
         `${i.backend} backend`
@@ -6360,14 +7588,14 @@ var SubsystemInstallCommand = class extends Command3 {
       return 0;
     }
     const targetRoot = resolveSubsystemsRoot(ctx, this.target);
-    const subsystemTarget = path23.join(targetRoot, desc.name);
+    const subsystemTarget = path24.join(targetRoot, desc.name);
     const source = subsystemSource(desc.name);
     if (!fs13.existsSync(source)) {
       printError(`Runtime subsystem source missing: ${source}`);
       return 1;
     }
     if (!this.force) {
-      const gitCheck = checkGitSafety([path23.relative(ctx.cwd, subsystemTarget) || subsystemTarget], ctx.cwd);
+      const gitCheck = checkGitSafety([path24.relative(ctx.cwd, subsystemTarget) || subsystemTarget], ctx.cwd);
       if (gitCheck.inRepo && !gitCheck.clean) {
         printWarning(
           `Uncommitted changes under ${subsystemTarget}. Pass --force to overwrite.`
@@ -6376,7 +7604,7 @@ var SubsystemInstallCommand = class extends Command3 {
       }
     }
     if (!isJsonMode()) {
-      printInfo(`target = ${path23.relative(ctx.cwd, subsystemTarget) || subsystemTarget}`);
+      printInfo(`target = ${path24.relative(ctx.cwd, subsystemTarget) || subsystemTarget}`);
       printInfo(`backend = ${backend}`);
     }
     const result = await copyRuntime({
@@ -6385,7 +7613,7 @@ var SubsystemInstallCommand = class extends Command3 {
       filter: backendFileFilter(backend, desc.name),
       resolveDeps: true,
       runtimeRoot: runtimeRoot(),
-      depsTargetRoot: path23.resolve(targetRoot, ".."),
+      depsTargetRoot: path24.resolve(targetRoot, ".."),
       dryRun: this.dryRun
     });
     const jobsScaffold = desc.name === "jobs" ? runJobsScaffold(ctx.cwd, ctx.config, {
@@ -6480,14 +7708,14 @@ var SubsystemInstallCommand = class extends Command3 {
     if (this.dryRun) {
       printInfo(`Dry run \u2014 ${result.planned.length} files would be written`);
       for (const p of result.planned) {
-        console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`);
+        console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
       }
       if (jobsScaffold?.planned?.length) {
         printInfo(
           `Jobs scaffold \u2014 ${jobsScaffold.planned.length} template targets`
         );
         for (const p of jobsScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (eventsScaffold?.planned?.length) {
@@ -6495,7 +7723,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Events scaffold \u2014 ${eventsScaffold.planned.length} template targets`
         );
         for (const p of eventsScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (integrationScaffold?.planned?.length) {
@@ -6503,7 +7731,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Integration scaffold \u2014 ${integrationScaffold.planned.length} template targets`
         );
         for (const p of integrationScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (bridgeScaffold?.planned?.length) {
@@ -6511,7 +7739,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Bridge scaffold \u2014 ${bridgeScaffold.planned.length} template targets`
         );
         for (const p of bridgeScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (observabilityScaffold?.planned?.length) {
@@ -6519,7 +7747,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Observability scaffold \u2014 ${observabilityScaffold.planned.length} template targets`
         );
         for (const p of observabilityScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (authScaffold?.planned?.length) {
@@ -6527,7 +7755,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Auth scaffold \u2014 ${authScaffold.planned.length} template targets`
         );
         for (const p of authScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       return 0;
@@ -6657,7 +7885,7 @@ var SubsystemInstallCommand = class extends Command3 {
    * `--force-config` and always regenerates the barrels).
    */
   async executePackageMode(ctx, desc, backend) {
-    const configPath = path23.join(ctx.cwd, "codegen.config.yaml");
+    const configPath = path24.join(ctx.cwd, "codegen.config.yaml");
     const installed = configuredSubsystemNames(
       ctx.config
     );
@@ -6784,7 +8012,7 @@ var SubsystemInstallCommand = class extends Command3 {
    * semantics as jobs/events/integration/bridge.
    */
   async executeOpenApiConfig(ctx) {
-    const configPath = path23.join(ctx.cwd, "codegen.config.yaml");
+    const configPath = path24.join(ctx.cwd, "codegen.config.yaml");
     const outcome = planConfigBlockAction(configPath, "openapi", this.forceConfig);
     if (outcome === "parse-error") {
       printError(
@@ -6803,7 +8031,7 @@ var SubsystemInstallCommand = class extends Command3 {
         });
       } else {
         printInfo(`Dry run \u2014 openapi config block would be ${outcome}`);
-        console.log(`  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, configPath) || configPath}`);
+        console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, configPath) || configPath}`);
       }
       return 0;
     }
@@ -6898,7 +8126,7 @@ var SubsystemInstallCommand = class extends Command3 {
       );
       for (const p of scaffold.planned) {
         console.log(
-          `  ${theme.muted(icons.arrow)} ${path23.relative(ctx.cwd, p) || p}`
+          `  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`
         );
       }
       return 0;
@@ -7281,7 +8509,7 @@ function runAuthScaffold(cwd, config, opts) {
     return { ok: true, planned, configBlockOutcome };
   }
   if (!fs13.existsSync(locals.envConfigPath)) {
-    fs13.mkdirSync(path23.dirname(locals.envConfigPath), { recursive: true });
+    fs13.mkdirSync(path24.dirname(locals.envConfigPath), { recursive: true });
     fs13.writeFileSync(locals.envConfigPath, "", "utf-8");
   }
   const result = invokeHygen({
@@ -7318,10 +8546,10 @@ function runAuthScaffold(cwd, config, opts) {
   return { ok: true, planned, configBlockOutcome };
 }
 function authIntegrationsExamplesRoot() {
-  const pkgRoot = path23.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path23.join(pkgRoot, "examples", "auth-integrations");
+  const pkgRoot = path24.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path24.join(pkgRoot, "examples", "auth-integrations");
   if (fs13.existsSync(topLevel)) return topLevel;
-  return path23.join(pkgRoot, "dist", "examples", "auth-integrations");
+  return path24.join(pkgRoot, "dist", "examples", "auth-integrations");
 }
 function copyTreeIdempotent(srcDir, destDir, force, transform) {
   const written = [];
@@ -7329,8 +8557,8 @@ function copyTreeIdempotent(srcDir, destDir, force, transform) {
   const walk = (src, dest) => {
     const entries = fs13.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path23.join(src, entry.name);
-      const destPath = path23.join(dest, entry.name);
+      const srcPath = path24.join(src, entry.name);
+      const destPath = path24.join(dest, entry.name);
       if (entry.isDirectory()) {
         fs13.mkdirSync(destPath, { recursive: true });
         walk(srcPath, destPath);
@@ -7341,7 +8569,7 @@ function copyTreeIdempotent(srcDir, destDir, force, transform) {
         skipped.push(destPath);
         continue;
       }
-      fs13.mkdirSync(path23.dirname(destPath), { recursive: true });
+      fs13.mkdirSync(path24.dirname(destPath), { recursive: true });
       const isTextSource = transform && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"));
       if (isTextSource && transform) {
         const raw = fs13.readFileSync(srcPath, "utf-8");
@@ -7359,16 +8587,16 @@ function copyTreeIdempotent(srcDir, destDir, force, transform) {
 }
 var AUTH_BARE_IMPORT_RE = /(['"])@pattern-stack\/codegen\/runtime\/subsystems\/auth\1/g;
 function buildAuthImportRewriter(subsystemsRoot) {
-  const authRoot = path23.join(subsystemsRoot, "auth");
+  const authRoot = path24.join(subsystemsRoot, "auth");
   return (content, destPath) => {
     if (!AUTH_BARE_IMPORT_RE.test(content)) {
       AUTH_BARE_IMPORT_RE.lastIndex = 0;
       return content;
     }
     AUTH_BARE_IMPORT_RE.lastIndex = 0;
-    let rel2 = path23.relative(path23.dirname(destPath), authRoot);
+    let rel2 = path24.relative(path24.dirname(destPath), authRoot);
     if (!rel2.startsWith(".")) rel2 = `./${rel2}`;
-    const relPosix = rel2.split(path23.sep).join("/");
+    const relPosix = rel2.split(path24.sep).join("/");
     return content.replace(
       AUTH_BARE_IMPORT_RE,
       (_match, quote) => `${quote}${relPosix}${quote}`
@@ -7390,9 +8618,9 @@ function runAuthIntegrationsScaffold(cwd, config, opts) {
       error: `auth-integrations starter source missing: ${examplesRoot}`
     };
   }
-  const adaptersSrc = path23.join(examplesRoot, "runtime", "connections");
-  const adaptersDest = path23.join(locals.vendorRoot, "connections");
-  const connectionYamlSrc = path23.join(
+  const adaptersSrc = path24.join(examplesRoot, "runtime", "connections");
+  const adaptersDest = path24.join(locals.vendorRoot, "connections");
+  const connectionYamlSrc = path24.join(
     examplesRoot,
     "definitions",
     "entities",
@@ -7424,7 +8652,7 @@ function runAuthIntegrationsScaffold(cwd, config, opts) {
     if (fs13.existsSync(connectionYamlDest) && !opts.force) {
       yamlSkipped = true;
     } else if (fs13.existsSync(connectionYamlSrc)) {
-      fs13.mkdirSync(path23.dirname(connectionYamlDest), { recursive: true });
+      fs13.mkdirSync(path24.dirname(connectionYamlDest), { recursive: true });
       fs13.copyFileSync(connectionYamlSrc, connectionYamlDest);
       yamlWritten = true;
     }
@@ -7490,7 +8718,7 @@ var SubsystemListCommand = class extends Command3 {
         name: s.name,
         status: inst ? inst.status : "available",
         backend: inst ? inst.backend : null,
-        path: inst ? path23.relative(ctx.cwd, inst.path) || inst.path : null
+        path: inst ? path24.relative(ctx.cwd, inst.path) || inst.path : null
       };
     });
     if (isJsonMode()) {
@@ -7586,7 +8814,7 @@ var SubsystemRemoveCommand = class extends Command3 {
       return 1;
     }
     if (!this.force) {
-      const rel2 = path23.relative(ctx.cwd, subsystemDir) || subsystemDir;
+      const rel2 = path24.relative(ctx.cwd, subsystemDir) || subsystemDir;
       const gitCheck = checkGitSafety([rel2], ctx.cwd);
       if (gitCheck.inRepo && !gitCheck.clean) {
         printWarning(
@@ -7622,7 +8850,7 @@ var SubsystemRemoveCommand = class extends Command3 {
       return 0;
     }
     printSuccess(
-      `${desc.name} subsystem removed (${path23.relative(ctx.cwd, subsystemDir) || subsystemDir}).`
+      `${desc.name} subsystem removed (${path24.relative(ctx.cwd, subsystemDir) || subsystemDir}).`
     );
     if (barrelRegenerated) {
       printInfo("Regenerated <generated>/subsystems.ts barrel.");
@@ -7651,27 +8879,27 @@ var subsystem_default = subsystemNoun;
 
 // src/cli/commands/project.ts
 import fs19 from "fs";
-import path29 from "path";
+import path30 from "path";
 import readline from "readline";
 import { Command as Command7, Option as Option7 } from "clipanion";
 import { stringify as stringifyYaml2 } from "yaml";
 
 // src/cli/shared/init-scaffold.ts
 import fs14 from "fs";
-import path24 from "path";
+import path25 from "path";
 import { stringify as stringifyYaml } from "yaml";
 function runtimeRoot2() {
-  const pkgRoot = path24.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path24.join(pkgRoot, "runtime");
+  const pkgRoot = path25.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path25.join(pkgRoot, "runtime");
   if (fs14.existsSync(topLevel)) return topLevel;
-  return path24.join(pkgRoot, "dist", "runtime");
+  return path25.join(pkgRoot, "dist", "runtime");
 }
 function resolveRuntimePath(cwd) {
-  const shimDir = path24.join(cwd, "src", "shared", "base-classes");
-  return path24.relative(shimDir, runtimeRoot2());
+  const shimDir = path25.join(cwd, "src", "shared", "base-classes");
+  return path25.relative(shimDir, runtimeRoot2());
 }
 function loadRuntimeFile(relPath) {
-  return fs14.readFileSync(path24.join(runtimeRoot2(), relPath), "utf-8");
+  return fs14.readFileSync(path25.join(runtimeRoot2(), relPath), "utf-8");
 }
 var VENDORED_RUNTIME_FILES = [
   // base-classes — consumer-facing inheritance targets
@@ -8087,8 +9315,38 @@ function mergeTsconfig(raw) {
     unchanged: false
   };
 }
+function mergeFrontendDeps(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return {
+      content: raw,
+      added: [],
+      unchanged: true,
+      parseError: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const deps = parsed.dependencies ?? {};
+  const added = [];
+  for (const [pkg, range] of Object.entries(FRONTEND_EMITTED_DEPS)) {
+    if (!(pkg in deps)) {
+      deps[pkg] = range;
+      added.push(pkg);
+    }
+  }
+  if (added.length === 0) {
+    return { content: raw, added: [], unchanged: true };
+  }
+  parsed.dependencies = deps;
+  return {
+    content: JSON.stringify(parsed, null, 2) + "\n",
+    added,
+    unchanged: false
+  };
+}
 function relOf(cwd, abs) {
-  return path24.relative(cwd, abs) || abs;
+  return path25.relative(cwd, abs) || abs;
 }
 function fileEntry(cwd, absPath, content, opts) {
   const exists = fs14.existsSync(absPath);
@@ -8139,7 +9397,7 @@ async function buildInitPlan(ctx, options) {
   const runtimePath = options.runtimePath ?? resolveRuntimePath(cwd);
   const entries = [];
   {
-    const configPath = path24.join(cwd, "codegen.config.yaml");
+    const configPath = path25.join(cwd, "codegen.config.yaml");
     const config = {
       // Runtime mode (ADR-037). `package` (default) imports the runtime from
       // `@pattern-stack/codegen/*`; `vendored` imports it via `@shared/*` and
@@ -8174,7 +9432,7 @@ async function buildInitPlan(ctx, options) {
     entries.push(fileEntry(cwd, configPath, content, { force }));
   }
   {
-    const tsconfigPath = path24.join(cwd, "tsconfig.json");
+    const tsconfigPath = path25.join(cwd, "tsconfig.json");
     if (fs14.existsSync(tsconfigPath)) {
       const raw = fs14.readFileSync(tsconfigPath, "utf-8");
       const merged = mergeTsconfig(raw);
@@ -8221,7 +9479,7 @@ async function buildInitPlan(ctx, options) {
   entries.push(
     fileEntry(
       cwd,
-      path24.join(cwd, "src", "shared", "database", "database.module.ts"),
+      path25.join(cwd, "src", "shared", "database", "database.module.ts"),
       databaseModuleContent(runtimeMode),
       { force }
     )
@@ -8229,14 +9487,14 @@ async function buildInitPlan(ctx, options) {
   if (runtimeMode === "vendored") {
     for (const v of VENDORED_RUNTIME_FILES) {
       entries.push(
-        fileEntry(cwd, path24.join(cwd, v.target), loadRuntimeFile(v.runtime), { force })
+        fileEntry(cwd, path25.join(cwd, v.target), loadRuntimeFile(v.runtime), { force })
       );
     }
   }
   entries.push(
     fileEntry(
       cwd,
-      path24.join(cwd, "src", "generated", "modules.ts"),
+      path25.join(cwd, "src", "generated", "modules.ts"),
       emptyModulesBarrel(),
       { force }
     )
@@ -8244,13 +9502,13 @@ async function buildInitPlan(ctx, options) {
   entries.push(
     fileEntry(
       cwd,
-      path24.join(cwd, "src", "generated", "schema.ts"),
+      path25.join(cwd, "src", "generated", "schema.ts"),
       emptySchemaBarrel(),
       { force }
     )
   );
   {
-    const appModulePath = path24.join(cwd, "src", "app.module.ts");
+    const appModulePath = path25.join(cwd, "src", "app.module.ts");
     if (!fs14.existsSync(appModulePath)) {
       entries.push({
         path: appModulePath,
@@ -8268,7 +9526,7 @@ async function buildInitPlan(ctx, options) {
     }
   }
   {
-    const mainPath = path24.join(cwd, "src", "main.ts");
+    const mainPath = path25.join(cwd, "src", "main.ts");
     if (!fs14.existsSync(mainPath)) {
       entries.push({
         path: mainPath,
@@ -8286,7 +9544,7 @@ async function buildInitPlan(ctx, options) {
     }
   }
   {
-    const schemaPath = path24.join(cwd, "src", "schema.ts");
+    const schemaPath = path25.join(cwd, "src", "schema.ts");
     if (!fs14.existsSync(schemaPath)) {
       entries.push({
         path: schemaPath,
@@ -8303,12 +9561,12 @@ async function buildInitPlan(ctx, options) {
       });
     }
   }
-  entries.push(dirEntry(cwd, path24.join(cwd, "entities")));
+  entries.push(dirEntry(cwd, path25.join(cwd, "entities")));
   {
-    const entitiesDir = path24.join(cwd, "entities");
-    const examplePath = path24.join(entitiesDir, "example.yaml");
+    const entitiesDir = path25.join(cwd, "entities");
+    const examplePath = path25.join(entitiesDir, "example.yaml");
     const hasOtherYamls = fs14.existsSync(entitiesDir) && findYamlFiles(entitiesDir).some(
-      (f) => path24.basename(f) !== "example.yaml"
+      (f) => path25.basename(f) !== "example.yaml"
     );
     if (fs14.existsSync(examplePath)) {
       entries.push({
@@ -8333,6 +9591,46 @@ async function buildInitPlan(ctx, options) {
       });
     }
   }
+  if (frontend) {
+    const frontendSrc = ctx.config?.paths?.frontend_src ?? "apps/frontend/src";
+    const frontendRoot = path25.dirname(path25.join(cwd, frontendSrc));
+    const pkgPath = path25.join(frontendRoot, "package.json");
+    const depsList = Object.entries(FRONTEND_EMITTED_DEPS).map(([p, r]) => `${p}@${r}`).join(", ");
+    if (fs14.existsSync(pkgPath)) {
+      const raw = fs14.readFileSync(pkgPath, "utf-8");
+      const merged = mergeFrontendDeps(raw);
+      if (merged.parseError) {
+        entries.push({
+          path: pkgPath,
+          relPath: relOf(cwd, pkgPath),
+          action: "skip",
+          reason: `unable to parse (${merged.parseError}); add frontend deps manually: ${depsList}`
+        });
+      } else if (merged.unchanged) {
+        entries.push({
+          path: pkgPath,
+          relPath: relOf(cwd, pkgPath),
+          action: "skip",
+          reason: "frontend deps already present"
+        });
+      } else {
+        entries.push({
+          path: pkgPath,
+          relPath: relOf(cwd, pkgPath),
+          action: "merge",
+          content: merged.content,
+          reason: `add frontend deps: ${merged.added.join(", ")}`
+        });
+      }
+    } else {
+      entries.push({
+        path: pkgPath,
+        relPath: relOf(cwd, pkgPath),
+        action: "skip",
+        reason: `frontend enabled but ${relOf(cwd, pkgPath)} not found \u2014 install: ${depsList}`
+      });
+    }
+  }
   return {
     entries,
     summary: {
@@ -8364,7 +9662,7 @@ function writePlan(plan) {
       skipped.push(e);
       continue;
     }
-    fs14.mkdirSync(path24.dirname(e.path), { recursive: true });
+    fs14.mkdirSync(path25.dirname(e.path), { recursive: true });
     fs14.writeFileSync(e.path, e.content, "utf-8");
     if (e.action === "create") created.push(e);
     else if (e.action === "merge") merged.push(e);
@@ -8375,7 +9673,7 @@ function writePlan(plan) {
 
 // src/cli/commands/project-upgrade-openapi.ts
 import fs15 from "fs";
-import path25 from "path";
+import path26 from "path";
 import { Command as Command4, Option as Option4 } from "clipanion";
 import { Project, IndentationText, QuoteKind, NewLineKind } from "ts-morph";
 
@@ -8614,31 +9912,31 @@ var MAIN_SWAGGER_IMPORTS = [
   "import { OPENAPI_REGISTRY, OpenApiRegistry } from './shared/openapi';"
 ];
 function runtimeRoot3() {
-  const pkgRoot = path25.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path25.join(pkgRoot, "runtime");
+  const pkgRoot = path26.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path26.join(pkgRoot, "runtime");
   if (fs15.existsSync(topLevel)) return topLevel;
-  return path25.join(pkgRoot, "dist", "runtime");
+  return path26.join(pkgRoot, "dist", "runtime");
 }
 function loadRuntimeFile2(rel2) {
-  return fs15.readFileSync(path25.join(runtimeRoot3(), rel2), "utf-8");
+  return fs15.readFileSync(path26.join(runtimeRoot3(), rel2), "utf-8");
 }
 function resolveProjectRoot(startDir) {
-  let dir = path25.resolve(startDir);
+  let dir = path26.resolve(startDir);
   for (let i = 0; i < 16; i++) {
-    if (fs15.existsSync(path25.join(dir, "codegen.config.yaml")) || fs15.existsSync(path25.join(dir, "package.json"))) {
+    if (fs15.existsSync(path26.join(dir, "codegen.config.yaml")) || fs15.existsSync(path26.join(dir, "package.json"))) {
       return dir;
     }
-    const parent = path25.dirname(dir);
+    const parent = path26.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path25.resolve(startDir);
+  return path26.resolve(startDir);
 }
 async function runUpgradeOpenapi(opts) {
   const { projectRoot, dryRun, force } = opts;
   const changes = [];
   for (const v of OPENAPI_VENDORED_FILES) {
-    const target = path25.join(projectRoot, v.target);
+    const target = path26.join(projectRoot, v.target);
     const exists = fs15.existsSync(target);
     const newContent = loadRuntimeFile2(v.runtime);
     if (exists && !force) {
@@ -8654,7 +9952,7 @@ async function runUpgradeOpenapi(opts) {
       }
     } else {
       if (!dryRun) {
-        fs15.mkdirSync(path25.dirname(target), { recursive: true });
+        fs15.mkdirSync(path26.dirname(target), { recursive: true });
         fs15.writeFileSync(target, newContent);
       }
       changes.push({
@@ -8663,7 +9961,7 @@ async function runUpgradeOpenapi(opts) {
       });
     }
   }
-  const appModulePath = path25.join(projectRoot, "src", "app.module.ts");
+  const appModulePath = path26.join(projectRoot, "src", "app.module.ts");
   if (!fs15.existsSync(appModulePath)) {
     return {
       projectRoot,
@@ -8747,7 +10045,7 @@ async function runUpgradeOpenapi(opts) {
   } else {
     changes.push({ path: "src/app.module.ts", action: "unchanged" });
   }
-  const mainPath = path25.join(projectRoot, "src", "main.ts");
+  const mainPath = path26.join(projectRoot, "src", "main.ts");
   if (fs15.existsSync(mainPath)) {
     const mainSource = project.addSourceFileAtPath(mainPath);
     const mainBefore = mainSource.getFullText();
@@ -8828,7 +10126,7 @@ var ProjectUpgradeOpenapiCommand = class extends Command4 {
   json = Option4.Boolean("--json", false);
   async execute() {
     if (this.json) setJsonMode(true);
-    const startDir = this.pathOpt ? path25.resolve(this.pathOpt) : process.cwd();
+    const startDir = this.pathOpt ? path26.resolve(this.pathOpt) : process.cwd();
     if (!fs15.existsSync(startDir)) {
       printError(`Directory not found: ${startDir}`);
       return 1;
@@ -8905,17 +10203,17 @@ ${CONSUMER_SETUP_POINTER}
 
 // src/cli/commands/project-update.ts
 import fs18 from "fs";
-import path28 from "path";
+import path29 from "path";
 import { Command as Command6, Option as Option6 } from "clipanion";
 
 // src/cli/commands/skills.ts
 import fs17 from "fs";
-import path27 from "path";
+import path28 from "path";
 import { Command as Command5, Option as Option5 } from "clipanion";
 
 // src/cli/shared/tree-copier.ts
 import fs16 from "fs";
-import path26 from "path";
+import path27 from "path";
 var TEXT_EXTENSIONS = [".ts", ".tsx", ".md", ".mdx", ".yaml", ".yml", ".json"];
 function isTextFile(name) {
   return TEXT_EXTENSIONS.some((ext) => name.endsWith(ext));
@@ -8932,17 +10230,17 @@ function copyTreeWithReport(opts) {
     throw new Error(`tree-copier source directory not found: ${srcDir}`);
   }
   const walk = (relDir) => {
-    const absSrcDir = path26.join(srcDir, relDir);
+    const absSrcDir = path27.join(srcDir, relDir);
     for (const entry of fs16.readdirSync(absSrcDir, { withFileTypes: true })) {
-      const relPath = relDir ? path26.posix.join(relDir, entry.name) : entry.name;
-      const absSrc = path26.join(srcDir, relPath);
+      const relPath = relDir ? path27.posix.join(relDir, entry.name) : entry.name;
+      const absSrc = path27.join(srcDir, relPath);
       if (entry.isDirectory()) {
         walk(relPath);
         continue;
       }
       if (!entry.isFile()) continue;
       if (include && !include(relPath)) continue;
-      const dest = path26.join(destDir, relPath);
+      const dest = path27.join(destDir, relPath);
       let content = fs16.readFileSync(absSrc, "utf-8");
       if (transform && isTextFile(entry.name)) {
         content = transform(content, dest);
@@ -8957,7 +10255,7 @@ function copyTreeWithReport(opts) {
         action = "updated";
       }
       if (!dryRun && action !== "unchanged") {
-        fs16.mkdirSync(path26.dirname(dest), { recursive: true });
+        fs16.mkdirSync(path27.dirname(dest), { recursive: true });
         fs16.writeFileSync(dest, content, "utf-8");
       }
       const record = { relPath, dest, action };
@@ -8971,13 +10269,13 @@ function copyTreeWithReport(opts) {
 
 // src/cli/commands/skills.ts
 function consumerSkillsRoot() {
-  const pkgRoot = path27.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path27.join(pkgRoot, "consumer-skills");
+  const pkgRoot = path28.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path28.join(pkgRoot, "consumer-skills");
   if (fs17.existsSync(topLevel)) return topLevel;
-  return path27.join(pkgRoot, "dist", "consumer-skills");
+  return path28.join(pkgRoot, "dist", "consumer-skills");
 }
 function skillsTargetDir(cwd) {
-  return path27.join(cwd, ".claude", "skills");
+  return path28.join(cwd, ".claude", "skills");
 }
 function availableSkills() {
   const root = consumerSkillsRoot();
@@ -9024,13 +10322,13 @@ async function summary3(ctx) {
   return {
     title: "skills",
     body,
-    footer: `${installedCount} of ${skills.length} skills installed \u2192 ${path27.relative(ctx.cwd, targetDir) || targetDir}`
+    footer: `${installedCount} of ${skills.length} skills installed \u2192 ${path28.relative(ctx.cwd, targetDir) || targetDir}`
   };
 }
 async function hints3(ctx) {
   const skills = availableSkills();
   const targetDir = skillsTargetDir(ctx.cwd);
-  const allPresent = skills.length > 0 && fs17.existsSync(targetDir) && skills.every((s) => fs17.existsSync(path27.join(targetDir, s)));
+  const allPresent = skills.length > 0 && fs17.existsSync(targetDir) && skills.every((s) => fs17.existsSync(path28.join(targetDir, s)));
   if (allPresent) {
     return [
       { command: "codegen update", description: "Re-sync skills + runtime after a package bump" }
@@ -9105,7 +10403,7 @@ var SkillsInstallCommand = class extends Command5 {
       });
       return 0;
     }
-    printInfo(`target = ${path27.relative(ctx.cwd, result.targetDir) || result.targetDir}`);
+    printInfo(`target = ${path28.relative(ctx.cwd, result.targetDir) || result.targetDir}`);
     console.log("");
     renderTreeReport(report);
     console.log("");
@@ -9133,7 +10431,7 @@ var SkillsListCommand = class extends Command5 {
     const skills = availableSkills();
     const targetDir = skillsTargetDir(ctx.cwd);
     const rows = skills.map((name) => {
-      const dir = path27.join(targetDir, name);
+      const dir = path28.join(targetDir, name);
       return { name, status: fs17.existsSync(dir) ? "installed" : "available" };
     });
     if (isJsonMode()) {
@@ -9163,7 +10461,7 @@ var NON_RUNTIME_SUBSYSTEMS = /* @__PURE__ */ new Set(["openapi-config", "auth-in
 function syncVendoredRuntime(cwd, write) {
   const changes = [];
   for (const v of VENDORED_RUNTIME_FILES) {
-    const dest = path28.join(cwd, v.target);
+    const dest = path29.join(cwd, v.target);
     const content = loadRuntimeFile(v.runtime);
     const existing = fs18.existsSync(dest) ? fs18.readFileSync(dest, "utf-8") : null;
     let action;
@@ -9171,7 +10469,7 @@ function syncVendoredRuntime(cwd, write) {
     else if (existing === content) action = "unchanged";
     else action = "updated";
     if (write && action !== "unchanged") {
-      fs18.mkdirSync(path28.dirname(dest), { recursive: true });
+      fs18.mkdirSync(path29.dirname(dest), { recursive: true });
       fs18.writeFileSync(dest, content, "utf-8");
     }
     changes.push({ path: v.target, action });
@@ -9186,14 +10484,14 @@ async function syncSubsystemRuntime(cwd, inst, write) {
   if (!fs18.existsSync(source)) {
     return { name: inst.name, changes: [], skippedReason: "no runtime source in package" };
   }
-  const subsystemsRoot = path28.dirname(inst.path);
+  const subsystemsRoot = path29.dirname(inst.path);
   const result = await copyRuntime({
     sourceDir: source,
     targetDir: inst.path,
     filter: backendFileFilter(inst.backend, inst.name),
     resolveDeps: true,
     runtimeRoot: runtimeRoot2(),
-    depsTargetRoot: path28.resolve(subsystemsRoot, ".."),
+    depsTargetRoot: path29.resolve(subsystemsRoot, ".."),
     dryRun: !write,
     // Refresh files already vendored for this subsystem; never install new
     // ones (that's `subsystem install`). copyRuntime classifies accurately
@@ -9207,7 +10505,7 @@ async function syncSubsystemRuntime(cwd, inst, write) {
   return { name: inst.name, changes };
 }
 function rel(cwd, abs) {
-  return path28.relative(cwd, abs) || abs;
+  return path29.relative(cwd, abs) || abs;
 }
 var ProjectUpdateCommand = class extends Command6 {
   static paths = [["project", "update"]];
@@ -9246,7 +10544,7 @@ var ProjectUpdateCommand = class extends Command6 {
     const installed = this.skipSubsystems ? [] : await detectInstalledSubsystems(ctx);
     if (!this.dryRun && !this.force) {
       const vendoredDry = syncVendoredRuntime(ctx.cwd, false);
-      const vendoredDirtyCandidates = vendoredDry.filter((c) => c.action === "updated").map((c) => path28.join(ctx.cwd, c.path));
+      const vendoredDirtyCandidates = vendoredDry.filter((c) => c.action === "updated").map((c) => path29.join(ctx.cwd, c.path));
       const skillDirtyCandidates = this.skipSkills ? [] : runSkillsInstall({ cwd: ctx.cwd, dryRun: true }).report?.updated.map((e) => e.dest) ?? [];
       const subsystemDirs = installed.filter((i) => !NON_RUNTIME_SUBSYSTEMS.has(i.name)).map((i) => i.path);
       const gate = checkGitSafety(
@@ -9597,8 +10895,8 @@ var ProjectScanCommand = class extends Command7 {
   cwd = Option7.String("--cwd", { required: false });
   async execute() {
     if (this.json) setJsonMode(true);
-    const baseCwd = this.cwd ? path29.resolve(this.cwd) : process.cwd();
-    const target = this.directory ? path29.resolve(baseCwd, this.directory) : baseCwd;
+    const baseCwd = this.cwd ? path30.resolve(this.cwd) : process.cwd();
+    const target = this.directory ? path30.resolve(baseCwd, this.directory) : baseCwd;
     if (!fs19.existsSync(target)) {
       printError(`Directory not found: ${target}`);
       return 1;
@@ -9649,7 +10947,7 @@ var ProjectScanCommand = class extends Command7 {
         `architecture: ${profile.architecture.evidence.join(", ") || "\u2014"}`
       ]);
     }
-    const outPath = path29.join(target, "codegen.config.yaml");
+    const outPath = path30.join(target, "codegen.config.yaml");
     const existsNow = fs19.existsSync(outPath);
     if (this.dryRun) {
       console.log("");
@@ -9770,8 +11068,8 @@ var ProjectInspectCommand = class extends Command7 {
     return 2;
   }
   resolveEntitiesDir(ctx) {
-    if (this.dir) return path29.resolve(ctx.cwd, this.dir);
-    return ctx.entitiesDir ?? path29.resolve(ctx.cwd, "entities");
+    if (this.dir) return path30.resolve(ctx.cwd, this.dir);
+    return ctx.entitiesDir ?? path30.resolve(ctx.cwd, "entities");
   }
   async runAnalysis(ctx, kind) {
     const entitiesDir = this.resolveEntitiesDir(ctx);
@@ -9974,15 +11272,15 @@ var ProjectGraphCommand = class extends Command7 {
       json: this.json,
       skipDetection: true
     });
-    const entitiesDir = this.dir ? path29.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path29.resolve(ctx.cwd, "entities");
+    const entitiesDir = this.dir ? path30.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path30.resolve(ctx.cwd, "entities");
     if (!fs19.existsSync(entitiesDir)) {
       printError(`Entity directory not found: ${entitiesDir}`);
       return 1;
     }
     const relCandidates = [
-      path29.resolve(path29.dirname(entitiesDir), "relationships"),
-      path29.resolve(entitiesDir, "relationships"),
-      path29.resolve(ctx.cwd, "relationships")
+      path30.resolve(path30.dirname(entitiesDir), "relationships"),
+      path30.resolve(entitiesDir, "relationships"),
+      path30.resolve(ctx.cwd, "relationships")
     ];
     const relationshipsDir = relCandidates.find((d) => fs19.existsSync(d));
     const result = await analyzeDomain(entitiesDir, relationshipsDir);
@@ -9998,20 +11296,20 @@ var ProjectGraphCommand = class extends Command7 {
       return 0;
     }
     if (this.output) {
-      const outPath = path29.resolve(ctx.cwd, this.output);
+      const outPath = path30.resolve(ctx.cwd, this.output);
       fs19.writeFileSync(outPath, JSON.stringify(serialized, null, 2));
       printSuccess(`Graph written to ${outPath}`);
       printInfo(`${result.entities.length} entities, ${result.relationshipDefinitions.length} relationships, ${result.graph.edges.length} edges`);
       return 0;
     }
     const os = await import("os");
-    const tmpDir = fs19.mkdtempSync(path29.join(os.default.tmpdir(), "codegen-graph-"));
-    const graphPath = path29.join(tmpDir, "graph.json");
+    const tmpDir = fs19.mkdtempSync(path30.join(os.default.tmpdir(), "codegen-graph-"));
+    const graphPath = path30.join(tmpDir, "graph.json");
     fs19.writeFileSync(graphPath, JSON.stringify(serialized, null, 2));
-    const viewerDir = path29.resolve(import.meta.dirname, "..", "..", "..", "tools", "schema-graph-viewer");
-    const viewerDist = path29.join(viewerDir, "dist", "index.html");
+    const viewerDir = path30.resolve(import.meta.dirname, "..", "..", "..", "tools", "schema-graph-viewer");
+    const viewerDist = path30.join(viewerDir, "dist", "index.html");
     if (fs19.existsSync(viewerDist)) {
-      fs19.copyFileSync(graphPath, path29.join(viewerDir, "dist", "graph.json"));
+      fs19.copyFileSync(graphPath, path30.join(viewerDir, "dist", "graph.json"));
       printSuccess("Graph exported");
       printInfo(`${result.entities.length} entities, ${result.relationshipDefinitions.length} relationships, ${result.graph.edges.length} edges`);
       printInfo(`Graph JSON: ${graphPath}`);
@@ -10043,7 +11341,7 @@ var project_default = projectNoun;
 
 // src/cli/commands/dev.ts
 import fs20 from "fs";
-import path30 from "path";
+import path31 from "path";
 import { execSync as execSync3, spawn, spawnSync } from "child_process";
 import { Command as Command8, Option as Option8 } from "clipanion";
 var DEFAULT_APP_PORT = 3e3;
@@ -10076,14 +11374,14 @@ function getRedisPort(_ctx) {
   return Number(process.env.DEV_REDIS_PORT ?? DEFAULT_REDIS_PORT);
 }
 function composeFilePath(cwd) {
-  const devPath = path30.join(cwd, COMPOSE_FILE);
+  const devPath = path31.join(cwd, COMPOSE_FILE);
   if (fs20.existsSync(devPath)) return devPath;
-  const rootPath = path30.join(cwd, "docker-compose.yml");
+  const rootPath = path31.join(cwd, "docker-compose.yml");
   if (fs20.existsSync(rootPath)) return rootPath;
   return devPath;
 }
 function pidFilePath(cwd) {
-  return path30.join(cwd, PID_FILE);
+  return path31.join(cwd, PID_FILE);
 }
 function readAppPid(cwd) {
   const p = pidFilePath(cwd);
@@ -10144,7 +11442,7 @@ function checkApp(cwd, port) {
 function listEntityNames(ctx) {
   if (!ctx.entitiesDir || !fs20.existsSync(ctx.entitiesDir)) return [];
   return findYamlFiles(ctx.entitiesDir).map(
-    (f) => path30.basename(f).replace(/\.ya?ml$/, "")
+    (f) => path31.basename(f).replace(/\.ya?ml$/, "")
   );
 }
 function formatServiceLine(svc) {
@@ -10154,7 +11452,7 @@ function formatServiceLine(svc) {
   return `${icon} ${svc.name.padEnd(12)}  ${theme.muted(`${svc.host}:${svc.port}`)}    ${status}${pidStr}`;
 }
 function ensureComposeFile(cwd, pgPort, redisPort) {
-  const composePath = path30.join(cwd, COMPOSE_FILE);
+  const composePath = path31.join(cwd, COMPOSE_FILE);
   if (fs20.existsSync(composePath)) return composePath;
   const content = `# Auto-generated by codegen dev
 # Ports offset from defaults to avoid conflicts with other local services.
@@ -10239,7 +11537,7 @@ var DevUpCommand = class extends Command8 {
     if (!pgReady) printWarning("postgres did not become healthy in time");
     if (!redisReady) printWarning("redis did not become healthy in time");
     const drizzleConfig = ["drizzle.config.ts", "drizzle.config.js"].find(
-      (f) => fs20.existsSync(path30.join(ctx.cwd, f))
+      (f) => fs20.existsSync(path31.join(ctx.cwd, f))
     );
     if (drizzleConfig) {
       if (!isJsonMode()) printInfo("pushing database schema...");
@@ -10259,7 +11557,7 @@ var DevUpCommand = class extends Command8 {
         if (!isJsonMode()) printInfo("starting NestJS app...");
         const dbUrl = `postgres://postgres:postgres@localhost:${pgPort}/codegen_dev`;
         const redisUrl = `redis://localhost:${redisPort}`;
-        const logFile = path30.join(ctx.cwd, ".dev-app.log");
+        const logFile = path31.join(ctx.cwd, ".dev-app.log");
         const logFd = fs20.openSync(logFile, "a");
         const child = spawn("bun", ["src/main.ts"], {
           cwd: ctx.cwd,
@@ -10417,7 +11715,7 @@ var DevLogsCommand = class extends Command8 {
       }
       return 0;
     }
-    const logFile = path30.join(ctx.cwd, ".dev-app.log");
+    const logFile = path31.join(ctx.cwd, ".dev-app.log");
     if (!fs20.existsSync(logFile)) {
       printInfo("no app logs found \u2014 is the app running?");
       return 0;
@@ -10461,7 +11759,7 @@ var DevRestartCommand = class extends Command8 {
     spawnSync("sleep", ["1"]);
     const dbUrl = `postgres://postgres:postgres@localhost:${pgPort}/codegen_dev`;
     const redisUrl = `redis://localhost:${redisPort}`;
-    const logFile = path30.join(ctx.cwd, ".dev-app.log");
+    const logFile = path31.join(ctx.cwd, ".dev-app.log");
     const logFd = fs20.openSync(logFile, "a");
     const child = spawn("bun", ["src/main.ts"], {
       cwd: ctx.cwd,
@@ -10591,7 +11889,7 @@ var dev_default = devNoun;
 
 // src/cli/commands/relationship.ts
 import fs21 from "fs";
-import path31 from "path";
+import path32 from "path";
 import { Command as Command9, Option as Option9 } from "clipanion";
 function listRelationshipYamls2(dir) {
   if (!fs21.existsSync(dir)) return [];
@@ -10618,7 +11916,7 @@ function padRight2(s, n) {
   return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 async function summary6(ctx) {
-  const relDir = path31.resolve(ctx.cwd, "relationships");
+  const relDir = path32.resolve(ctx.cwd, "relationships");
   const files = listRelationshipYamls2(relDir);
   if (files.length === 0) {
     return {
@@ -10688,14 +11986,14 @@ var RelationshipNewCommand = class extends Command9 {
     }
     let targets = [];
     if (this.all) {
-      const dir = path31.resolve(ctx.cwd, "relationships");
+      const dir = path32.resolve(ctx.cwd, "relationships");
       targets = listRelationshipYamls2(dir);
       if (targets.length === 0) {
         printError(`No relationship YAML files found in ${dir}`);
         return 1;
       }
     } else if (this.yaml) {
-      targets = [path31.resolve(ctx.cwd, this.yaml)];
+      targets = [path32.resolve(ctx.cwd, this.yaml)];
     } else {
       printError("Missing YAML path. Pass a file or --all.");
       return 2;
@@ -10712,7 +12010,7 @@ var RelationshipNewCommand = class extends Command9 {
     }
     if (invalid.length > 0) {
       for (const i of invalid) {
-        printError(`${path31.basename(i.file)} \u2014 ${i.message}`);
+        printError(`${path32.basename(i.file)} \u2014 ${i.message}`);
       }
       if (!isJsonMode()) return 1;
     }
@@ -10743,7 +12041,7 @@ var RelationshipNewCommand = class extends Command9 {
     }
     const succeeded = [];
     const failed = [
-      ...invalid.map((i) => ({ name: path31.basename(i.file), file: i.file, message: i.message }))
+      ...invalid.map((i) => ({ name: path32.basename(i.file), file: i.file, message: i.message }))
     ];
     for (const v of validated) {
       if (!isJsonMode()) {
@@ -10762,8 +12060,8 @@ var RelationshipNewCommand = class extends Command9 {
         if (!isJsonMode()) printError(`${v.name} \u2014 ${res.stderr ?? "failed"}`);
       }
     }
-    const entitiesDir = ctx.entitiesDir ?? path31.resolve(ctx.cwd, "entities");
-    const relationshipsDir = path31.resolve(ctx.cwd, "relationships");
+    const entitiesDir = ctx.entitiesDir ?? path32.resolve(ctx.cwd, "entities");
+    const relationshipsDir = path32.resolve(ctx.cwd, "relationships");
     const generatedDir = resolveGeneratedDir(ctx);
     const architecture = resolveArchitecture(ctx);
     let barrelResult = null;
@@ -10808,7 +12106,7 @@ var RelationshipNewCommand = class extends Command9 {
       }
       if (barrelResult) {
         printInfo(
-          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path31.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path31.relative(ctx.cwd, barrelResult.schemaBarrel)}`
+          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path32.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path32.relative(ctx.cwd, barrelResult.schemaBarrel)}`
         );
       }
     }
@@ -10831,7 +12129,7 @@ var RelationshipListCommand = class extends Command9 {
       json: this.json,
       skipDetection: true
     });
-    const relDir = path31.resolve(ctx.cwd, "relationships");
+    const relDir = path32.resolve(ctx.cwd, "relationships");
     const files = listRelationshipYamls2(relDir);
     if (files.length === 0) {
       printInfo("No relationship definitions found.");
@@ -10871,7 +12169,7 @@ var relationshipNoun = {
 var relationship_default = relationshipNoun;
 
 // src/cli/commands/junction.ts
-import path32 from "path";
+import path33 from "path";
 import { Command as Command10, Option as Option10 } from "clipanion";
 function summarizeJunctionFile(filePath) {
   const result = loadJunctionFromYaml(filePath);
@@ -10894,7 +12192,7 @@ function padRight3(s, n) {
   return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 async function summary7(ctx) {
-  const junctionDir = path32.resolve(ctx.cwd, "junctions");
+  const junctionDir = path33.resolve(ctx.cwd, "junctions");
   const files = listJunctionYamls(junctionDir);
   if (files.length === 0) {
     return {
@@ -10964,14 +12262,14 @@ var JunctionNewCommand = class extends Command10 {
     }
     let targets = [];
     if (this.all) {
-      const dir = path32.resolve(ctx.cwd, "junctions");
+      const dir = path33.resolve(ctx.cwd, "junctions");
       targets = listJunctionYamls(dir);
       if (targets.length === 0) {
         printError(`No junction YAML files found in ${dir}`);
         return 1;
       }
     } else if (this.yaml) {
-      targets = [path32.resolve(ctx.cwd, this.yaml)];
+      targets = [path33.resolve(ctx.cwd, this.yaml)];
     } else {
       printError("Missing YAML path. Pass a file or --all.");
       return 2;
@@ -10990,7 +12288,7 @@ var JunctionNewCommand = class extends Command10 {
     }
     if (invalid.length > 0) {
       for (const i of invalid) {
-        printError(`${path32.basename(i.file)} \u2014 ${i.message}`);
+        printError(`${path33.basename(i.file)} \u2014 ${i.message}`);
       }
       if (!isJsonMode()) return 1;
     }
@@ -11021,7 +12319,7 @@ var JunctionNewCommand = class extends Command10 {
     }
     const succeeded = [];
     const failed = [
-      ...invalid.map((i) => ({ name: path32.basename(i.file), file: i.file, message: i.message }))
+      ...invalid.map((i) => ({ name: path33.basename(i.file), file: i.file, message: i.message }))
     ];
     for (const v of validated) {
       if (!isJsonMode()) {
@@ -11040,9 +12338,9 @@ var JunctionNewCommand = class extends Command10 {
         if (!isJsonMode()) printError(`${v.name} \u2014 ${res.stderr ?? "failed"}`);
       }
     }
-    const entitiesDir = ctx.entitiesDir ?? path32.resolve(ctx.cwd, "entities");
-    const relationshipsDir = path32.resolve(ctx.cwd, "relationships");
-    const junctionsDir = path32.resolve(ctx.cwd, "junctions");
+    const entitiesDir = ctx.entitiesDir ?? path33.resolve(ctx.cwd, "entities");
+    const relationshipsDir = path33.resolve(ctx.cwd, "relationships");
+    const junctionsDir = path33.resolve(ctx.cwd, "junctions");
     const generatedDir = resolveGeneratedDir(ctx);
     const architecture = resolveArchitecture(ctx);
     let barrelResult = null;
@@ -11088,7 +12386,7 @@ var JunctionNewCommand = class extends Command10 {
       }
       if (barrelResult) {
         printInfo(
-          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path32.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path32.relative(ctx.cwd, barrelResult.schemaBarrel)}`
+          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path33.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path33.relative(ctx.cwd, barrelResult.schemaBarrel)}`
         );
       }
     }
@@ -11111,7 +12409,7 @@ var JunctionListCommand = class extends Command10 {
       json: this.json,
       skipDetection: true
     });
-    const junctionDir = path32.resolve(ctx.cwd, "junctions");
+    const junctionDir = path33.resolve(ctx.cwd, "junctions");
     const files = listJunctionYamls(junctionDir);
     if (files.length === 0) {
       printInfo("No junction definitions found.");
@@ -11152,7 +12450,7 @@ var junction_default = junctionNoun;
 
 // src/cli/commands/events.ts
 import fs22 from "fs";
-import path33 from "path";
+import path34 from "path";
 import ts2 from "typescript";
 import { Command as Command11, Option as Option11 } from "clipanion";
 function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
@@ -11288,7 +12586,7 @@ function suggestEventTypes(target, known, limit = 3) {
   return known.map((t) => ({ t, d: levenshtein(target, t) })).sort((a, b) => a.d - b.d).slice(0, limit).map((x) => x.t);
 }
 function renderConsumerReport(result, cwd) {
-  const rel2 = (p) => path33.relative(cwd, p) || p;
+  const rel2 = (p) => path34.relative(cwd, p) || p;
   const lines = [];
   const total = result.tier3.length + result.tier2.length + result.tier1.length;
   lines.push(`Event: ${result.eventType}`);
@@ -11324,7 +12622,7 @@ function renderConsumerReport(result, cwd) {
   return lines;
 }
 function runConsumersScan(opts) {
-  const scanRoot = opts.scanRoot ?? path33.join(opts.cwd, "src");
+  const scanRoot = opts.scanRoot ?? path34.join(opts.cwd, "src");
   const handlersDir = opts.handlersDir ?? scanRoot;
   const allTriggers = scanHandlerFiles(handlersDir);
   const tier3 = allTriggers.filter((t) => t.event === opts.eventType).map((t) => ({
@@ -11334,7 +12632,7 @@ function runConsumersScan(opts) {
     sourceLine: t.sourceLine
   }));
   const tier21 = fs22.existsSync(scanRoot) ? scanDirectoryForConsumers(scanRoot, opts.eventType) : { tier2: [], tier1: [], hasEventFlowImport: false };
-  const eventsGeneratedDir = opts.eventsGeneratedDir ?? path33.join(
+  const eventsGeneratedDir = opts.eventsGeneratedDir ?? path34.join(
     resolveSubsystemsRootFromContext(opts.cwd, opts.config),
     "events",
     "generated"
@@ -11355,11 +12653,11 @@ function runConsumersScan(opts) {
 function resolveSubsystemsRootFromContext(cwd, config) {
   const configured = config?.paths?.subsystems;
   if (typeof configured === "string" && configured.length > 0) {
-    return path33.resolve(cwd, configured);
+    return path34.resolve(cwd, configured);
   }
   const backendSrc = config?.paths?.backend_src;
   const base = typeof backendSrc === "string" && backendSrc.length > 0 ? backendSrc : "src";
-  return path33.resolve(cwd, base, "shared", "subsystems");
+  return path34.resolve(cwd, base, "shared", "subsystems");
 }
 var EventsConsumersCommand = class extends Command11 {
   static paths = [["events", "consumers"]];
@@ -11448,7 +12746,7 @@ var eventsNoun = {
 var events_default = eventsNoun;
 
 // src/cli/commands/orchestration.ts
-import path34 from "path";
+import path35 from "path";
 import { Command as Command12, Option as Option12 } from "clipanion";
 var DEFAULT_PATTERN_GLOBS = ["src/patterns/*.pattern.ts"];
 function resolvePatternGlobs(ctx) {
@@ -11462,10 +12760,10 @@ function resolveOrchestrationOutputRoot(ctx) {
   const paths = ctx.config?.paths;
   const explicit = paths?.orchestration_src;
   if (typeof explicit === "string" && explicit.length > 0) {
-    return path34.resolve(ctx.cwd, explicit);
+    return path35.resolve(ctx.cwd, explicit);
   }
   const backendSrc = typeof paths?.backend_src === "string" && paths.backend_src.length > 0 ? paths.backend_src : "app/backend/src";
-  return path34.resolve(ctx.cwd, backendSrc, "orchestration");
+  return path35.resolve(ctx.cwd, backendSrc, "orchestration");
 }
 async function reloadRegistry(ctx) {
   _resetRegistryForTests({ includeLibrary: false });
@@ -11554,12 +12852,12 @@ var OrchestrationGenCommand = class extends Command12 {
         );
         for (const f of result.files) {
           console.log(
-            `  ${theme.muted(icons.arrow)} ${path34.relative(ctx.cwd, f.outputPath)}`
+            `  ${theme.muted(icons.arrow)} ${path35.relative(ctx.cwd, f.outputPath)}`
           );
         }
       } else {
         printSuccess(
-          `Emitted ${result.files.length} file(s) across ${targets.length} pattern(s) \u2192 ${path34.relative(ctx.cwd, outputRoot)}`
+          `Emitted ${result.files.length} file(s) across ${targets.length} pattern(s) \u2192 ${path35.relative(ctx.cwd, outputRoot)}`
         );
       }
       return 0;
@@ -11725,7 +13023,7 @@ var update_default = UpdateShortcut;
 // src/cli/index.ts
 function readVersion() {
   try {
-    const pkgPath = join10(import.meta.dirname, "..", "..", "package.json");
+    const pkgPath = join18(import.meta.dirname, "..", "..", "package.json");
     const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {