create-projx 1.6.5 → 1.7.1

package/dist/index.js

@@ -9,12 +9,14 @@ import {
   matchesSkip,
   saveBaselineRef,
   writeTemplateToDir
-} from "./chunk-XQ7FE4U3.js";
+} from "./chunk-N4WD4VN3.js";
 import {
   COMPONENTS,
   COMPONENT_MARKER,
   DEFAULT_ROOT_SKIP_PATTERNS,
   EXCLUDE,
+  KNOWN_FEATURES,
+  ORM_PROVIDERS,
   PACKAGE_MANAGERS,
   cleanupRepo,
   detectPackageManager,
@@ -29,22 +31,354 @@ import {
   readComponentMarker,
   readFileOrNull,
   readProjxConfig,
+  render,
   toKebab,
   toSnake,
-  toTitle,
   writeComponentMarker,
   writeProjxConfig
-} from "./chunk-6YRBHJ2V.js";
+} from "./chunk-OLPF7FAN.js";
 
 // src/index.ts
 import { existsSync as existsSync11 } from "fs";
 import { resolve } from "path";
 
+// src/features.ts
+import { existsSync } from "fs";
+import { cp, mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { dirname, join, relative } from "path";
+function parseFeatureFlag(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return [];
+  const pieces = trimmed.split(",");
+  const out = [];
+  for (const raw of pieces) {
+    const piece = raw.trim();
+    if (!piece) {
+      throw new Error(
+        `Invalid feature flag: empty target in "${input}". Use "component[:instance],..." form.`
+      );
+    }
+    const parts = piece.split(":").map((p10) => p10.trim());
+    if (parts.length > 2 || parts.some((p10) => !p10)) {
+      throw new Error(
+        `Invalid feature flag target "${piece}". Expected "component" or "component:instance".`
+      );
+    }
+    const [component, instance] = parts;
+    if (!COMPONENTS.includes(component)) {
+      throw new Error(
+        `Unknown component "${component}". Valid: ${COMPONENTS.join(", ")}.`
+      );
+    }
+    out.push(
+      instance ? { component, instance } : { component }
+    );
+  }
+  return out;
+}
+function validateFeatureTargets(targets, instances, _components, supports) {
+  const resolved = [];
+  for (const t of targets) {
+    if (supports && !supports.includes(t.component)) {
+      throw new Error(
+        `Feature does not support ${t.component}. Supported: ${supports.join(", ")}.`
+      );
+    }
+    const candidates = instances.filter((i) => i.type === t.component).sort((a, b) => a.path.localeCompare(b.path));
+    if (candidates.length === 0) {
+      throw new Error(
+        `No ${t.component} instance found. Add it to --components first.`
+      );
+    }
+    if (t.instance) {
+      const match = candidates.find((c) => c.path === t.instance);
+      if (!match) {
+        const known = candidates.map((c) => c.path).join(", ");
+        throw new Error(
+          `No ${t.component} instance named "${t.instance}". Known: ${known}.`
+        );
+      }
+      resolved.push({
+        component: t.component,
+        instance: t.instance,
+        path: match.path
+      });
+    } else {
+      resolved.push({
+        component: t.component,
+        instance: candidates[0].path,
+        path: candidates[0].path
+      });
+    }
+  }
+  return resolved;
+}
+async function applyFeatures(opts) {
+  const featureRoot = join(opts.repoDir, "features");
+  for (const [name, raw] of Object.entries(opts.features)) {
+    if (!raw) continue;
+    const targets = parseFeatureFlag(raw);
+    const featureDir = join(featureRoot, name);
+    if (!existsSync(featureDir)) {
+      throw new Error(
+        `Feature "${name}" not found at ${featureDir}. Pin or update the repo to a version that ships this feature.`
+      );
+    }
+    const manifest = JSON.parse(
+      await readFile(join(featureDir, "feature.json"), "utf-8")
+    );
+    if (manifest.requiresOrm && manifest.requiresOrm.length > 0) {
+      const orm = opts.vars.orm ?? "prisma";
+      if (!manifest.requiresOrm.includes(orm)) {
+        throw new Error(
+          `Feature "${name}" requires --orm ${manifest.requiresOrm.join(" or ")} (got "${orm}").`
+        );
+      }
+    }
+    const resolved = validateFeatureTargets(
+      targets,
+      opts.instances,
+      opts.components,
+      manifest.supports
+    );
+    await applyFeature({
+      feature: name,
+      featureRoot,
+      targets: resolved,
+      dest: opts.dest,
+      vars: opts.vars
+    });
+  }
+}
+async function applyFeature(opts) {
+  const featureDir = join(opts.featureRoot, opts.feature);
+  if (!existsSync(featureDir)) {
+    throw new Error(
+      `Feature "${opts.feature}" not found at ${featureDir}. Check feature name and repo version.`
+    );
+  }
+  const manifest = await readManifest(featureDir, opts.feature);
+  for (const target of opts.targets) {
+    if (!manifest.supports.includes(target.component)) {
+      throw new Error(
+        `Feature "${opts.feature}" does not support ${target.component}. Supported: ${manifest.supports.join(", ")}.`
+      );
+    }
+    await applyTarget({
+      featureDir,
+      featureName: opts.feature,
+      manifest,
+      target,
+      dest: opts.dest,
+      vars: { ...opts.vars, inst: target }
+    });
+  }
+}
+async function readManifest(featureDir, feature) {
+  const path = join(featureDir, "feature.json");
+  if (!existsSync(path)) {
+    throw new Error(`Feature "${feature}" missing feature.json at ${path}.`);
+  }
+  const raw = await readFile(path, "utf-8");
+  const manifest = JSON.parse(raw);
+  if (!manifest.name || !Array.isArray(manifest.supports)) {
+    throw new Error(`Feature "${feature}" manifest is malformed.`);
+  }
+  return manifest;
+}
+async function applyTarget(args2) {
+  const stackDir = join(args2.featureDir, args2.target.component);
+  if (!existsSync(stackDir)) return;
+  const targetPath = join(args2.dest, args2.target.path);
+  if (!existsSync(targetPath)) {
+    throw new Error(
+      `Target instance path ${args2.target.path} not found in ${args2.dest}.`
+    );
+  }
+  const orm = typeof args2.vars.orm === "string" ? args2.vars.orm : void 0;
+  const ormDir = orm ? join(stackDir, orm) : void 0;
+  const hasOrmDir = ormDir !== void 0 && existsSync(ormDir);
+  const ormPatchNames = /* @__PURE__ */ new Set();
+  if (hasOrmDir) {
+    const ormPatchesDir = join(ormDir, "patches");
+    if (existsSync(ormPatchesDir)) {
+      for (const f of await readdir(ormPatchesDir)) {
+        if (f.endsWith(".json")) ormPatchNames.add(f);
+      }
+    }
+  }
+  for (const sub of ["files", join("common", "files")]) {
+    const filesDir = join(stackDir, sub);
+    if (existsSync(filesDir)) {
+      await renderFilesInto(filesDir, targetPath, args2.vars);
+    }
+  }
+  for (const sub of ["patches", join("common", "patches")]) {
+    const patchesDir = join(stackDir, sub);
+    if (existsSync(patchesDir)) {
+      await applyPatches(
+        patchesDir,
+        targetPath,
+        args2.featureName,
+        ormPatchNames,
+        hasOrmDir
+      );
+    }
+  }
+  if (hasOrmDir) {
+    const ormFilesDir = join(ormDir, "files");
+    if (existsSync(ormFilesDir)) {
+      await renderFilesInto(ormFilesDir, targetPath, args2.vars);
+    }
+    const ormPatchesDir = join(ormDir, "patches");
+    if (existsSync(ormPatchesDir)) {
+      await applyPatches(ormPatchesDir, targetPath, args2.featureName);
+    }
+  }
+  const envKeys = args2.manifest.env?.[args2.target.component] ?? [];
+  if (envKeys.length > 0) {
+    await appendEnvExample(targetPath, args2.featureName, envKeys);
+  }
+  await recordFeatureInMarker(targetPath, args2.featureName);
+}
+async function renderFilesInto(filesDir, targetPath, vars) {
+  const entries = await collectFiles(filesDir);
+  for (const rel of entries) {
+    const src = join(filesDir, rel);
+    const isEjs = rel.endsWith(".ejs");
+    const outRel = isEjs ? rel.slice(0, -4) : rel;
+    const dst = join(targetPath, outRel);
+    await mkdir(dirname(dst), { recursive: true });
+    if (isEjs || /\.(ts|tsx|js|jsx|py|dart|md|json|yml|yaml|html)$/.test(rel)) {
+      const raw = await readFile(src, "utf-8");
+      await writeFile(dst, render(raw, vars));
+    } else {
+      await cp(src, dst);
+    }
+  }
+}
+async function collectFiles(root) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) await walk(full);
+      else out.push(relative(root, full));
+    }
+  }
+  await walk(root);
+  return out.sort();
+}
+async function applyPatches(patchesDir, targetPath, featureName, skipNames = /* @__PURE__ */ new Set(), tolerateMissingTarget = false) {
+  const files = (await readdir(patchesDir)).filter((f) => f.endsWith(".json")).filter((f) => !skipNames.has(f)).sort();
+  for (const file of files) {
+    const raw = await readFile(join(patchesDir, file), "utf-8");
+    const patch = JSON.parse(raw);
+    if (patch.type === "package-json") {
+      await applyPackageJsonPatch(targetPath, patch);
+    } else if (patch.type === "text") {
+      await applyTextPatch(
+        targetPath,
+        patch,
+        featureName,
+        tolerateMissingTarget
+      );
+    } else {
+      throw new Error(
+        `Unknown patch type in ${file}: ${patch.type}.`
+      );
+    }
+  }
+}
+async function applyPackageJsonPatch(targetPath, patch) {
+  const pkgPath = join(targetPath, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error(`package-json patch failed: ${pkgPath} not found.`);
+  }
+  const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+  const merge = patch.merge;
+  for (const key of ["dependencies", "devDependencies", "scripts"]) {
+    const incoming = merge[key];
+    if (!incoming) continue;
+    pkg[key] = { ...pkg[key] ?? {}, ...incoming };
+  }
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+async function applyTextPatch(targetPath, patch, featureName, tolerateMissingTarget = false) {
+  const filePath = join(targetPath, patch.file);
+  if (!existsSync(filePath)) {
+    if (tolerateMissingTarget) return;
+    throw new Error(
+      `text patch failed: ${patch.file} not found in ${targetPath}.`
+    );
+  }
+  const content = await readFile(filePath, "utf-8");
+  const idx = content.indexOf(patch.anchor);
+  if (idx === -1) {
+    throw new Error(
+      `text patch anchor "${patch.anchor}" not found in ${patch.file}.`
+    );
+  }
+  const lineStart = content.lastIndexOf("\n", idx) + 1;
+  const indent = content.slice(lineStart, idx).match(/^\s*/)?.[0] ?? "";
+  const sentinel = sentinelFor(featureName, patch.anchor, patch.insert, indent);
+  if (content.includes(sentinel)) return;
+  const insertWithSentinel = patch.insert + sentinel;
+  let next;
+  if (patch.position === "before") {
+    next = content.slice(0, idx) + insertWithSentinel + content.slice(idx);
+  } else {
+    const end = idx + patch.anchor.length;
+    const after = content.slice(end);
+    const newline = after.startsWith("\n") ? "\n" : "\n";
+    next = content.slice(0, end) + newline + insertWithSentinel + (after.startsWith("\n") ? after.slice(1) : after);
+  }
+  await writeFile(filePath, next);
+}
+function sentinelFor(feature, anchor, insert, indent = "") {
+  const hash = simpleHash(anchor + "|" + insert);
+  const isHash = anchor.includes("#");
+  const open = isHash ? "# " : "// ";
+  return `${indent}${open}projx-feature: ${feature} ${hash}
+`;
+}
+function simpleHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) h = h * 31 + s.charCodeAt(i) | 0;
+  return Math.abs(h).toString(36);
+}
+async function appendEnvExample(targetPath, featureName, keys) {
+  const envPath = join(targetPath, ".env.example");
+  let content = existsSync(envPath) ? await readFile(envPath, "utf-8") : "";
+  const header = `# Added by feature: ${featureName}`;
+  if (content.includes(header)) return;
+  if (content && !content.endsWith("\n")) content += "\n";
+  content += `
+${header}
+`;
+  for (const key of keys) content += `# ${key}=
+`;
+  await writeFile(envPath, content);
+}
+async function recordFeatureInMarker(targetPath, featureName) {
+  const markerPath = join(targetPath, ".projx-component");
+  if (!existsSync(markerPath)) return;
+  const raw = await readFile(markerPath, "utf-8");
+  const marker = JSON.parse(raw);
+  marker.features = marker.features ?? [];
+  if (!marker.features.includes(featureName)) {
+    marker.features.push(featureName);
+    await writeFile(markerPath, JSON.stringify(marker, null, 2) + "\n");
+  }
+}
+
 // src/prompts.ts
 import * as p from "@clack/prompts";
 var LABELS = {
   fastapi: { label: "FastAPI", hint: "Python \u2014 SQLAlchemy, Alembic, uvicorn" },
   fastify: { label: "Fastify", hint: "Node.js \u2014 Prisma, TypeBox, TypeScript" },
+  express: { label: "Express", hint: "Node.js \u2014 Express 5, TypeScript" },
   frontend: { label: "Frontend", hint: "React 19 + Vite + React Router" },
   mobile: { label: "Mobile", hint: "Flutter + Riverpod + GoRouter" },
   e2e: { label: "E2E Tests", hint: "Playwright" },
@@ -78,9 +412,25 @@ async function runPrompts(nameArg) {
     p.log.warn("No components selected. Creating an empty project.");
   }
   const hasJs = components.some(
-    (c) => ["fastify", "frontend", "e2e"].includes(c)
+    (c) => ["fastify", "express", "frontend", "e2e"].includes(c)
+  );
+  const hasNodeBackend = components.some(
+    (c) => ["fastify", "express"].includes(c)
   );
+  let orm = "prisma";
   let packageManager = "npm";
+  if (hasNodeBackend) {
+    const choice = await p.select({
+      message: "Node backend ORM",
+      options: ORM_PROVIDERS.map((provider) => ({
+        value: provider,
+        label: provider === "prisma" ? "Prisma" : "Drizzle"
+      })),
+      initialValue: "prisma"
+    });
+    if (p.isCancel(choice)) process.exit(0);
+    orm = choice;
+  }
   if (hasJs) {
     const pm = await p.select({
       message: "Package manager",
@@ -90,13 +440,13 @@ async function runPrompts(nameArg) {
     if (p.isCancel(pm)) process.exit(0);
     packageManager = pm;
   }
-  return { name, components, git: true, install: true, packageManager };
+  return { name, components, git: true, install: true, packageManager, orm };
 }
 
 // src/scaffold.ts
-import { copyFileSync, existsSync } from "fs";
-import { mkdir, readFile } from "fs/promises";
-import { join } from "path";
+import { copyFileSync, existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
 import * as p2 from "@clack/prompts";
 async function scaffold(opts, dest, localRepo) {
   const name = toKebab(opts.name);
@@ -108,10 +458,11 @@ async function scaffold(opts, dest, localRepo) {
     projectName: name,
     components: opts.components,
     paths,
-    pm: pmCommands(pm)
+    pm: pmCommands(pm),
+    orm: opts.orm ?? "prisma"
   };
   const isLocal = !!localRepo;
-  await mkdir(dest, { recursive: true });
+  await mkdir2(dest, { recursive: true });
   const dlSpinner = p2.spinner();
   dlSpinner.start(
     isLocal ? "Using local templates" : "Downloading latest templates"
@@ -124,15 +475,15 @@ async function scaffold(opts, dest, localRepo) {
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
     const pkg = JSON.parse(
-      await readFile(join(repoDir, "cli/package.json"), "utf-8")
+      await readFile2(join2(repoDir, "cli/package.json"), "utf-8")
     );
     const version = pkg.version;
     p2.log.info(`Scaffolding project in ${dest}`);
     if (opts.git) {
       exec("git init", dest);
     }
-    const spinner7 = p2.spinner();
-    spinner7.start("Scaffolding project");
+    const spinner6 = p2.spinner();
+    spinner6.start("Scaffolding project");
     await applyTemplate(
       dest,
       repoDir,
@@ -144,7 +495,20 @@ async function scaffold(opts, dest, localRepo) {
       void 0,
       true
     );
-    spinner7.stop("Scaffold complete.");
+    spinner6.stop("Scaffold complete.");
+    if (opts.features && Object.keys(opts.features).length > 0) {
+      const featSpinner = p2.spinner();
+      featSpinner.start("Applying features");
+      await applyFeatures({
+        features: opts.features,
+        repoDir,
+        components: opts.components,
+        instances: opts.components.map((type) => ({ type, path: type })),
+        dest,
+        vars
+      });
+      featSpinner.stop("Features applied.");
+    }
     if (opts.install) {
       await installDeps(dest, opts.components, pm);
     }
@@ -174,34 +538,45 @@ async function installDeps(dest, components, pm) {
   const cmds = pmCommands(pm);
   const pmBin = pm === "bun" ? "bun" : pm;
   for (const component of components) {
-    const spinner7 = p2.spinner();
+    const spinner6 = p2.spinner();
     try {
       switch (component) {
         case "fastapi":
           if (hasCommand("uv")) {
-            spinner7.start("Installing FastAPI dependencies (uv sync)");
-            exec("uv sync --all-extras", join(dest, "fastapi"));
-            spinner7.stop("FastAPI dependencies installed.");
+            spinner6.start("Installing FastAPI dependencies (uv sync)");
+            exec("uv sync --all-extras", join2(dest, "fastapi"));
+            spinner6.stop("FastAPI dependencies installed.");
           } else {
             p2.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
           if (hasCommand(pmBin)) {
-            spinner7.start(`Installing Fastify dependencies (${cmds.install})`);
-            exec(cmds.install, join(dest, "fastify"));
-            spinner7.stop("Fastify dependencies installed.");
+            spinner6.start(`Installing Fastify dependencies (${cmds.install})`);
+            exec(cmds.install, join2(dest, "fastify"));
+            spinner6.stop("Fastify dependencies installed.");
           } else {
             p2.log.warn(
               `${pm} not found \u2014 run 'cd fastify && ${cmds.install}' manually.`
             );
           }
           break;
+        case "express":
+          if (hasCommand(pmBin)) {
+            spinner6.start(`Installing Express dependencies (${cmds.install})`);
+            exec(cmds.install, join2(dest, "express"));
+            spinner6.stop("Express dependencies installed.");
+          } else {
+            p2.log.warn(
+              `${pm} not found \u2014 run 'cd express && ${cmds.install}' manually.`
+            );
+          }
+          break;
         case "frontend":
           if (hasCommand(pmBin)) {
-            spinner7.start(`Installing Frontend dependencies (${cmds.install})`);
-            exec(cmds.install, join(dest, "frontend"));
-            spinner7.stop("Frontend dependencies installed.");
+            spinner6.start(`Installing Frontend dependencies (${cmds.install})`);
+            exec(cmds.install, join2(dest, "frontend"));
+            spinner6.stop("Frontend dependencies installed.");
           } else {
             p2.log.warn(
               `${pm} not found \u2014 run 'cd frontend && ${cmds.install}' manually.`
@@ -210,9 +585,9 @@ async function installDeps(dest, components, pm) {
           break;
         case "e2e":
           if (hasCommand(pmBin)) {
-            spinner7.start(`Installing E2E dependencies (${cmds.install})`);
-            exec(cmds.install, join(dest, "e2e"));
-            spinner7.stop("E2E dependencies installed.");
+            spinner6.start(`Installing E2E dependencies (${cmds.install})`);
+            exec(cmds.install, join2(dest, "e2e"));
+            spinner6.stop("E2E dependencies installed.");
           } else {
             p2.log.warn(
               `${pm} not found \u2014 run 'cd e2e && ${cmds.install}' manually.`
@@ -221,9 +596,9 @@ async function installDeps(dest, components, pm) {
           break;
         case "mobile":
           if (hasCommand("flutter")) {
-            spinner7.start("Installing Flutter dependencies");
-            exec("flutter pub get", join(dest, "mobile"));
-            spinner7.stop("Flutter dependencies installed.");
+            spinner6.start("Installing Flutter dependencies");
+            exec("flutter pub get", join2(dest, "mobile"));
+            spinner6.stop("Flutter dependencies installed.");
           } else {
             p2.log.warn(
               "Flutter not found \u2014 run 'cd mobile && flutter pub get' manually."
@@ -234,15 +609,15 @@ async function installDeps(dest, components, pm) {
           break;
       }
     } catch {
-      spinner7.stop(`Failed to install ${component} dependencies.`);
+      spinner6.stop(`Failed to install ${component} dependencies.`);
     }
   }
 }
 function copyEnvExamples(dest, components) {
   for (const component of components) {
-    const example = join(dest, component, ".env.example");
-    const env = join(dest, component, ".env");
-    if (existsSync(example) && !existsSync(env)) {
+    const example = join2(dest, component, ".env.example");
+    const env = join2(dest, component, ".env");
+    if (existsSync2(example) && !existsSync2(env)) {
       try {
         copyFileSync(example, env);
       } catch {
@@ -252,10 +627,10 @@ function copyEnvExamples(dest, components) {
 }
 
 // src/update.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile2, unlink } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3, unlink } from "fs/promises";
 import { execSync } from "child_process";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import * as p3 from "@clack/prompts";
 async function update(cwd, localRepo) {
   p3.intro("projx update");
@@ -323,7 +698,7 @@ async function update(cwd, localRepo) {
   const componentSkips = {};
   for (const component of components) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join2(cwd, dir));
+    const marker = await readComponentMarker(join3(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       componentSkips[component] = marker.skip;
     }
@@ -340,7 +715,7 @@ async function update(cwd, localRepo) {
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
     const pkg = JSON.parse(
-      await readFile2(join2(repoDir, "cli/package.json"), "utf-8")
+      await readFile3(join3(repoDir, "cli/package.json"), "utf-8")
     );
     const version = pkg.version;
     const name = detectProjectName(cwd, components, componentPaths);
@@ -366,10 +741,11 @@ async function update(cwd, localRepo) {
       paths: componentPaths,
       instances,
       pm: pmCommands(pm),
-      nameOverrides
+      nameOverrides,
+      orm: raw.orm ?? "prisma"
     };
-    const spinner7 = p3.spinner();
-    spinner7.start("Applying template update");
+    const spinner6 = p3.spinner();
+    spinner6.start("Applying template update");
     const rootSkip = Array.isArray(raw.skip) ? raw.skip : [];
     const isLegacyMigration = !raw.defaultsApplied;
     if (isLegacyMigration) {
@@ -389,7 +765,7 @@ async function update(cwd, localRepo) {
       isLegacyMigration,
       extraInstances
     );
-    spinner7.stop("Template applied.");
+    spinner6.stop("Template applied.");
     const pinnedUpdates = await findPinnedFilesWithUpdates(
       cwd,
       repoDir,
@@ -473,22 +849,21 @@ function hasUncommittedChanges(cwd) {
   }
 }
 async function findPinnedFilesWithUpdates(cwd, repoDir, components, componentPaths, vars, version, componentSkips, rootSkip) {
-  const { mkdir: mkdir5, rm: rm2, readFile: readFile7 } = await import("fs/promises");
+  const { mkdtemp: mkdtemp2, rm: rm2, readFile: readFile8 } = await import("fs/promises");
   const { tmpdir: tmpdir2 } = await import("os");
-  const { writeTemplateToDir: writeTemplateToDir2 } = await import("./baseline-PZM4KJJW.js");
+  const { writeTemplateToDir: writeTemplateToDir2 } = await import("./baseline-FKCXQFRD.js");
   const config = await readProjxConfig(cwd);
   const rootPinned = Array.isArray(config.skip) ? config.skip : [];
   const componentPinned = [];
   for (const component of components) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join2(cwd, dir));
+    const marker = await readComponentMarker(join3(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       componentPinned.push({ component, dir, patterns: marker.skip });
     }
   }
   if (rootPinned.length === 0 && componentPinned.length === 0) return [];
-  const tmpTemplate = join2(tmpdir2(), `projx-pinned-${Date.now()}`);
-  await mkdir5(tmpTemplate, { recursive: true });
+  const tmpTemplate = await mkdtemp2(join3(tmpdir2(), "projx-pinned-"));
   void componentSkips;
   void rootSkip;
   try {
@@ -507,22 +882,22 @@ async function findPinnedFilesWithUpdates(cwd, repoDir, components, componentPat
     );
     const updates = [];
     for (const file of rootPinned) {
-      const tmplPath = join2(tmpTemplate, file);
-      const userPath = join2(cwd, file);
-      if (!existsSync2(tmplPath) || !existsSync2(userPath)) continue;
-      const tmplContent = await readFile7(tmplPath, "utf-8");
-      const userContent = await readFile7(userPath, "utf-8");
+      const tmplPath = join3(tmpTemplate, file);
+      const userPath = join3(cwd, file);
+      if (!existsSync3(tmplPath) || !existsSync3(userPath)) continue;
+      const tmplContent = await readFile8(tmplPath, "utf-8");
+      const userContent = await readFile8(userPath, "utf-8");
       if (tmplContent !== userContent) updates.push(file);
     }
     for (const { dir, patterns } of componentPinned) {
       for (const pattern of patterns) {
         if (pattern.includes("*")) continue;
         const rel = `${dir}/${pattern}`;
-        const tmplPath = join2(tmpTemplate, rel);
-        const userPath = join2(cwd, rel);
-        if (!existsSync2(tmplPath) || !existsSync2(userPath)) continue;
-        const tmplContent = await readFile7(tmplPath, "utf-8");
-        const userContent = await readFile7(userPath, "utf-8");
+        const tmplPath = join3(tmpTemplate, rel);
+        const userPath = join3(cwd, rel);
+        if (!existsSync3(tmplPath) || !existsSync3(userPath)) continue;
+        const tmplContent = await readFile8(tmplPath, "utf-8");
+        const userContent = await readFile8(userPath, "utf-8");
         if (tmplContent !== userContent) updates.push(rel);
       }
     }
@@ -596,7 +971,7 @@ async function promptSkipLearning(cwd, componentPaths, version, conflictedFiles)
       const entry = entries.find((e) => e.file === file);
       try {
         if (entry?.status === "??") {
-          await unlink(join2(cwd, file));
+          await unlink(join3(cwd, file));
         } else {
           execSync(`git checkout -- "${file}"`, { cwd, stdio: "pipe" });
         }
@@ -630,9 +1005,9 @@ async function learnSkips(cwd, files, componentPaths) {
     let matched = false;
     for (const [dir, component] of Object.entries(dirToComponent)) {
       if (file.startsWith(dir + "/")) {
-        const relative = file.slice(dir.length + 1);
+        const relative2 = file.slice(dir.length + 1);
         if (!componentSkipAdds[component]) componentSkipAdds[component] = [];
-        componentSkipAdds[component].push(relative);
+        componentSkipAdds[component].push(relative2);
         matched = true;
         break;
       }
@@ -643,10 +1018,10 @@ async function learnSkips(cwd, files, componentPaths) {
   }
   for (const [component, additions] of Object.entries(componentSkipAdds)) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join2(cwd, dir));
+    const marker = await readComponentMarker(join3(cwd, dir));
     if (!marker) continue;
     const merged = [.../* @__PURE__ */ new Set([...marker.skip, ...additions])];
-    await writeComponentMarker(join2(cwd, dir), { ...marker, skip: merged });
+    await writeComponentMarker(join3(cwd, dir), { ...marker, skip: merged });
   }
   if (rootSkipAdds.length > 0) {
     const config = await readProjxConfig(cwd);
@@ -657,14 +1032,14 @@ async function learnSkips(cwd, files, componentPaths) {
 }
 
 // src/add.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync3 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync4 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join4 } from "path";
 import * as p4 from "@clack/prompts";
 async function add(cwd, newComponents, localRepo, skipInstall = false, customName) {
   p4.intro("projx add");
   const isLocal = !!localRepo;
-  if (!existsSync3(join3(cwd, ".projx"))) {
+  if (!existsSync4(join4(cwd, ".projx"))) {
     p4.log.error(
       "No .projx file found. Run 'npx create-projx <name>' to create a project first."
     );
@@ -678,8 +1053,8 @@ async function add(cwd, newComponents, localRepo, skipInstall = false, customNam
         "--name can only be used when adding a single component type."
       );
     }
-    const targetDir = join3(cwd, customName);
-    if (existsSync3(targetDir)) {
+    const targetDir = join4(cwd, customName);
+    if (existsSync4(targetDir)) {
       throw new Error(`Directory '${customName}' already exists.`);
     }
     return await addInstance(
@@ -730,14 +1105,15 @@ async function add(cwd, newComponents, localRepo, skipInstall = false, customNam
       components: allComponents,
       paths,
       instances,
-      pm: pmCommands(pm)
+      pm: pmCommands(pm),
+      orm: config.orm ?? "prisma"
     };
     const pkg = JSON.parse(
-      await readFile3(join3(repoDir, "cli/package.json"), "utf-8")
+      await readFile4(join4(repoDir, "cli/package.json"), "utf-8")
     );
     const version = pkg.version;
-    const spinner7 = p4.spinner();
-    spinner7.start("Adding components");
+    const spinner6 = p4.spinner();
+    spinner6.start("Adding components");
     await writeTemplateToDir(
       cwd,
       repoDir,
@@ -747,7 +1123,7 @@ async function add(cwd, newComponents, localRepo, skipInstall = false, customNam
       version,
       { realCwd: cwd }
     );
-    spinner7.stop("Components added.");
+    spinner6.stop("Components added.");
     if (!skipInstall) {
       await installDeps2(
         cwd,
@@ -756,9 +1132,9 @@ async function add(cwd, newComponents, localRepo, skipInstall = false, customNam
       );
     }
     for (const component of toAdd) {
-      const example = join3(cwd, component, ".env.example");
-      const env = join3(cwd, component, ".env");
-      if (existsSync3(example) && !existsSync3(env)) {
+      const example = join4(cwd, component, ".env.example");
+      const env = join4(cwd, component, ".env");
+      if (existsSync4(example) && !existsSync4(env)) {
         try {
           copyFileSync2(example, env);
         } catch {
@@ -798,28 +1174,28 @@ async function addInstance(cwd, type, customName, config, existing, localRepo, s
       components: existing,
       paths,
       instances,
-      pm: pmCommands(pm)
+      pm: pmCommands(pm),
+      orm: config.orm ?? "prisma"
     };
     const pkg = JSON.parse(
-      await readFile3(join3(repoDir, "cli/package.json"), "utf-8")
+      await readFile4(join4(repoDir, "cli/package.json"), "utf-8")
     );
     const version = pkg.version;
     const INSTANCE_AWARE_ROOT = /* @__PURE__ */ new Set([
       ".github/workflows/ci.yml",
       ".githooks/pre-commit",
       "scripts/setup.sh",
-      "docker-compose.yml",
-      "docker-compose.dev.yml"
+      "docker-compose.yml"
     ]);
     const rawSkip = Array.isArray(config.skip) ? config.skip : [];
-    const rootSkip = rawSkip.filter((p11) => !INSTANCE_AWARE_ROOT.has(p11));
+    const rootSkip = rawSkip.filter((p10) => !INSTANCE_AWARE_ROOT.has(p10));
     const componentSkips = {};
     for (const inst of existingInstances) {
-      const m = await readComponentMarker(join3(cwd, inst.path));
+      const m = await readComponentMarker(join4(cwd, inst.path));
       if (m?.skip && m.skip.length > 0) componentSkips[inst.type] = m.skip;
     }
-    const spinner7 = p4.spinner();
-    spinner7.start(`Scaffolding ${customName}/`);
+    const spinner6 = p4.spinner();
+    spinner6.start(`Scaffolding ${customName}/`);
     const result = await applyTemplate(
       cwd,
       repoDir,
@@ -833,7 +1209,7 @@ async function addInstance(cwd, type, customName, config, existing, localRepo, s
       [newInstance],
       [newInstance]
     );
-    spinner7.stop(`Scaffolded ${customName}/.`);
+    spinner6.stop(`Scaffolded ${customName}/.`);
     if (result.status === "merged") {
       p4.log.success(
         `${result.mergedFiles?.length ?? 0} root file(s) merged cleanly.`
@@ -851,9 +1227,9 @@ async function addInstance(cwd, type, customName, config, existing, localRepo, s
     if (!skipInstall) {
       await installDeps2(cwd, [{ type, path: customName }], pm);
     }
-    const example = join3(cwd, customName, ".env.example");
-    const env = join3(cwd, customName, ".env");
-    if (existsSync3(example) && !existsSync3(env)) {
+    const example = join4(cwd, customName, ".env.example");
+    const env = join4(cwd, customName, ".env");
+    if (existsSync4(example) && !existsSync4(env)) {
       try {
         copyFileSync2(example, env);
       } catch {
@@ -868,26 +1244,39 @@ async function installDeps2(dest, instances, pm) {
   const cmds = pmCommands(pm);
   const pmBin = pm === "bun" ? "bun" : pm;
   for (const { type, path } of instances) {
-    const dir = join3(dest, path);
-    const spinner7 = p4.spinner();
+    const dir = join4(dest, path);
+    const spinner6 = p4.spinner();
     try {
       switch (type) {
         case "fastapi":
           if (hasCommand("uv")) {
-            spinner7.start(`Installing FastAPI dependencies (${path}/)`);
+            spinner6.start(`Installing FastAPI dependencies (${path}/)`);
             exec("uv sync --all-extras", dir);
-            spinner7.stop(`FastAPI dependencies installed (${path}/).`);
+            spinner6.stop(`FastAPI dependencies installed (${path}/).`);
           } else {
             p4.log.warn(`uv not found \u2014 run 'cd ${path} && uv sync' manually.`);
           }
           break;
         case "fastify":
           if (hasCommand(pmBin)) {
-            spinner7.start(
+            spinner6.start(
               `Installing Fastify dependencies (${path}/, ${cmds.install})`
             );
             exec(cmds.install, dir);
-            spinner7.stop(`Fastify dependencies installed (${path}/).`);
+            spinner6.stop(`Fastify dependencies installed (${path}/).`);
+          } else {
+            p4.log.warn(
+              `${pm} not found \u2014 run 'cd ${path} && ${cmds.install}' manually.`
+            );
+          }
+          break;
+        case "express":
+          if (hasCommand(pmBin)) {
+            spinner6.start(
+              `Installing Express dependencies (${path}/, ${cmds.install})`
+            );
+            exec(cmds.install, dir);
+            spinner6.stop(`Express dependencies installed (${path}/).`);
           } else {
             p4.log.warn(
               `${pm} not found \u2014 run 'cd ${path} && ${cmds.install}' manually.`
@@ -896,11 +1285,11 @@ async function installDeps2(dest, instances, pm) {
           break;
         case "frontend":
           if (hasCommand(pmBin)) {
-            spinner7.start(
+            spinner6.start(
               `Installing Frontend dependencies (${path}/, ${cmds.install})`
             );
             exec(cmds.install, dir);
-            spinner7.stop(`Frontend dependencies installed (${path}/).`);
+            spinner6.stop(`Frontend dependencies installed (${path}/).`);
           } else {
             p4.log.warn(
               `${pm} not found \u2014 run 'cd ${path} && ${cmds.install}' manually.`
@@ -909,11 +1298,11 @@ async function installDeps2(dest, instances, pm) {
           break;
         case "e2e":
           if (hasCommand(pmBin)) {
-            spinner7.start(
+            spinner6.start(
               `Installing E2E dependencies (${path}/, ${cmds.install})`
             );
             exec(cmds.install, dir);
-            spinner7.stop(`E2E dependencies installed (${path}/).`);
+            spinner6.stop(`E2E dependencies installed (${path}/).`);
           } else {
             p4.log.warn(
               `${pm} not found \u2014 run 'cd ${path} && ${cmds.install}' manually.`
@@ -922,9 +1311,9 @@ async function installDeps2(dest, instances, pm) {
           break;
         case "mobile":
           if (hasCommand("flutter")) {
-            spinner7.start(`Installing Flutter dependencies (${path}/)`);
+            spinner6.start(`Installing Flutter dependencies (${path}/)`);
             exec("flutter pub get", dir);
-            spinner7.stop(`Flutter dependencies installed (${path}/).`);
+            spinner6.stop(`Flutter dependencies installed (${path}/).`);
           } else {
             p4.log.warn(
               `Flutter not found \u2014 run 'cd ${path} && flutter pub get' manually.`
@@ -935,30 +1324,30 @@ async function installDeps2(dest, instances, pm) {
           break;
       }
     } catch {
-      spinner7.stop(`Failed to install ${type} dependencies (${path}/).`);
+      spinner6.stop(`Failed to install ${type} dependencies (${path}/).`);
     }
   }
 }
 
 // src/init.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
 import { execSync as execSync2 } from "child_process";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import * as p5 from "@clack/prompts";
 
 // src/detect.ts
-import { existsSync as existsSync4 } from "fs";
-import { readdir } from "fs/promises";
-import { join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join5 } from "path";
 async function detectComponents(cwd) {
   const results = [];
-  const entries = await readdir(cwd, { withFileTypes: true });
+  const entries = await readdir2(cwd, { withFileTypes: true });
   const dirs = entries.filter(
     (e) => e.isDirectory() && !e.name.startsWith(".") && !EXCLUDE.has(e.name)
   ).map((e) => e.name);
   for (const dir of dirs) {
-    const full = join4(cwd, dir);
+    const full = join5(cwd, dir);
     const detections = await scanDirectory(full, dir);
     results.push(...detections);
   }
@@ -966,7 +1355,7 @@ async function detectComponents(cwd) {
 }
 async function scanDirectory(dir, relPath) {
   const results = [];
-  const pyproject = await readFileOrNull(join4(dir, "pyproject.toml"));
+  const pyproject = await readFileOrNull(join5(dir, "pyproject.toml"));
   if (pyproject && /fastapi/i.test(pyproject)) {
     results.push({
       component: "fastapi",
@@ -986,6 +1375,14 @@ async function scanDirectory(dir, relPath) {
         evidence: "package.json has fastify dependency"
       });
     }
+    if (allDeps.express) {
+      results.push({
+        component: "express",
+        directory: relPath,
+        confidence: "high",
+        evidence: "package.json has express dependency"
+      });
+    }
     if (allDeps.react || allDeps["react-dom"]) {
       results.push({
         component: "frontend",
@@ -1003,7 +1400,7 @@ async function scanDirectory(dir, relPath) {
       });
     }
   }
-  const pubspec = await readFileOrNull(join4(dir, "pubspec.yaml"));
+  const pubspec = await readFileOrNull(join5(dir, "pubspec.yaml"));
   if (pubspec && /flutter:/i.test(pubspec)) {
     results.push({
       component: "mobile",
@@ -1012,7 +1409,7 @@ async function scanDirectory(dir, relPath) {
       evidence: "pubspec.yaml has flutter dependency"
     });
   }
-  const hasTf = existsSync4(join4(dir, "main.tf")) || existsSync4(join4(dir, "variables.tf")) || existsSync4(join4(dir, "stack/main.tf")) || existsSync4(join4(dir, "versions.tf"));
+  const hasTf = existsSync5(join5(dir, "main.tf")) || existsSync5(join5(dir, "variables.tf")) || existsSync5(join5(dir, "stack/main.tf")) || existsSync5(join5(dir, "versions.tf"));
   if (hasTf) {
     results.push({
       component: "infra",
@@ -1024,7 +1421,7 @@ async function scanDirectory(dir, relPath) {
   return results;
 }
 async function readPkg(dir) {
-  const content = await readFileOrNull(join4(dir, "package.json"));
+  const content = await readFileOrNull(join5(dir, "package.json"));
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -1037,7 +1434,7 @@ async function readPkg(dir) {
 async function init(cwd, localRepo) {
   p5.intro("projx init");
   const isLocal = !!localRepo;
-  if (existsSync5(join5(cwd, ".projx"))) {
+  if (existsSync6(join6(cwd, ".projx"))) {
     p5.log.error(
       "This project is already initialized. Use 'npx create-projx update' or 'npx create-projx add' instead."
     );
@@ -1053,10 +1450,10 @@ async function init(cwd, localRepo) {
     p5.log.error("You have uncommitted changes. Commit or stash them first.");
     process.exit(1);
   }
-  const spinner7 = p5.spinner();
-  spinner7.start("Scanning for components");
+  const spinner6 = p5.spinner();
+  spinner6.start("Scanning for components");
   const detected = await detectComponents(cwd);
-  spinner7.stop(
+  spinner6.stop(
     detected.length > 0 ? `Found ${detected.length} component(s).` : "No components detected."
   );
   if (detected.length === 0) {
@@ -1076,7 +1473,7 @@ async function init(cwd, localRepo) {
     confirmed.map((c) => [c.component, c.directory])
   );
   const hasJs = components.some(
-    (c) => ["fastify", "frontend", "e2e"].includes(c)
+    (c) => ["fastify", "express", "frontend", "e2e"].includes(c)
   );
   let pm = "npm";
   if (hasJs) {
@@ -1099,7 +1496,8 @@ async function init(cwd, localRepo) {
     projectName,
     components,
     paths,
-    pm: pmCommands(pm)
+    pm: pmCommands(pm),
+    orm: "prisma"
   };
   const dlSpinner = p5.spinner();
   dlSpinner.start(
@@ -1113,7 +1511,7 @@ async function init(cwd, localRepo) {
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
     const pkg = JSON.parse(
-      await readFile4(join5(repoDir, "cli/package.json"), "utf-8")
+      await readFile5(join6(repoDir, "cli/package.json"), "utf-8")
     );
     const version = pkg.version;
     const applySpinner = p5.spinner();
@@ -1130,7 +1528,7 @@ async function init(cwd, localRepo) {
       true
     );
     applySpinner.stop("Template applied.");
-    if (existsSync5(join5(cwd, ".githooks"))) {
+    if (existsSync6(join6(cwd, ".githooks"))) {
       try {
         execSync2("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
       } catch {
@@ -1179,7 +1577,7 @@ async function writeBareProjx(cwd, localRepo, isLocal, pm) {
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
     const pkg = JSON.parse(
-      await readFile4(join5(repoDir, "cli/package.json"), "utf-8")
+      await readFile5(join6(repoDir, "cli/package.json"), "utf-8")
     );
     const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const config = {
@@ -1228,8 +1626,8 @@ function hasUncommittedChanges2(cwd) {
 }
 
 // src/pin.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
 import * as p6 from "@clack/prompts";
 function classifyPattern(pattern, componentPaths) {
   const dirToComponent = {};
@@ -1249,7 +1647,7 @@ function classifyPattern(pattern, componentPaths) {
 }
 async function pin(cwd, patterns) {
   p6.intro("projx pin");
-  if (!existsSync6(join6(cwd, ".projx"))) {
+  if (!existsSync7(join7(cwd, ".projx"))) {
     p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
@@ -1262,20 +1660,20 @@ async function pin(cwd, patterns) {
       p6.log.warn(`Cannot pin ${pattern} \u2014 config files are managed by projx.`);
       continue;
     }
-    const { scope, component, relative } = classifyPattern(
+    const { scope, component, relative: relative2 } = classifyPattern(
       pattern,
       componentPaths
     );
     if (scope === "component" && component) {
       if (!componentAdds[component]) componentAdds[component] = [];
-      componentAdds[component].push(relative);
+      componentAdds[component].push(relative2);
     } else {
-      rootAdds.push(relative);
+      rootAdds.push(relative2);
     }
   }
   for (const [component, additions] of Object.entries(componentAdds)) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join6(cwd, dir));
+    const marker = await readComponentMarker(join7(cwd, dir));
     if (!marker) {
       p6.log.error(`Could not read marker for ${component}.`);
       continue;
@@ -1284,7 +1682,7 @@ async function pin(cwd, patterns) {
     const added = merged.length - marker.skip.length;
     if (added > 0) {
       const next = { ...marker, skip: merged };
-      await writeComponentMarker(join6(cwd, dir), next);
+      await writeComponentMarker(join7(cwd, dir), next);
       p6.log.success(`${component}: pinned ${additions.join(", ")}`);
     } else {
       p6.log.info(`${component}: already pinned.`);
@@ -1305,7 +1703,7 @@ async function pin(cwd, patterns) {
 }
 async function unpin(cwd, patterns) {
   p6.intro("projx unpin");
-  if (!existsSync6(join6(cwd, ".projx"))) {
+  if (!existsSync7(join7(cwd, ".projx"))) {
     p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
@@ -1314,20 +1712,20 @@ async function unpin(cwd, patterns) {
   const rootRemoves = [];
   const componentRemoves = {};
   for (const pattern of patterns) {
-    const { scope, component, relative } = classifyPattern(
+    const { scope, component, relative: relative2 } = classifyPattern(
       pattern,
       componentPaths
     );
     if (scope === "component" && component) {
       if (!componentRemoves[component]) componentRemoves[component] = [];
-      componentRemoves[component].push(relative);
+      componentRemoves[component].push(relative2);
     } else {
-      rootRemoves.push(relative);
+      rootRemoves.push(relative2);
     }
   }
   for (const [component, removals] of Object.entries(componentRemoves)) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join6(cwd, dir));
+    const marker = await readComponentMarker(join7(cwd, dir));
     if (!marker) {
       p6.log.error(`Could not read marker for ${component}.`);
       continue;
@@ -1336,7 +1734,7 @@ async function unpin(cwd, patterns) {
     const removed = marker.skip.length - filtered.length;
     if (removed > 0) {
       const next = { ...marker, skip: filtered };
-      await writeComponentMarker(join6(cwd, dir), next);
+      await writeComponentMarker(join7(cwd, dir), next);
       p6.log.success(`${component}: unpinned ${removals.join(", ")}`);
     } else {
       p6.log.info(`${component}: not found in skip list.`);
@@ -1357,7 +1755,7 @@ async function unpin(cwd, patterns) {
 }
 async function listPins(cwd) {
   p6.intro("projx pin --list");
-  if (!existsSync6(join6(cwd, ".projx"))) {
+  if (!existsSync7(join7(cwd, ".projx"))) {
     p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
@@ -1374,7 +1772,7 @@ async function listPins(cwd) {
   }
   for (const component of discovered) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join6(cwd, dir));
+    const marker = await readComponentMarker(join7(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       hasAny = true;
       const label = dir !== component ? `${component} (${dir}/)` : `${component}`;
@@ -1391,15 +1789,15 @@ async function listPins(cwd) {
 }
 
 // src/doctor.ts
-import { existsSync as existsSync7 } from "fs";
-import { readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { readdir as readdir3 } from "fs/promises";
 import { execSync as execSync3 } from "child_process";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import * as p7 from "@clack/prompts";
 async function checkConfig(cwd) {
   const results = [];
-  const configPath = join7(cwd, ".projx");
-  if (!existsSync7(configPath)) {
+  const configPath = join8(cwd, ".projx");
+  if (!existsSync8(configPath)) {
     results.push({
       name: ".projx exists",
       status: "fail",
@@ -1449,8 +1847,8 @@ async function checkComponents(cwd, components, componentPaths) {
   });
   for (const component of components) {
     const dir = componentPaths[component];
-    const fullDir = join7(cwd, dir);
-    if (!existsSync7(fullDir)) {
+    const fullDir = join8(cwd, dir);
+    if (!existsSync8(fullDir)) {
       results.push({
         name: `${component} directory`,
         status: "fail",
@@ -1590,10 +1988,10 @@ async function checkSkipPatterns(cwd, rootConfig, components, componentPaths) {
   }
   for (const component of components) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join7(cwd, dir));
+    const marker = await readComponentMarker(join8(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       for (const pattern of marker.skip) {
-        const matches = await patternMatchesAnything(join7(cwd, dir), pattern);
+        const matches = await patternMatchesAnything(join8(cwd, dir), pattern);
         if (!matches) {
           results.push({
             name: `${component} skip`,
@@ -1615,16 +2013,16 @@ async function checkSkipPatterns(cwd, rootConfig, components, componentPaths) {
 }
 async function patternMatchesAnything(dir, pattern) {
   if (pattern === "**") return true;
-  if (!existsSync7(dir)) return false;
+  if (!existsSync8(dir)) return false;
   const walk = async (current, base) => {
     let entries;
     try {
-      entries = await readdir2(current, { withFileTypes: true });
+      entries = await readdir3(current, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
-      const full = join7(current, entry.name);
+      const full = join8(current, entry.name);
       const rel = full.slice(base.length + 1);
       if (entry.isDirectory()) {
         if (await walk(full, base)) return true;
@@ -1674,17 +2072,17 @@ function printReport(results) {
 }
 
 // src/diff.ts
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile5, mkdir as mkdir2, rm } from "fs/promises";
-import { join as join8 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile6, mkdtemp, rm } from "fs/promises";
+import { join as join9 } from "path";
 import { tmpdir } from "os";
 import * as p8 from "@clack/prompts";
 function isSkipped(file, componentPaths, componentSkips, rootSkip) {
   for (const [component, dir] of Object.entries(componentPaths)) {
     if (file.startsWith(dir + "/")) {
-      const relative = file.slice(dir.length + 1);
+      const relative2 = file.slice(dir.length + 1);
       const skips = componentSkips[component] ?? [];
-      if (matchesSkip(relative, skips)) return true;
+      if (matchesSkip(relative2, skips)) return true;
     }
   }
   const base = file.split("/").pop();
@@ -1700,7 +2098,7 @@ function fileComponent(file, componentPaths) {
 async function diff(cwd, localRepo) {
   p8.intro("projx diff");
   const isLocal = !!localRepo;
-  if (!existsSync8(join8(cwd, ".projx"))) {
+  if (!existsSync9(join9(cwd, ".projx"))) {
     p8.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
@@ -1709,7 +2107,7 @@ async function diff(cwd, localRepo) {
   const componentSkips = {};
   for (const component of components) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join8(cwd, dir));
+    const marker = await readComponentMarker(join9(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       componentSkips[component] = marker.skip;
     }
@@ -1727,7 +2125,7 @@ async function diff(cwd, localRepo) {
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
     const pkg = JSON.parse(
-      await readFile5(join8(repoDir, "cli/package.json"), "utf-8")
+      await readFile6(join9(repoDir, "cli/package.json"), "utf-8")
     );
     const version = pkg.version;
     p8.log.info(`Current: v${raw.version ?? "unknown"} \u2192 Template: v${version}`);
@@ -1736,12 +2134,12 @@ async function diff(cwd, localRepo) {
       projectName: name,
       components,
       paths: componentPaths,
-      pm: pmCommands(raw.packageManager ?? "npm")
+      pm: pmCommands(raw.packageManager ?? "npm"),
+      orm: raw.orm ?? "prisma"
     };
-    const spinner7 = p8.spinner();
-    spinner7.start("Analyzing changes");
-    const tmpTemplate = join8(tmpdir(), `projx-diff-${Date.now()}`);
-    await mkdir2(tmpTemplate, { recursive: true });
+    const spinner6 = p8.spinner();
+    spinner6.start("Analyzing changes");
+    const tmpTemplate = await mkdtemp(join9(tmpdir(), "projx-diff-"));
     await writeTemplateToDir(
       tmpTemplate,
       repoDir,
@@ -1764,16 +2162,16 @@ async function diff(cwd, localRepo) {
         analyses.push({ file, status: "skipped", component });
         continue;
       }
-      const oursPath = join8(cwd, file);
-      if (!existsSync8(oursPath)) {
+      const oursPath = join9(cwd, file);
+      if (!existsSync9(oursPath)) {
         analyses.push({ file, status: "new", component });
         continue;
       }
       let oursContent;
       let theirsContent;
       try {
-        oursContent = await readFile5(oursPath, "utf-8");
-        theirsContent = await readFile5(join8(tmpTemplate, file), "utf-8");
+        oursContent = await readFile6(oursPath, "utf-8");
+        theirsContent = await readFile6(join9(tmpTemplate, file), "utf-8");
       } catch {
         continue;
       }
@@ -1799,7 +2197,7 @@ async function diff(cwd, localRepo) {
       }
     }
     await rm(tmpTemplate, { recursive: true, force: true });
-    spinner7.stop("Analysis complete.");
+    spinner6.stop("Analysis complete.");
     const groups = {
       new: [],
       "clean-update": [],
@@ -1853,9 +2251,9 @@ async function diff(cwd, localRepo) {
 }
 
 // src/gen.ts
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile6, writeFile, mkdir as mkdir3 } from "fs/promises";
-import { join as join9 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile7, writeFile as writeFile2, mkdir as mkdir3 } from "fs/promises";
+import { join as join10 } from "path";
 import * as p9 from "@clack/prompts";
 var FIELD_TYPES = [
   "string",
@@ -1928,11 +2326,23 @@ async function promptEntityConfig(name) {
       initialValue: true
     });
     if (p9.isCancel(required)) process.exit(0);
-    fields.push({ name: toSnake(fieldName), type: fieldType, required });
+    fields.push({
+      name: toSnake(fieldName),
+      type: fieldType,
+      required,
+      unique: false,
+      generated: false
+    });
   }
   if (fields.length === 0) {
     p9.log.warn("No fields defined. Adding a default 'name' field.");
-    fields.push({ name: "name", type: "string", required: true });
+    fields.push({
+      name: "name",
+      type: "string",
+      required: true,
+      unique: false,
+      generated: false
+    });
   }
   const stringFields = fields.filter(
     (f) => f.type === "string" || f.type === "text"
@@ -1965,7 +2375,14 @@ function parseFieldsFlag(raw) {
     const required = nameType.endsWith("!");
     const name = toSnake(required ? nameType.slice(0, -1) : nameType);
     const type = rest[0] || "string";
-    return { name, type, required: required || true };
+    const modifiers = new Set(rest.slice(1).map((item) => item.toLowerCase()));
+    return {
+      name,
+      type,
+      required: required || true,
+      unique: modifiers.has("unique") || modifiers.has("@unique"),
+      generated: modifiers.has("generated") || modifiers.has("server") || modifiers.has("server-generated")
+    };
   });
 }
 function sqlalchemyType(type) {
@@ -2088,24 +2505,6 @@ function typeboxOptional(type) {
       return "Type.Optional(Type.Any())";
   }
 }
-function fieldMetaType(type) {
-  switch (type) {
-    case "string":
-      return { type: "str", fieldType: "text" };
-    case "number":
-      return { type: "int", fieldType: "number" };
-    case "boolean":
-      return { type: "bool", fieldType: "boolean" };
-    case "date":
-      return { type: "date", fieldType: "date" };
-    case "datetime":
-      return { type: "datetime", fieldType: "datetime" };
-    case "text":
-      return { type: "str", fieldType: "textarea" };
-    case "json":
-      return { type: "dict", fieldType: "textarea" };
-  }
-}
 function prismaType(type, required) {
   const nullable = required ? "" : "?";
   switch (type) {
@@ -2125,6 +2524,10 @@ function prismaType(type, required) {
       return `Json${nullable}`;
   }
 }
+function prismaFieldType(field) {
+  const base = prismaType(field.type, field.required);
+  return field.unique ? `${base} @unique` : base;
+}
 function generateFastifySchemas(config) {
   const className = toPascal(config.name);
   const lines = [];
@@ -2146,7 +2549,7 @@ function generateFastifySchemas(config) {
   lines.push(`export type ${className} = Static<typeof ${className}Schema>;`);
   lines.push("");
   lines.push(`export const Create${className}Schema = Type.Object({`);
-  for (const f of config.fields) {
+  for (const f of config.fields.filter((field) => !field.generated)) {
     if (f.required) {
       lines.push(`  ${f.name}: ${typeboxType(f.type, true)},`);
     } else {
@@ -2160,7 +2563,7 @@ function generateFastifySchemas(config) {
   );
   lines.push("");
   lines.push(`export const Update${className}Schema = Type.Object({`);
-  for (const f of config.fields) {
+  for (const f of config.fields.filter((field) => !field.generated)) {
     lines.push(`  ${f.name}: ${typeboxOptional(f.type)},`);
   }
   lines.push(`});`);
@@ -2174,44 +2577,26 @@ function generateFastifySchemas(config) {
 function generateFastifyIndex(config) {
   const className = toPascal(config.name);
   const camelConfig = className.charAt(0).toLowerCase() + className.slice(1) + "Config";
-  const allColumns = [
-    "id",
-    ...config.fields.map((f) => f.name),
-    "created_at",
-    "updated_at"
-  ];
-  if (config.softDelete) allColumns.push("deleted_at");
+  const generatedFields = config.fields.filter((field) => field.generated);
   const lines = [];
   lines.push(
-    `import { EntityRegistry, type EntityConfig, type FieldMeta } from '../_base/index.js';`
+    `import { EntityRegistry, type EntityConfig } from '../_base/index.js';`
   );
+  if (generatedFields.length > 0) {
+    lines.push(`import { randomBytes } from 'node:crypto';`);
+  }
   lines.push(
     `import { ${className}Schema, Create${className}Schema, Update${className}Schema } from './schemas.js';`
   );
   lines.push("");
-  lines.push(`const fields: FieldMeta[] = [`);
-  lines.push(
-    `  { key: 'id', label: 'Id', type: 'str', nullable: false, is_auto: true, is_primary_key: true, filterable: true, has_foreign_key: false, field_type: 'text' },`
-  );
-  for (const f of config.fields) {
-    const meta = fieldMetaType(f.type);
-    lines.push(
-      `  { key: '${f.name}', label: '${toTitle(f.name)}', type: '${meta.type}', nullable: ${!f.required}, is_auto: false, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: '${meta.fieldType}' },`
-    );
-  }
-  lines.push(
-    `  { key: 'created_at', label: 'Created At', type: 'datetime', nullable: false, is_auto: true, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: 'datetime' },`
-  );
-  lines.push(
-    `  { key: 'updated_at', label: 'Updated At', type: 'datetime', nullable: false, is_auto: true, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: 'datetime' },`
-  );
-  if (config.softDelete) {
+  for (const field of generatedFields) {
     lines.push(
-      `  { key: 'deleted_at', label: 'Deleted At', type: 'datetime', nullable: true, is_auto: true, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: 'datetime' },`
+      `function generate${className}${toPascal(field.name)}(): string {`
     );
+    lines.push(`  return randomBytes(8).toString('hex').toUpperCase();`);
+    lines.push(`}`);
+    lines.push("");
   }
-  lines.push(`];`);
-  lines.push("");
   const tags = config.apiPrefix.replace(/^\//, "");
   lines.push(`export const ${camelConfig}: EntityConfig = {`);
   lines.push(`  name: '${className}',`);
@@ -2222,7 +2607,6 @@ function generateFastifyIndex(config) {
   lines.push(`  readonly: ${config.readonly},`);
   lines.push(`  softDelete: ${config.softDelete},`);
   lines.push(`  bulkOperations: ${config.bulkOperations},`);
-  lines.push(`  columnNames: [${allColumns.map((c) => `'${c}'`).join(", ")}],`);
   if (config.searchableFields.length > 0) {
     lines.push(
       `  searchableFields: [${config.searchableFields.map((f) => `'${f}'`).join(", ")}],`
@@ -2230,10 +2614,25 @@ function generateFastifyIndex(config) {
   } else {
     lines.push(`  searchableFields: [],`);
   }
-  lines.push(`  fields,`);
   lines.push(`  schema: ${className}Schema,`);
   lines.push(`  createSchema: Create${className}Schema,`);
   lines.push(`  updateSchema: Update${className}Schema,`);
+  if (generatedFields.length > 0) {
+    lines.push(
+      `  beforeCreateFields: [${generatedFields.map((field) => `'${field.name}'`).join(", ")}],`
+    );
+    lines.push(`  beforeCreate: (_request, data) => {`);
+    for (const field of generatedFields) {
+      lines.push(
+        `    if (!('${field.name}' in data) || data.${field.name} == null) {`
+      );
+      lines.push(
+        `      data.${field.name} = generate${className}${toPascal(field.name)}();`
+      );
+      lines.push(`    }`);
+    }
+    lines.push(`  },`);
+  }
   lines.push(`};`);
   lines.push("");
   lines.push(`EntityRegistry.register(${camelConfig});`);
@@ -2247,7 +2646,7 @@ function generatePrismaModel(config) {
   lines.push(`  id         String   @id @default(uuid())`);
   for (const f of config.fields) {
     const padded = f.name.padEnd(10);
-    lines.push(`  ${padded} ${prismaType(f.type, f.required)}`);
+    lines.push(`  ${padded} ${prismaFieldType(f)}`);
   }
   if (config.softDelete) {
     lines.push(`  deleted_at DateTime?`);
@@ -2262,28 +2661,248 @@ function generatePrismaModel(config) {
   lines.push(`}`);
   return lines.join("\n");
 }
-function tsType(type, required) {
-  const base = (() => {
+function drizzleColumn(field) {
+  let expr;
+  switch (field.type) {
+    case "number":
+      expr = `integer('${field.name}')`;
+      break;
+    case "boolean":
+      expr = `boolean('${field.name}')`;
+      break;
+    case "date":
+      expr = `date('${field.name}')`;
+      break;
+    case "datetime":
+      expr = `timestamp('${field.name}', { withTimezone: true })`;
+      break;
+    case "json":
+      expr = `jsonb('${field.name}')`;
+      break;
+    case "text":
+    case "string":
+      expr = `text('${field.name}')`;
+      break;
+  }
+  if (field.required) expr += ".notNull()";
+  if (field.unique) expr += ".unique()";
+  return expr;
+}
+function generateDrizzleTable(config) {
+  const lines = [];
+  const tableConst = toCamel(pluralize(toPascal(config.name)));
+  lines.push(`export const ${tableConst} = pgTable('${config.tableName}', {`);
+  lines.push(`  id: uuid('id').primaryKey().defaultRandom(),`);
+  lines.push(
+    `  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),`
+  );
+  lines.push(
+    `  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow().$onUpdate(() => new Date()),`
+  );
+  if (config.softDelete) {
+    lines.push(`  deletedAt: timestamp('deleted_at', { withTimezone: true }),`);
+  }
+  for (const field of config.fields) {
+    lines.push(`  ${toCamel(field.name)}: ${drizzleColumn(field)},`);
+  }
+  lines.push(`});`);
+  return lines.join("\n");
+}
+function drizzleImports(config) {
+  const used = /* @__PURE__ */ new Set(["pgTable", "uuid", "timestamp"]);
+  for (const field of config.fields) {
+    switch (field.type) {
+      case "number":
+        used.add("integer");
+        break;
+      case "boolean":
+        used.add("boolean");
+        break;
+      case "date":
+        used.add("date");
+        break;
+      case "datetime":
+        used.add("timestamp");
+        break;
+      case "json":
+        used.add("jsonb");
+        break;
+      case "text":
+      case "string":
+        used.add("text");
+        break;
+    }
+  }
+  return [...used].sort();
+}
+function zodType(type, required) {
+  const inner = (() => {
     switch (type) {
       case "string":
       case "text":
-      case "date":
-      case "datetime":
-        return "string";
+        return "z.string()";
       case "number":
-        return "number";
+        return "z.number()";
       case "boolean":
-        return "boolean";
+        return "z.boolean()";
+      case "date":
+        return "z.string().date()";
+      case "datetime":
+        return "z.string().datetime()";
       case "json":
-        return "Record<string, unknown>";
+        return "z.unknown()";
     }
   })();
-  return required ? base : `${base} | null`;
+  return required ? inner : `${inner}.nullable()`;
 }
-function generateFrontendInterface(config) {
-  const className = toPascal(config.name);
-  const lines = [];
-  lines.push(`export interface ${className} {`);
+function zodOptional(type) {
+  switch (type) {
+    case "string":
+    case "text":
+      return "z.string().optional()";
+    case "number":
+      return "z.number().optional()";
+    case "boolean":
+      return "z.boolean().optional()";
+    case "date":
+      return "z.string().date().optional()";
+    case "datetime":
+      return "z.string().datetime().optional()";
+    case "json":
+      return "z.unknown().optional()";
+  }
+}
+function generateExpressSchemas(config) {
+  const className = toPascal(config.name);
+  const lines = [];
+  lines.push(`import { z } from 'zod';`);
+  lines.push("");
+  lines.push(`export const ${className}Schema = z.object({`);
+  lines.push(`  id: z.string().uuid(),`);
+  for (const f of config.fields) {
+    lines.push(`  ${f.name}: ${zodType(f.type, f.required)},`);
+  }
+  lines.push(`  created_at: z.string().datetime(),`);
+  lines.push(`  updated_at: z.string().datetime(),`);
+  if (config.softDelete)
+    lines.push(`  deleted_at: z.string().datetime().nullable(),`);
+  lines.push(`});`);
+  lines.push("");
+  lines.push(`export type ${className} = z.infer<typeof ${className}Schema>;`);
+  lines.push("");
+  lines.push(`export const Create${className}Schema = z.object({`);
+  for (const f of config.fields.filter((field) => !field.generated)) {
+    if (f.required) {
+      lines.push(`  ${f.name}: ${zodType(f.type, true)},`);
+    } else {
+      lines.push(`  ${f.name}: ${zodOptional(f.type)},`);
+    }
+  }
+  lines.push(`});`);
+  lines.push("");
+  lines.push(
+    `export type Create${className} = z.infer<typeof Create${className}Schema>;`
+  );
+  lines.push("");
+  lines.push(`export const Update${className}Schema = z.object({`);
+  for (const f of config.fields.filter((field) => !field.generated)) {
+    lines.push(`  ${f.name}: ${zodOptional(f.type)},`);
+  }
+  lines.push(`});`);
+  lines.push("");
+  lines.push(
+    `export type Update${className} = z.infer<typeof Update${className}Schema>;`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function generateExpressIndex(config) {
+  const className = toPascal(config.name);
+  const camelConfig = className.charAt(0).toLowerCase() + className.slice(1) + "Config";
+  const generatedFields = config.fields.filter((field) => field.generated);
+  const tags = config.apiPrefix.replace(/^\//, "");
+  const lines = [];
+  lines.push(
+    `import { EntityRegistry, type EntityConfig } from '../_base/index.js';`
+  );
+  if (generatedFields.length > 0) {
+    lines.push(`import { randomBytes } from 'node:crypto';`);
+  }
+  lines.push(
+    `import { ${className}Schema, Create${className}Schema, Update${className}Schema } from './schemas.js';`
+  );
+  lines.push("");
+  for (const field of generatedFields) {
+    lines.push(
+      `function generate${className}${toPascal(field.name)}(): string {`
+    );
+    lines.push(`  return randomBytes(8).toString('hex').toUpperCase();`);
+    lines.push(`}`);
+    lines.push("");
+  }
+  lines.push(`export const ${camelConfig}: EntityConfig = {`);
+  lines.push(`  name: '${className}',`);
+  lines.push(`  tableName: '${config.tableName}',`);
+  lines.push(`  prismaModel: '${className}',`);
+  lines.push(`  apiPrefix: '${config.apiPrefix}',`);
+  lines.push(`  tags: ['${tags}'],`);
+  lines.push(`  readonly: ${config.readonly},`);
+  lines.push(`  softDelete: ${config.softDelete},`);
+  lines.push(`  bulkOperations: ${config.bulkOperations},`);
+  if (config.searchableFields.length > 0) {
+    lines.push(
+      `  searchableFields: [${config.searchableFields.map((f) => `'${f}'`).join(", ")}],`
+    );
+  } else {
+    lines.push(`  searchableFields: [],`);
+  }
+  lines.push(`  schema: ${className}Schema,`);
+  lines.push(`  createSchema: Create${className}Schema,`);
+  lines.push(`  updateSchema: Update${className}Schema,`);
+  if (generatedFields.length > 0) {
+    lines.push(
+      `  beforeCreateFields: [${generatedFields.map((field) => `'${field.name}'`).join(", ")}],`
+    );
+    lines.push(`  beforeCreate: (_request, data) => {`);
+    for (const field of generatedFields) {
+      lines.push(
+        `    if (!('${field.name}' in data) || data.${field.name} == null) {`
+      );
+      lines.push(
+        `      data.${field.name} = generate${className}${toPascal(field.name)}();`
+      );
+      lines.push(`    }`);
+    }
+    lines.push(`  },`);
+  }
+  lines.push(`};`);
+  lines.push("");
+  lines.push(`EntityRegistry.register(${camelConfig});`);
+  lines.push("");
+  return lines.join("\n");
+}
+function tsType(type, required) {
+  const base = (() => {
+    switch (type) {
+      case "string":
+      case "text":
+      case "date":
+      case "datetime":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "json":
+        return "Record<string, unknown>";
+    }
+  })();
+  return required ? base : `${base} | null`;
+}
+function generateFrontendInterface(config) {
+  const className = toPascal(config.name);
+  const lines = [];
+  lines.push(`export interface ${className} {`);
   lines.push(`  id: string;`);
   for (const f of config.fields) {
     lines.push(`  ${f.name}: ${tsType(f.type, f.required)};`);
@@ -2331,7 +2950,8 @@ function dartType(type, required) {
   return required ? base : `${base}?`;
 }
 function toCamel(s) {
-  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  const pascal = toPascal(s);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 function dartFromJson(fieldName, type, required) {
   const key = `json['${fieldName}']`;
@@ -2565,77 +3185,579 @@ function generateFastifyTest(config) {
   const className = toPascal(config.name);
   const basePath = `/api/v1${config.apiPrefix}`;
   const updateField = config.fields[0];
+  const uniqueFields = config.fields.filter((field) => field.unique);
   const lines = [];
   lines.push(
     `import { describeCrudEntity } from '../helpers/crud-test-base.js';`
   );
+  lines.push(
+    `import { Create${className}Schema } from '../../src/modules/${toKebab(config.name)}/schemas.js';`
+  );
   lines.push("");
   lines.push(`describeCrudEntity({`);
   lines.push(`  entityName: '${className}',`);
   lines.push(`  basePath: '${basePath}',`);
   lines.push(`  prismaModel: '${className}',`);
-  lines.push(`  createPayload: {`);
-  for (const f of config.fields) {
-    lines.push(`    ${f.name}: ${tsLiteral(f.type, "create")},`);
-  }
+  lines.push(`  createSchema: Create${className}Schema,`);
+  lines.push(`  updatePayload: {`);
+  lines.push(
+    `    ${updateField.name}: ${tsLiteral(updateField.type, "update")},`
+  );
   lines.push(`  },`);
+  if (uniqueFields.length > 0) {
+    lines.push(
+      `  uniqueFields: [${uniqueFields.map((field) => `'${field.name}'`).join(", ")}],`
+    );
+  }
+  lines.push(`});`);
+  lines.push("");
+  return lines.join("\n");
+}
+function generateExpressTest(config) {
+  const className = toPascal(config.name);
+  const basePath = `/api/v1${config.apiPrefix}`;
+  const updateField = config.fields[0];
+  const uniqueFields = config.fields.filter((field) => field.unique);
+  const lines = [];
+  lines.push(
+    `import { describeCrudEntity } from '../helpers/crud-test-base.js';`
+  );
+  lines.push(
+    `import { Create${className}Schema } from '../../src/modules/${toKebab(config.name)}/schemas.js';`
+  );
+  lines.push("");
+  lines.push(`describeCrudEntity({`);
+  lines.push(`  entityName: '${className}',`);
+  lines.push(`  basePath: '${basePath}',`);
+  lines.push(`  prismaModel: '${className}',`);
+  lines.push(`  createSchema: Create${className}Schema,`);
   lines.push(`  updatePayload: {`);
   lines.push(
     `    ${updateField.name}: ${tsLiteral(updateField.type, "update")},`
   );
   lines.push(`  },`);
+  if (uniqueFields.length > 0) {
+    lines.push(
+      `  uniqueFields: [${uniqueFields.map((field) => `'${field.name}'`).join(", ")}],`
+    );
+  }
   lines.push(`});`);
   lines.push("");
   return lines.join("\n");
 }
-async function resolvePrimaryBackend(cwd, hasFastapi, hasFastify, backendFlag) {
+function addonGenEntityPath(repoDir, orm, fileName) {
+  return join10(repoDir, "addons", "orms", orm, "gen-entity", fileName);
+}
+function sampleValue(field) {
+  switch (field.type) {
+    case "string":
+    case "text":
+      return `'sample-${field.name}'`;
+    case "number":
+      return "1";
+    case "boolean":
+      return "true";
+    case "date":
+      return "'2025-01-01'";
+    case "datetime":
+      return "'2025-01-01T00:00:00Z'";
+    case "json":
+      return "{}";
+  }
+}
+function sampleJsonPayload(fields) {
+  const props = fields.filter((f) => !f.generated).map((f) => `${f.name}: ${sampleValue(f)}`);
+  return `{ ${props.join(", ")} }`;
+}
+function updateJsonPayload(fields) {
+  const editable = fields.find(
+    (f) => !f.generated && (f.type === "string" || f.type === "text")
+  );
+  if (editable) return `{ ${editable.name}: 'updated-${editable.name}' }`;
+  const numeric = fields.find((f) => !f.generated && f.type === "number");
+  if (numeric) return `{ ${numeric.name}: 2 }`;
+  return sampleJsonPayload(fields);
+}
+function insertAtAnchor(content, anchor, insertion) {
+  if (content.includes(insertion)) return content;
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(anchor)) {
+      lines.splice(i + 1, 0, insertion);
+      return lines.join("\n");
+    }
+  }
+  return content;
+}
+async function fillTemplate(repoDir, orm, fileName, vars) {
+  const path = addonGenEntityPath(repoDir, orm, fileName);
+  if (!existsSync10(path)) {
+    throw new Error(`Addon template not found: ${path}`);
+  }
+  let content = await readFile7(path, "utf-8");
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`__${key}__`, value);
+  }
+  return content;
+}
+function buildDrizzleEntityVars(config) {
+  const pascal = toPascal(config.name);
+  return {
+    ENTITY_PASCAL: pascal,
+    TABLE_CAMEL: toCamel(pluralize(pascal)),
+    API_PREFIX: config.apiPrefix,
+    TAG: config.apiPrefix.replace(/^\//, ""),
+    SEARCHABLE_FIELDS_ARRAY: config.searchableFields.map((f) => `'${f}'`).join(", "),
+    BULK_OPERATIONS: String(config.bulkOperations),
+    SAMPLE_PAYLOAD: sampleJsonPayload(config.fields),
+    UPDATE_PAYLOAD: updateJsonPayload(config.fields)
+  };
+}
+function sequelizeFieldType(field) {
+  switch (field.type) {
+    case "string":
+      return { dataType: "STRING", tsType: "string" };
+    case "text":
+      return { dataType: "TEXT", tsType: "string" };
+    case "number":
+      return { dataType: "INTEGER", tsType: "number" };
+    case "boolean":
+      return { dataType: "BOOLEAN", tsType: "boolean" };
+    case "date":
+      return { dataType: "DATEONLY", tsType: "Date" };
+    case "datetime":
+      return { dataType: "DATE", tsType: "Date" };
+    case "json":
+      return { dataType: "JSONB", tsType: "unknown" };
+  }
+}
+function sequelizeFieldDeclarations(fields) {
+  return fields.map((f) => {
+    const { tsType: tsType2 } = sequelizeFieldType(f);
+    const nullable = f.required ? "" : " | null";
+    return `  declare ${toCamel(f.name)}: ${tsType2}${nullable};`;
+  }).join("\n");
+}
+function sequelizeFieldDefinitions(fields) {
+  return fields.map((f) => {
+    const { dataType } = sequelizeFieldType(f);
+    const parts = [`type: DataTypes.${dataType}`];
+    if (f.required) parts.push("allowNull: false");
+    else parts.push("allowNull: true");
+    if (f.unique) parts.push("unique: true");
+    return `    ${toCamel(f.name)}: { ${parts.join(", ")} },`;
+  }).join("\n");
+}
+function buildSequelizeEntityVars(config) {
+  const pascal = toPascal(config.name);
+  const kebab = toKebab(config.name);
+  return {
+    ENTITY_PASCAL: pascal,
+    ENTITY_KEBAB: kebab,
+    TABLE_NAME: config.tableName,
+    API_PREFIX: config.apiPrefix,
+    TAG: config.apiPrefix.replace(/^\//, ""),
+    SEARCHABLE_FIELDS_ARRAY: config.searchableFields.map((f) => `'${f}'`).join(", "),
+    BULK_OPERATIONS: String(config.bulkOperations),
+    SAMPLE_PAYLOAD: sampleJsonPayload(config.fields),
+    UPDATE_PAYLOAD: updateJsonPayload(config.fields),
+    FIELD_DECLARATIONS: sequelizeFieldDeclarations(config.fields),
+    FIELD_DEFINITIONS: sequelizeFieldDefinitions(config.fields)
+  };
+}
+function typeormColumnType(field) {
+  switch (field.type) {
+    case "string":
+      return "varchar";
+    case "text":
+      return "text";
+    case "number":
+      return "integer";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "date";
+    case "datetime":
+      return "timestamptz";
+    case "json":
+      return "jsonb";
+  }
+}
+function typeormColumnTsType(field) {
+  switch (field.type) {
+    case "string":
+    case "text":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+      return "Date";
+    case "json":
+      return "unknown";
+  }
+}
+function typeormColumnDecorators(fields) {
+  return fields.map((f) => {
+    const dbName = f.name;
+    const propName = toCamel(f.name);
+    const opts = [
+      `type: '${typeormColumnType(f)}'`,
+      `name: '${dbName}'`
+    ];
+    if (!f.required) opts.push("nullable: true");
+    if (f.unique) opts.push("unique: true");
+    const tsType2 = typeormColumnTsType(f);
+    const nullable = f.required ? "!" : "?";
+    return `  @Column({ ${opts.join(", ")} })
+  ${propName}${nullable}: ${tsType2}${f.required ? "" : " | null"};`;
+  }).join("\n\n");
+}
+function buildTypeormEntityVars(config) {
+  const pascal = toPascal(config.name);
+  const kebab = toKebab(config.name);
+  return {
+    ENTITY_PASCAL: pascal,
+    ENTITY_KEBAB: kebab,
+    TABLE_NAME: config.tableName,
+    API_PREFIX: config.apiPrefix,
+    TAG: config.apiPrefix.replace(/^\//, ""),
+    SEARCHABLE_FIELDS_ARRAY: config.searchableFields.map((f) => `'${f}'`).join(", "),
+    BULK_OPERATIONS: String(config.bulkOperations),
+    SAMPLE_PAYLOAD: sampleJsonPayload(config.fields),
+    UPDATE_PAYLOAD: updateJsonPayload(config.fields),
+    COLUMN_DECORATORS: typeormColumnDecorators(config.fields)
+  };
+}
+async function appendTypeormEntity(repoDir, cwd, dir, framework, config, generated) {
+  const vars = buildTypeormEntityVars(config);
+  const kebab = vars.ENTITY_KEBAB;
+  const entitiesDir = join10(cwd, dir, "src/entities");
+  await mkdir3(entitiesDir, { recursive: true });
+  const entityPath = join10(entitiesDir, `${kebab}.ts`);
+  if (!existsSync10(entityPath)) {
+    const entitySource = await fillTemplate(
+      repoDir,
+      "typeorm",
+      "entity.ts",
+      vars
+    );
+    await writeFile2(entityPath, entitySource);
+    generated.push(`${dir}/src/entities/${kebab}.ts`);
+  }
+  const entitiesIndexPath = join10(entitiesDir, "index.ts");
+  if (existsSync10(entitiesIndexPath)) {
+    let content = await readFile7(entitiesIndexPath, "utf-8");
+    const importLine = `import { ${vars.ENTITY_PASCAL} } from './${kebab}.js';`;
+    const exportLine = `  ${vars.ENTITY_PASCAL},`;
+    const updated = insertAtAnchor(
+      insertAtAnchor(content, "projx-anchor: model-imports", importLine),
+      "projx-anchor: model-exports",
+      exportLine
+    );
+    if (updated !== content) {
+      content = updated;
+      await writeFile2(entitiesIndexPath, content);
+      generated.push(`${dir}/src/entities/index.ts (entity wired)`);
+    }
+  }
+  const moduleDir = join10(cwd, dir, "src/modules", kebab);
+  if (!existsSync10(moduleDir)) {
+    await mkdir3(moduleDir, { recursive: true });
+    const routerSource = await fillTemplate(
+      repoDir,
+      "typeorm",
+      framework === "fastify" ? "fastify-router.ts" : "express-router.ts",
+      vars
+    );
+    await writeFile2(join10(moduleDir, "index.ts"), routerSource);
+    generated.push(`${dir}/src/modules/${kebab}/index.ts`);
+  }
+  const appPath = join10(cwd, dir, "src/app.ts");
+  if (existsSync10(appPath)) {
+    let appContent = await readFile7(appPath, "utf-8");
+    const importLine = `import { register${vars.ENTITY_PASCAL}Entity } from './modules/${kebab}/index.js';`;
+    const registrationLine = framework === "fastify" ? `  await register${vars.ENTITY_PASCAL}Entity(app);` : `  register${vars.ENTITY_PASCAL}Entity(app);`;
+    const updated = insertAtAnchor(
+      insertAtAnchor(appContent, "projx-anchor: entity-imports", importLine),
+      "projx-anchor: entity-registrations",
+      registrationLine
+    );
+    if (updated !== appContent) {
+      appContent = updated;
+      await writeFile2(appPath, appContent);
+      generated.push(`${dir}/src/app.ts (entity wired)`);
+    }
+  }
+  const testsDir = framework === "fastify" ? join10(cwd, dir, "tests/modules") : join10(cwd, dir, "tests");
+  await mkdir3(testsDir, { recursive: true });
+  const testFile = join10(testsDir, `${kebab}.test.ts`);
+  if (!existsSync10(testFile)) {
+    const testSource = await fillTemplate(
+      repoDir,
+      "typeorm",
+      framework === "fastify" ? "fastify-test.ts" : "express-test.ts",
+      vars
+    );
+    await writeFile2(testFile, testSource);
+    const testRel = framework === "fastify" ? `tests/modules/${kebab}.test.ts` : `tests/${kebab}.test.ts`;
+    generated.push(`${dir}/${testRel}`);
+  }
+}
+async function appendSequelizeEntity(repoDir, cwd, dir, framework, config, generated) {
+  const vars = buildSequelizeEntityVars(config);
+  const kebab = vars.ENTITY_KEBAB;
+  const modelsDir = join10(cwd, dir, "src/models");
+  await mkdir3(modelsDir, { recursive: true });
+  const modelPath = join10(modelsDir, `${kebab}.ts`);
+  if (!existsSync10(modelPath)) {
+    const modelSource = await fillTemplate(
+      repoDir,
+      "sequelize",
+      "model.ts",
+      vars
+    );
+    await writeFile2(modelPath, modelSource);
+    generated.push(`${dir}/src/models/${kebab}.ts`);
+  }
+  const modelsIndexPath = join10(modelsDir, "index.ts");
+  if (existsSync10(modelsIndexPath)) {
+    let content = await readFile7(modelsIndexPath, "utf-8");
+    const importLine = `import { ${vars.ENTITY_PASCAL} } from './${kebab}.js';`;
+    const exportLine = `  ${vars.ENTITY_PASCAL},`;
+    const updated = insertAtAnchor(
+      insertAtAnchor(content, "projx-anchor: model-imports", importLine),
+      "projx-anchor: model-exports",
+      exportLine
+    );
+    if (updated !== content) {
+      content = updated;
+      await writeFile2(modelsIndexPath, content);
+      generated.push(`${dir}/src/models/index.ts (model wired)`);
+    }
+  }
+  const moduleDir = join10(cwd, dir, "src/modules", kebab);
+  if (!existsSync10(moduleDir)) {
+    await mkdir3(moduleDir, { recursive: true });
+    const routerSource = await fillTemplate(
+      repoDir,
+      "sequelize",
+      framework === "fastify" ? "fastify-router.ts" : "express-router.ts",
+      vars
+    );
+    await writeFile2(join10(moduleDir, "index.ts"), routerSource);
+    generated.push(`${dir}/src/modules/${kebab}/index.ts`);
+  }
+  const appPath = join10(cwd, dir, "src/app.ts");
+  if (existsSync10(appPath)) {
+    let appContent = await readFile7(appPath, "utf-8");
+    const importLine = `import { register${vars.ENTITY_PASCAL}Entity } from './modules/${kebab}/index.js';`;
+    const registrationLine = framework === "fastify" ? `  await register${vars.ENTITY_PASCAL}Entity(app);` : `  register${vars.ENTITY_PASCAL}Entity(app);`;
+    const updated = insertAtAnchor(
+      insertAtAnchor(appContent, "projx-anchor: entity-imports", importLine),
+      "projx-anchor: entity-registrations",
+      registrationLine
+    );
+    if (updated !== appContent) {
+      appContent = updated;
+      await writeFile2(appPath, appContent);
+      generated.push(`${dir}/src/app.ts (entity wired)`);
+    }
+  }
+  const testsDir = framework === "fastify" ? join10(cwd, dir, "tests/modules") : join10(cwd, dir, "tests");
+  await mkdir3(testsDir, { recursive: true });
+  const testFile = join10(testsDir, `${kebab}.test.ts`);
+  if (!existsSync10(testFile)) {
+    const testSource = await fillTemplate(
+      repoDir,
+      "sequelize",
+      framework === "fastify" ? "fastify-test.ts" : "express-test.ts",
+      vars
+    );
+    await writeFile2(testFile, testSource);
+    const testRel = framework === "fastify" ? `tests/modules/${kebab}.test.ts` : `tests/${kebab}.test.ts`;
+    generated.push(`${dir}/${testRel}`);
+  }
+}
+async function appendDrizzleEntity(repoDir, cwd, dir, framework, config, generated) {
+  const schemaDir = join10(cwd, dir, "src/db");
+  const schemaPath = join10(schemaDir, "schema.ts");
+  const tableConst = toCamel(pluralize(toPascal(config.name)));
+  const tableSource = generateDrizzleTable(config);
+  await mkdir3(schemaDir, { recursive: true });
+  const usedImports = drizzleImports(config);
+  if (!existsSync10(schemaPath)) {
+    await writeFile2(
+      schemaPath,
+      `import { ${usedImports.join(", ")} } from 'drizzle-orm/pg-core';
+
+${tableSource}
+`
+    );
+    generated.push(`${dir}/src/db/schema.ts`);
+  } else {
+    const content = await readFile7(schemaPath, "utf-8");
+    if (!content.includes(`export const ${tableConst} = pgTable(`)) {
+      let updated = content;
+      const importLine = `import { ${usedImports.join(", ")} } from 'drizzle-orm/pg-core';`;
+      if (!updated.includes("drizzle-orm/pg-core")) {
+        updated = importLine + "\n\n" + updated;
+      } else {
+        updated = updated.replace(
+          /import\s+\{([^}]+)\}\s+from\s+'drizzle-orm\/pg-core';/,
+          (_match, imports) => {
+            const names = new Set(
+              String(imports).split(",").map((item) => item.trim()).filter(Boolean)
+            );
+            for (const name of usedImports) {
+              names.add(name);
+            }
+            return `import { ${[...names].sort().join(", ")} } from 'drizzle-orm/pg-core';`;
+          }
+        );
+      }
+      await writeFile2(
+        schemaPath,
+        updated.trimEnd() + "\n\n" + tableSource + "\n"
+      );
+      generated.push(`${dir}/src/db/schema.ts (table added)`);
+    }
+  }
+  const vars = buildDrizzleEntityVars(config);
+  const kebab = toKebab(config.name);
+  const moduleDir = join10(cwd, dir, "src/modules", kebab);
+  if (!existsSync10(moduleDir)) {
+    await mkdir3(moduleDir, { recursive: true });
+    const routerSource = await fillTemplate(
+      repoDir,
+      "drizzle",
+      framework === "fastify" ? "fastify-router.ts" : "express-router.ts",
+      vars
+    );
+    await writeFile2(join10(moduleDir, "index.ts"), routerSource);
+    generated.push(`${dir}/src/modules/${kebab}/index.ts`);
+  }
+  const appPath = join10(cwd, dir, "src/app.ts");
+  if (existsSync10(appPath)) {
+    let appContent = await readFile7(appPath, "utf-8");
+    const importLine = `import { register${vars.ENTITY_PASCAL}Entity } from './modules/${kebab}/index.js';`;
+    const registrationLine = framework === "fastify" ? `  await register${vars.ENTITY_PASCAL}Entity(app);` : `  register${vars.ENTITY_PASCAL}Entity(app, db);`;
+    const updated = insertAtAnchor(
+      insertAtAnchor(appContent, "projx-anchor: entity-imports", importLine),
+      "projx-anchor: entity-registrations",
+      registrationLine
+    );
+    if (updated !== appContent) {
+      appContent = updated;
+      await writeFile2(appPath, appContent);
+      generated.push(`${dir}/src/app.ts (entity wired)`);
+    }
+  }
+  const testsDir = framework === "fastify" ? join10(cwd, dir, "tests/modules") : join10(cwd, dir, "tests");
+  await mkdir3(testsDir, { recursive: true });
+  const testFile = join10(testsDir, `${kebab}.test.ts`);
+  if (!existsSync10(testFile)) {
+    const testSource = await fillTemplate(
+      repoDir,
+      "drizzle",
+      framework === "fastify" ? "fastify-test.ts" : "express-test.ts",
+      vars
+    );
+    await writeFile2(testFile, testSource);
+    const testRel = framework === "fastify" ? `tests/modules/${kebab}.test.ts` : `tests/${kebab}.test.ts`;
+    generated.push(`${dir}/${testRel}`);
+  }
+}
+async function resolvePrimaryBackend(cwd, hasFastapi, hasFastify, hasExpress, backendFlag) {
   if (backendFlag) return backendFlag;
-  if (hasFastapi && !hasFastify) return "fastapi";
-  if (hasFastify && !hasFastapi) return "fastify";
+  const backends = [
+    hasFastapi ? "fastapi" : void 0,
+    hasFastify ? "fastify" : void 0,
+    hasExpress ? "express" : void 0
+  ].filter((item) => item !== void 0);
+  if (backends.length === 1) return backends[0];
   const config = await readProjxConfig(cwd);
-  if (config.primaryBackend === "fastapi" || config.primaryBackend === "fastify") {
+  if (config.primaryBackend === "fastapi" || config.primaryBackend === "fastify" || config.primaryBackend === "express") {
     return config.primaryBackend;
   }
-  if (!process.stdin.isTTY) return "fastify";
+  if (!process.stdin.isTTY) {
+    return hasFastify ? "fastify" : hasExpress ? "express" : "fastapi";
+  }
   const choice = await p9.select({
-    message: "Both backends detected. Which is your primary?",
+    message: "Multiple backends detected. Which is your primary?",
     options: [
-      { value: "fastify", label: "fastify (API backend)" },
-      { value: "fastapi", label: "fastapi (AI/ML engine)" }
+      ...hasFastify ? [{ value: "fastify", label: "fastify (API backend)" }] : [],
+      ...hasExpress ? [{ value: "express", label: "express (API backend)" }] : [],
+      ...hasFastapi ? [{ value: "fastapi", label: "fastapi (AI/ML engine)" }] : []
     ],
-    initialValue: "fastify"
+    initialValue: hasFastify ? "fastify" : hasExpress ? "express" : "fastapi"
   });
   if (p9.isCancel(choice)) process.exit(0);
   await writeProjxConfig(cwd, { ...config, primaryBackend: choice });
   p9.log.success(`Saved primaryBackend: ${choice} to .projx`);
   return choice;
 }
-async function gen(cwd, entityName, fieldsFlag, backendFlag) {
+async function gen(cwd, entityName, fieldsFlag, backendFlag, localRepo) {
   p9.intro(`projx gen entity ${entityName}`);
-  if (!existsSync9(join9(cwd, ".projx"))) {
+  if (!existsSync10(join10(cwd, ".projx"))) {
     p9.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
   const projxData = await readProjxConfig(cwd);
   const pmName = projxData.packageManager ?? "npm";
   const pm = pmCommands(pmName);
+  const orm = projxData.orm ?? "prisma";
+  const needsAddon = orm === "drizzle" || orm === "sequelize" || orm === "typeorm";
+  const repoDir = needsAddon ? await downloadRepo(localRepo).catch((err) => {
+    p9.cancel(`Failed to fetch templates: ${err.message}`);
+    process.exit(1);
+  }) : "";
+  const isLocal = Boolean(localRepo);
+  try {
+    return await runGen({
+      cwd,
+      entityName,
+      fieldsFlag,
+      backendFlag,
+      pm,
+      orm,
+      repoDir
+    });
+  } finally {
+    if (needsAddon && repoDir) {
+      await cleanupRepo(repoDir, isLocal);
+    }
+  }
+}
+async function runGen(opts) {
+  const { cwd, entityName, fieldsFlag, backendFlag, pm, orm, repoDir } = opts;
   const { components: discovered, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
   const hasFastapi = discovered.includes("fastapi");
   const hasFastify = discovered.includes("fastify");
+  const hasExpress = discovered.includes("express");
   const hasFrontend = discovered.includes("frontend");
   const hasMobile = discovered.includes("mobile");
-  if (!hasFastapi && !hasFastify) {
-    p9.log.error("No backend component found. Need fastapi or fastify.");
+  if (!hasFastapi && !hasFastify && !hasExpress) {
+    p9.log.error(
+      "No backend component found. Need fastapi, fastify, or express."
+    );
     process.exit(1);
   }
   const targetBackend = await resolvePrimaryBackend(
     cwd,
     hasFastapi,
     hasFastify,
+    hasExpress,
     backendFlag
   );
   const genFastapi = targetBackend === "fastapi" && hasFastapi;
   const genFastify = targetBackend === "fastify" && hasFastify;
+  const genExpress = targetBackend === "express" && hasExpress;
+  const genDrizzle = orm === "drizzle" && (genFastify || genExpress);
+  const genSequelize = orm === "sequelize" && (genFastify || genExpress);
+  const genTypeorm = orm === "typeorm" && (genFastify || genExpress);
   let config;
   if (fieldsFlag) {
     const fields = parseFieldsFlag(fieldsFlag);
@@ -2658,53 +3780,140 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
   const generated = [];
   if (genFastapi) {
     const dir = componentPaths.fastapi;
-    const entityDir = join9(cwd, dir, "src/entities", toSnake(config.name));
-    if (existsSync9(entityDir)) {
+    const entityDir = join10(cwd, dir, "src/entities", toSnake(config.name));
+    if (existsSync10(entityDir)) {
       p9.log.warn(
         `${dir}/src/entities/${toSnake(config.name)}/ already exists. Skipping FastAPI.`
       );
     } else {
       await mkdir3(entityDir, { recursive: true });
-      await writeFile(
-        join9(entityDir, "_model.py"),
+      await writeFile2(
+        join10(entityDir, "_model.py"),
         generateFastAPIModel(config)
       );
-      await writeFile(
-        join9(entityDir, "__init__.py"),
+      await writeFile2(
+        join10(entityDir, "__init__.py"),
         "from ._model import *\n"
       );
       generated.push(`${dir}/src/entities/${toSnake(config.name)}/_model.py`);
       generated.push(`${dir}/src/entities/${toSnake(config.name)}/__init__.py`);
-      const testsDir = join9(cwd, dir, "tests");
-      const testFile = join9(testsDir, `test_${toSnake(config.name)}_entity.py`);
-      if (existsSync9(testsDir) && !existsSync9(testFile)) {
-        await writeFile(testFile, generateFastapiTest(config));
+      const testsDir = join10(cwd, dir, "tests");
+      const testFile = join10(testsDir, `test_${toSnake(config.name)}_entity.py`);
+      if (existsSync10(testsDir) && !existsSync10(testFile)) {
+        await writeFile2(testFile, generateFastapiTest(config));
         generated.push(`${dir}/tests/test_${toSnake(config.name)}_entity.py`);
       }
     }
   }
-  if (genFastify) {
+  if (genFastify && orm !== "drizzle" && orm !== "sequelize" && orm !== "typeorm") {
     const dir = componentPaths.fastify;
-    const moduleDir = join9(cwd, dir, "src/modules", toKebab(config.name));
-    if (existsSync9(moduleDir)) {
+    const moduleDir = join10(cwd, dir, "src/modules", toKebab(config.name));
+    if (existsSync10(moduleDir)) {
       p9.log.warn(
         `${dir}/src/modules/${toKebab(config.name)}/ already exists. Skipping Fastify.`
       );
     } else {
       await mkdir3(moduleDir, { recursive: true });
-      await writeFile(
-        join9(moduleDir, "schemas.ts"),
+      await writeFile2(
+        join10(moduleDir, "schemas.ts"),
         generateFastifySchemas(config)
       );
-      await writeFile(
-        join9(moduleDir, "index.ts"),
+      await writeFile2(
+        join10(moduleDir, "index.ts"),
         generateFastifyIndex(config)
       );
       generated.push(`${dir}/src/modules/${toKebab(config.name)}/schemas.ts`);
       generated.push(`${dir}/src/modules/${toKebab(config.name)}/index.ts`);
-      const appPath = join9(cwd, dir, "src/app.ts");
-      if (existsSync9(appPath)) {
-        const appContent = await readFile6(appPath, "utf-8");
+      const appPath = join10(cwd, dir, "src/app.ts");
+      if (existsSync10(appPath)) {
+        const appContent = await readFile7(appPath, "utf-8");
+        const importLine = `import './modules/${toKebab(config.name)}/index.js';`;
+        if (!appContent.includes(importLine)) {
+          const updated = appContent.replace(
+            /^(import\s+'\.\/modules\/.*?';?\s*\n)/m,
+            `$1${importLine}
+`
+          );
+          if (updated !== appContent) {
+            await writeFile2(appPath, updated);
+            generated.push(`${dir}/src/app.ts (import added)`);
+          }
+        }
+      }
+      const prismaPath = join10(cwd, dir, "prisma/schema.prisma");
+      if (existsSync10(prismaPath)) {
+        const prismaContent = await readFile7(prismaPath, "utf-8");
+        const modelName = `model ${toPascal(config.name)}`;
+        if (!prismaContent.includes(modelName)) {
+          const prismaModel = generatePrismaModel(config);
+          await writeFile2(
+            prismaPath,
+            prismaContent.trimEnd() + "\n\n" + prismaModel + "\n"
+          );
+          generated.push(`${dir}/prisma/schema.prisma (model added)`);
+        }
+      }
+      const testsModulesDir = join10(cwd, dir, "tests/modules");
+      const fastifyTestFile = join10(
+        testsModulesDir,
+        `${toKebab(config.name)}.test.ts`
+      );
+      if (existsSync10(testsModulesDir) && !existsSync10(fastifyTestFile)) {
+        await writeFile2(fastifyTestFile, generateFastifyTest(config));
+        generated.push(`${dir}/tests/modules/${toKebab(config.name)}.test.ts`);
+      }
+    }
+  }
+  if (genFastify && orm === "drizzle") {
+    await appendDrizzleEntity(
+      repoDir,
+      cwd,
+      componentPaths.fastify,
+      "fastify",
+      config,
+      generated
+    );
+  } else if (genFastify && orm === "sequelize") {
+    await appendSequelizeEntity(
+      repoDir,
+      cwd,
+      componentPaths.fastify,
+      "fastify",
+      config,
+      generated
+    );
+  } else if (genFastify && orm === "typeorm") {
+    await appendTypeormEntity(
+      repoDir,
+      cwd,
+      componentPaths.fastify,
+      "fastify",
+      config,
+      generated
+    );
+  }
+  if (genExpress && orm !== "drizzle" && orm !== "sequelize" && orm !== "typeorm") {
+    const dir = componentPaths.express;
+    const moduleDir = join10(cwd, dir, "src/modules", toKebab(config.name));
+    if (existsSync10(moduleDir)) {
+      p9.log.warn(
+        `${dir}/src/modules/${toKebab(config.name)}/ already exists. Skipping Express.`
+      );
+    } else {
+      await mkdir3(moduleDir, { recursive: true });
+      await writeFile2(
+        join10(moduleDir, "schemas.ts"),
+        generateExpressSchemas(config)
+      );
+      await writeFile2(
+        join10(moduleDir, "index.ts"),
+        generateExpressIndex(config)
+      );
+      generated.push(`${dir}/src/modules/${toKebab(config.name)}/schemas.ts`);
+      generated.push(`${dir}/src/modules/${toKebab(config.name)}/index.ts`);
+      const appPath = join10(cwd, dir, "src/app.ts");
+      if (existsSync10(appPath)) {
+        const appContent = await readFile7(appPath, "utf-8");
         const importLine = `import './modules/${toKebab(config.name)}/index.js';`;
         if (!appContent.includes(importLine)) {
           const updated = appContent.replace(
@@ -2713,75 +3922,103 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
 `
           );
           if (updated !== appContent) {
-            await writeFile(appPath, updated);
+            await writeFile2(appPath, updated);
             generated.push(`${dir}/src/app.ts (import added)`);
           }
         }
       }
-      const prismaPath = join9(cwd, dir, "prisma/schema.prisma");
-      if (existsSync9(prismaPath)) {
-        const prismaContent = await readFile6(prismaPath, "utf-8");
+      const prismaPath = join10(cwd, dir, "prisma/schema.prisma");
+      if (existsSync10(prismaPath)) {
+        const prismaContent = await readFile7(prismaPath, "utf-8");
         const modelName = `model ${toPascal(config.name)}`;
         if (!prismaContent.includes(modelName)) {
           const prismaModel = generatePrismaModel(config);
-          await writeFile(
+          await writeFile2(
             prismaPath,
             prismaContent.trimEnd() + "\n\n" + prismaModel + "\n"
           );
           generated.push(`${dir}/prisma/schema.prisma (model added)`);
         }
       }
-      const testsModulesDir = join9(cwd, dir, "tests/modules");
-      const fastifyTestFile = join9(
+      const testsModulesDir = join10(cwd, dir, "tests/modules");
+      const expressTestFile = join10(
         testsModulesDir,
         `${toKebab(config.name)}.test.ts`
       );
-      if (existsSync9(testsModulesDir) && !existsSync9(fastifyTestFile)) {
-        await writeFile(fastifyTestFile, generateFastifyTest(config));
+      if (existsSync10(testsModulesDir) && !existsSync10(expressTestFile)) {
+        await writeFile2(expressTestFile, generateExpressTest(config));
         generated.push(`${dir}/tests/modules/${toKebab(config.name)}.test.ts`);
       }
     }
   }
+  if (genExpress && orm === "drizzle") {
+    await appendDrizzleEntity(
+      repoDir,
+      cwd,
+      componentPaths.express,
+      "express",
+      config,
+      generated
+    );
+  } else if (genExpress && orm === "sequelize") {
+    await appendSequelizeEntity(
+      repoDir,
+      cwd,
+      componentPaths.express,
+      "express",
+      config,
+      generated
+    );
+  } else if (genExpress && orm === "typeorm") {
+    await appendTypeormEntity(
+      repoDir,
+      cwd,
+      componentPaths.express,
+      "express",
+      config,
+      generated
+    );
+  }
   if (hasFrontend) {
     const dir = componentPaths.frontend;
-    const typesDir = join9(cwd, dir, "src/types");
+    const typesDir = join10(cwd, dir, "src/types");
     const fileName = toKebab(config.name) + ".ts";
-    const filePath = join9(typesDir, fileName);
-    if (existsSync9(filePath)) {
+    const filePath = join10(typesDir, fileName);
+    if (existsSync10(filePath)) {
       p9.log.warn(
         `${dir}/src/types/${fileName} already exists. Skipping frontend types.`
       );
     } else {
       await mkdir3(typesDir, { recursive: true });
-      await writeFile(filePath, generateFrontendInterface(config));
+      await writeFile2(filePath, generateFrontendInterface(config));
       generated.push(`${dir}/src/types/${fileName}`);
-      const barrelPath = join9(typesDir, "index.ts");
+      const barrelPath = join10(typesDir, "index.ts");
       const exportLine = `export * from './${toKebab(config.name)}';`;
-      if (existsSync9(barrelPath)) {
-        const content = await readFile6(barrelPath, "utf-8");
+      if (existsSync10(barrelPath)) {
+        const content = await readFile7(barrelPath, "utf-8");
         if (!content.includes(exportLine)) {
-          await writeFile(
+          await writeFile2(
             barrelPath,
             content.trimEnd() + "\n" + exportLine + "\n"
           );
         }
       } else {
-        await writeFile(barrelPath, exportLine + "\n");
+        await writeFile2(barrelPath, exportLine + "\n");
       }
       generated.push(`${dir}/src/types/index.ts`);
     }
   }
   if (hasMobile) {
     const dir = componentPaths.mobile;
-    const entityDir = join9(cwd, dir, "lib/entities", toSnake(config.name));
-    const modelPath = join9(entityDir, "model.dart");
-    if (existsSync9(modelPath)) {
+    const entityDir = join10(cwd, dir, "lib/entities", toSnake(config.name));
+    const modelPath = join10(entityDir, "model.dart");
+    if (existsSync10(modelPath)) {
       p9.log.warn(
         `${dir}/lib/entities/${toSnake(config.name)}/model.dart already exists. Skipping mobile model.`
       );
     } else {
       await mkdir3(entityDir, { recursive: true });
-      await writeFile(modelPath, generateDartModel(config));
+      await writeFile2(modelPath, generateDartModel(config));
       generated.push(`${dir}/lib/entities/${toSnake(config.name)}/model.dart`);
     }
   }
@@ -2803,13 +4040,33 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
     );
     p9.log.info("  alembic upgrade head");
   }
-  if (genFastify) {
+  if (genFastify && orm === "prisma") {
     p9.log.info("");
     p9.log.info("Fastify next steps:");
     p9.log.info(
       `  ${pm.prismaExec} migrate dev --name add_${toSnake(config.name)}`
     );
   }
+  if (genDrizzle) {
+    p9.log.info("");
+    p9.log.info("Drizzle next steps:");
+    p9.log.info(`  ${pm.exec} drizzle-kit generate`);
+    p9.log.info(`  ${pm.exec} drizzle-kit migrate`);
+  }
+  if (genSequelize) {
+    p9.log.info("");
+    p9.log.info("Sequelize next steps:");
+    p9.log.info(
+      `  ${pm.run} db:sync   # syncs the schema against $DATABASE_URL`
+    );
+  }
+  if (genTypeorm) {
+    p9.log.info("");
+    p9.log.info("TypeORM next steps:");
+    p9.log.info(
+      `  ${pm.run} db:sync   # syncs the schema against $DATABASE_URL`
+    );
+  }
   if (hasFrontend) {
     p9.log.info("");
     p9.log.info("Frontend usage:");
@@ -2828,295 +4085,30 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
   p9.outro(`Entity ${className} created.`);
 }
 
-// src/sync.ts
-import { existsSync as existsSync10, readFileSync } from "fs";
-import { writeFile as writeFile2, mkdir as mkdir4 } from "fs/promises";
-import { join as join10 } from "path";
-import * as p10 from "@clack/prompts";
-function toPascal2(s) {
-  return s.replace(/(?:^|[_\-\s])([a-zA-Z])/g, (_, c) => c.toUpperCase());
-}
-function toCamel2(s) {
-  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-}
-function metaTypeToTs(type, fieldType, nullable) {
-  const base = (() => {
-    switch (type) {
-      case "str":
-        return "string";
-      case "int":
-      case "float":
-        return "number";
-      case "bool":
-        return "boolean";
-      case "datetime":
-      case "date":
-        return "string";
-      case "dict":
-        return "Record<string, unknown>";
-      default:
-        return "unknown";
-    }
-  })();
-  return nullable ? `${base} | null` : base;
-}
-function metaTypeToDart(type, nullable) {
-  const base = (() => {
-    switch (type) {
-      case "str":
-        return "String";
-      case "int":
-        return "int";
-      case "float":
-        return "double";
-      case "bool":
-        return "bool";
-      case "datetime":
-      case "date":
-        return "DateTime";
-      case "dict":
-        return "Map<String, dynamic>";
-      default:
-        return "dynamic";
-    }
-  })();
-  return nullable ? `${base}?` : base;
-}
-function dartFromJsonExpr(key, type, nullable) {
-  const accessor = `json['${key}']`;
-  const isDate = type === "datetime" || type === "date";
-  if (isDate && nullable)
-    return `${accessor} != null ? DateTime.parse(${accessor} as String) : null`;
-  if (isDate) return `DateTime.parse(${accessor} as String)`;
-  if (type === "dict" && nullable)
-    return `${accessor} as Map<String, dynamic>?`;
-  if (type === "dict") return `${accessor} as Map<String, dynamic>`;
-  const dartT = (() => {
-    switch (type) {
-      case "str":
-        return "String";
-      case "int":
-        return "int";
-      case "float":
-        return "double";
-      case "bool":
-        return "bool";
-      default:
-        return "dynamic";
-    }
-  })();
-  return nullable ? `${accessor} as ${dartT}?` : `${accessor} as ${dartT}`;
-}
-function dartToJsonExpr(key, camel, type) {
-  const isDate = type === "datetime" || type === "date";
-  if (isDate) return `'${key}': ${camel}?.toIso8601String()`;
-  return `'${key}': ${camel}`;
-}
-function generateTsInterface(entity) {
-  const className = toPascal2(entity.name);
-  const lines = [];
-  lines.push(`export interface ${className} {`);
-  for (const f of entity.fields) {
-    lines.push(
-      `  ${f.key}: ${metaTypeToTs(f.type, f.field_type, f.nullable)};`
-    );
-  }
-  lines.push(`}`);
-  lines.push("");
-  const createFields = entity.fields.filter((f) => f.in_create);
-  lines.push(`export interface Create${className} {`);
-  for (const f of createFields) {
-    const optional = f.nullable ? "?" : "";
-    lines.push(
-      `  ${f.key}${optional}: ${metaTypeToTs(f.type, f.field_type, f.nullable)};`
-    );
-  }
-  lines.push(`}`);
-  lines.push("");
-  const updateFields = entity.fields.filter((f) => f.in_update);
-  lines.push(`export interface Update${className} {`);
-  for (const f of updateFields) {
-    lines.push(`  ${f.key}?: ${metaTypeToTs(f.type, f.field_type, true)};`);
-  }
-  lines.push(`}`);
-  lines.push("");
-  return lines.join("\n");
-}
-function generateDartModel2(entity) {
-  const className = toPascal2(entity.name);
-  const lines = [];
-  const fields = entity.fields.map((f) => ({
-    snake: f.key,
-    camel: toCamel2(f.key),
-    type: metaTypeToDart(f.type, f.nullable),
-    nullable: f.nullable,
-    metaType: f.type
-  }));
-  lines.push(`class ${className} {`);
-  for (const f of fields) {
-    lines.push(`  final ${f.type} ${f.camel};`);
-  }
-  lines.push("");
-  lines.push(`  const ${className}({`);
-  for (const f of fields) {
-    if (f.nullable) {
-      lines.push(`    this.${f.camel},`);
-    } else {
-      lines.push(`    required this.${f.camel},`);
-    }
-  }
-  lines.push(`  });`);
-  lines.push("");
-  lines.push(`  factory ${className}.fromJson(Map<String, dynamic> json) {`);
-  lines.push(`    return ${className}(`);
-  for (const f of fields) {
-    lines.push(
-      `      ${f.camel}: ${dartFromJsonExpr(f.snake, f.metaType, f.nullable)},`
-    );
-  }
-  lines.push(`    );`);
-  lines.push(`  }`);
-  lines.push("");
-  lines.push(`  Map<String, dynamic> toJson() {`);
-  lines.push(`    return {`);
-  for (const f of fields) {
-    lines.push(`      ${dartToJsonExpr(f.snake, f.camel, f.metaType)},`);
-  }
-  lines.push(`    };`);
-  lines.push(`  }`);
-  lines.push("");
-  lines.push(`  ${className} copyWith({`);
-  for (const f of fields) {
-    lines.push(`    ${f.type.replace("?", "")}? ${f.camel},`);
-  }
-  lines.push(`  }) {`);
-  lines.push(`    return ${className}(`);
-  for (const f of fields) {
-    lines.push(`      ${f.camel}: ${f.camel} ?? this.${f.camel},`);
-  }
-  lines.push(`    );`);
-  lines.push(`  }`);
-  lines.push(`}`);
-  lines.push("");
-  return lines.join("\n");
-}
-async function sync(cwd, url) {
-  p10.intro("projx sync");
-  const configPath = join10(cwd, ".projx");
-  if (!existsSync10(configPath)) {
-    p10.log.error("No .projx file found. Run 'npx create-projx init' first.");
-    process.exit(1);
-  }
-  const { components: discovered, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
-  const hasFrontend = discovered.includes("frontend");
-  const hasMobile = discovered.includes("mobile");
-  if (!hasFrontend && !hasMobile) {
-    p10.log.error("No frontend or mobile component found. Nothing to sync.");
-    process.exit(1);
-  }
-  const metaUrl = url || detectMetaUrl(cwd);
-  const spinner7 = p10.spinner();
-  spinner7.start(`Fetching metadata from ${metaUrl}`);
-  let meta;
-  try {
-    const res = await fetch(metaUrl);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    meta = await res.json();
-  } catch (err) {
-    spinner7.stop("Failed.");
-    p10.log.error(`Could not fetch ${metaUrl}: ${err}`);
-    p10.log.info("Make sure your backend is running.");
-    p10.log.info(
-      "Or specify URL: projx sync --url http://localhost:8000/api/v1/_meta"
-    );
-    process.exit(1);
-  }
-  spinner7.stop(`Fetched ${meta.entities.length} entity(s).`);
-  const generated = [];
-  if (hasFrontend) {
-    const dir = componentPaths.frontend;
-    const typesDir = join10(cwd, dir, "src/types");
-    await mkdir4(typesDir, { recursive: true });
-    const barrelExports = [];
-    for (const entity of meta.entities) {
-      const fileName = toKebab(toSnake(entity.name)) + ".ts";
-      const filePath = join10(typesDir, fileName);
-      await writeFile2(filePath, generateTsInterface(entity));
-      generated.push(`${dir}/src/types/${fileName}`);
-      barrelExports.push(`export * from './${toKebab(toSnake(entity.name))}';`);
-    }
-    await writeFile2(
-      join10(typesDir, "index.ts"),
-      barrelExports.join("\n") + "\n"
-    );
-    generated.push(`${dir}/src/types/index.ts`);
-  }
-  if (hasMobile) {
-    const dir = componentPaths.mobile;
-    for (const entity of meta.entities) {
-      const entityDir = join10(cwd, dir, "lib/entities", toSnake(entity.name));
-      await mkdir4(entityDir, { recursive: true });
-      const modelPath = join10(entityDir, "model.dart");
-      await writeFile2(modelPath, generateDartModel2(entity));
-      generated.push(`${dir}/lib/entities/${toSnake(entity.name)}/model.dart`);
-    }
-  }
-  p10.log.success(`Synced ${meta.entities.length} entity(s):`);
-  for (const f of generated) {
-    p10.log.info(`  ${f}`);
-  }
-  if (hasFrontend) {
-    p10.log.info("");
-    p10.log.info("Frontend usage:");
-    for (const entity of meta.entities) {
-      const className = toPascal2(entity.name);
-      p10.log.info(
-        `  import type { ${className} } from '../types/${toKebab(toSnake(entity.name))}';`
-      );
-    }
-  }
-  p10.outro("Types are up to date.");
-}
-function detectMetaUrl(cwd) {
-  const envFiles = [".env", ".env.dev", ".env.local"];
-  for (const envFile of envFiles) {
-    const envPath = join10(cwd, envFile);
-    if (existsSync10(envPath)) {
-      try {
-        const content = readFileSync(envPath, "utf-8");
-        const match = content.match(/VITE_API_URL\s*=\s*(.+)/);
-        if (match) {
-          const base = match[1].trim().replace(/["']/g, "");
-          return `${base}/api/v1/_meta`;
-        }
-      } catch {
-      }
+// src/index.ts
+var args = process.argv.slice(2);
+function matchFeatureFlag(arg, argv, i) {
+  for (const feat of KNOWN_FEATURES) {
+    const eq = `--${feat}=`;
+    if (arg.startsWith(eq)) {
+      return {
+        feature: feat,
+        value: arg.slice(eq.length),
+        consumedNext: false
+      };
     }
-  }
-  const frontendEnvFiles = [
-    "frontend/.env",
-    "frontend/.env.local",
-    "frontend/.env.dev"
-  ];
-  for (const envFile of frontendEnvFiles) {
-    const envPath = join10(cwd, envFile);
-    if (existsSync10(envPath)) {
-      try {
-        const content = readFileSync(envPath, "utf-8");
-        const match = content.match(/VITE_API_URL\s*=\s*(.+)/);
-        if (match) {
-          const base = match[1].trim().replace(/["']/g, "");
-          return `${base}/api/v1/_meta`;
-        }
-      } catch {
+    if (arg === `--${feat}`) {
+      const next = argv[i + 1];
+      if (!next || next.startsWith("-")) {
+        throw new Error(
+          `Flag --${feat} requires a value. Use --${feat}=<targets> or --${feat} <targets>.`
+        );
       }
+      return { feature: feat, value: next, consumedNext: true };
     }
   }
-  return "http://localhost:8000/api/v1/_meta";
+  return null;
 }
-
-// src/index.ts
-var args = process.argv.slice(2);
 function parseArgs() {
   let command = "create";
   let name;
@@ -3158,10 +4150,6 @@ function parseArgs() {
       command = "gen";
       continue;
     }
-    if (arg === "sync" && !name) {
-      command = "sync";
-      continue;
-    }
     if (arg === "--components") {
       const val = args[++i];
       if (val) {
@@ -3169,6 +4157,16 @@ function parseArgs() {
       }
       continue;
     }
+    if (arg === "--orm") {
+      const val = args[++i];
+      if (!val || !ORM_PROVIDERS.includes(val)) {
+        throw new Error(
+          `Invalid --orm. Use one of: ${ORM_PROVIDERS.join(", ")}`
+        );
+      }
+      options.orm = val;
+      continue;
+    }
     if (arg === "--local") {
       localRepo = resolve(args[++i] || ".");
       continue;
@@ -3201,11 +4199,6 @@ function parseArgs() {
       flags.backend = true;
       continue;
     }
-    if (arg === "--url") {
-      const val = args[++i];
-      if (val) extraArgs.push(`--url=${val}`);
-      continue;
-    }
     if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
@@ -3220,6 +4213,16 @@ function parseArgs() {
       if (val) extraArgs.push(`--name=${val}`);
       continue;
     }
+    {
+      const featureMatch = matchFeatureFlag(arg, args, i);
+      if (featureMatch) {
+        const { feature, value, consumedNext } = featureMatch;
+        parseFeatureFlag(value);
+        options.features = { ...options.features ?? {}, [feature]: value };
+        if (consumedNext) i++;
+        continue;
+      }
+    }
     if (!arg.startsWith("-")) {
       if (command === "add" || command === "pin" || command === "unpin" || command === "gen") {
         extraArgs.push(arg);
@@ -3244,10 +4247,11 @@ function printHelp() {
     projx pin --list              Show all skip patterns
     projx doctor [--fix]          Health check for projx project
     projx gen entity <name>       Generate a new entity
-    projx sync [--url <url>]      Sync types from running backend
 
   Options:
-    --components <list>  Comma-separated: fastapi,fastify,frontend,mobile,e2e,infra
+    --components <list>  Comma-separated: fastapi,fastify,express,frontend,mobile,e2e,infra
+    --orm <provider>     Node backend ORM: prisma (default), drizzle, sequelize, typeorm
+    --auth <targets>     Add auth feature. Targets: <component>[:<instance>] (comma-separated)
     --no-git             Skip git init
     --no-install         Skip dependency installation
     -y, --yes            Accept defaults (fastify + frontend + e2e)
@@ -3257,6 +4261,8 @@ function printHelp() {
   Examples:
     npx create-projx my-app
     npx create-projx my-app --components fastapi,frontend,e2e
+    npx create-projx my-app --components express,frontend,e2e --orm drizzle
+    npx create-projx my-app --components fastify,frontend,mobile --auth fastify
     npx create-projx my-app -y
     npx create-projx add frontend mobile
     npx create-projx add fastify --name email-ingestor
@@ -3330,12 +4336,6 @@ async function main() {
     await doctor(process.cwd(), flags.fix);
     return;
   }
-  if (command === "sync") {
-    const urlArg = extraArgs.find((a) => a.startsWith("--url="));
-    const url = urlArg ? urlArg.split("=").slice(1).join("=") : void 0;
-    await sync(process.cwd(), url);
-    return;
-  }
   if (command === "gen") {
     const subcommand = extraArgs[0];
     if (subcommand !== "entity" || !extraArgs[1]) {
@@ -3348,7 +4348,7 @@ async function main() {
     const fieldsArg = extraArgs.find((a) => a.startsWith("--fields="));
     const fieldsFlag = fieldsArg ? fieldsArg.split("=").slice(1).join("=") : void 0;
     const backendFlag = flags.ai ? "fastapi" : flags.backend ? "fastify" : void 0;
-    await gen(process.cwd(), entityName, fieldsFlag, backendFlag);
+    await gen(process.cwd(), entityName, fieldsFlag, backendFlag, localRepo);
     return;
   }
   let opts;
@@ -3361,12 +4361,16 @@ async function main() {
       name,
       components: options.components,
       git: options.git ?? true,
-      install: options.install ?? true
+      install: options.install ?? true,
+      orm: options.orm ?? "prisma",
+      features: options.features
     };
   } else {
     opts = await runPrompts(name);
     opts.git = options.git ?? opts.git;
     opts.install = options.install ?? opts.install;
+    opts.orm = options.orm ?? opts.orm ?? "prisma";
+    opts.features = options.features ?? opts.features;
   }
   const dest = resolve(process.cwd(), opts.name);
   if (existsSync11(dest)) {