@dereekb/dbx-cli 13.11.0 → 13.11.2

package/firebase-api-manifest/main.js

@@ -0,0 +1,711 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/main.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "node:fs";
+import { dirname as dirname3, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve3 } from "node:path";
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/parse-functions.ts
+import { readFileSync } from "node:fs";
+import { Node, Project } from "ts-morph";
+function parseFunctionsConfig(functionsTsPath) {
+  const project = new Project({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  const text = readFileSync(functionsTsPath, "utf8");
+  const sourceFile = project.createSourceFile("functions.ts", text, { overwrite: true });
+  const importIdentToModule = collectImportSpecifierMap(sourceFile);
+  const result = [];
+  for (const variable of sourceFile.getVariableDeclarations()) {
+    const initializer = readFunctionsConfigInitializer(variable);
+    if (initializer) collectGroupsFromConfig(initializer, importIdentToModule, result);
+  }
+  return result;
+}
+function readFunctionsConfigInitializer(variable) {
+  let result;
+  if (isFunctionsConfigVariable(variable)) {
+    const initializer = variable.getInitializer();
+    if (initializer && Node.isObjectLiteralExpression(initializer)) result = initializer;
+  }
+  return result;
+}
+function collectGroupsFromConfig(initializer, importIdentToModule, sink) {
+  for (const property of initializer.getProperties()) {
+    const group = readGroupFromProperty(property, importIdentToModule);
+    if (group) sink.push(group);
+  }
+}
+function readGroupFromProperty(property, importIdentToModule) {
+  if (!Node.isPropertyAssignment(property)) return void 0;
+  const valueExpr = property.getInitializer();
+  if (!valueExpr || !Node.isArrayLiteralExpression(valueExpr)) return void 0;
+  const first = valueExpr.getElements()[0];
+  if (!first || !Node.isIdentifier(first)) return void 0;
+  const className = first.getText();
+  const importedFromModule = importIdentToModule.get(className);
+  if (!importedFromModule) return void 0;
+  return { groupKey: property.getName(), className, importedFromModule };
+}
+function isFunctionsConfigVariable(variable) {
+  const name = variable.getName();
+  return name.endsWith("FIREBASE_FUNCTIONS_CONFIG");
+}
+function collectImportSpecifierMap(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = decl.getModuleSpecifierValue();
+    for (const named of decl.getNamedImports()) {
+      const localName = named.getAliasNode()?.getText() ?? named.getName();
+      map.set(localName, moduleSpecifier);
+    }
+  }
+  return map;
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/resolve-package.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+var _pathsCache;
+function loadTsconfigPaths(workspaceRoot) {
+  if (_pathsCache) return _pathsCache;
+  const tsconfigPath = join(workspaceRoot, "tsconfig.base.json");
+  const raw = readFileSync2(tsconfigPath, "utf8");
+  const cleaned = stripJsonComments(raw);
+  const tsconfig = JSON.parse(cleaned);
+  const paths = tsconfig.compilerOptions?.paths ?? {};
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(paths)) {
+    if (Array.isArray(value) && value[0]) {
+      map.set(key, resolve(workspaceRoot, value[0]));
+    }
+  }
+  _pathsCache = map;
+  return map;
+}
+function resolveModuleToPackage(input) {
+  const { workspaceRoot, importingFile, moduleSpecifier } = input;
+  if (moduleSpecifier.startsWith(".")) {
+    const importingDir = dirname(importingFile);
+    const candidatePath = resolve(importingDir, moduleSpecifier);
+    return locatePackageForPath(workspaceRoot, candidatePath);
+  }
+  const paths = loadTsconfigPaths(workspaceRoot);
+  const indexFile = paths.get(moduleSpecifier);
+  if (indexFile) return locatePackageForPath(workspaceRoot, indexFile);
+  return locatePackageInNodeModules({ workspaceRoot, importingFile, moduleSpecifier });
+}
+function locatePackageInNodeModules(input) {
+  const { importingFile, moduleSpecifier } = input;
+  let current = dirname(importingFile);
+  while (current && current !== dirname(current)) {
+    const candidateRoot = join(current, "node_modules", moduleSpecifier);
+    const pkgJson = join(candidateRoot, "package.json");
+    if (existsSync(pkgJson)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgJson, "utf8"));
+        if (pkg.name) return { packageName: pkg.name, packageRoot: candidateRoot };
+      } catch {
+      }
+    }
+    current = dirname(current);
+  }
+  return void 0;
+}
+function locatePackageForPath(workspaceRoot, startPath) {
+  let current = startPath;
+  while (current && current !== workspaceRoot && current !== dirname(current)) {
+    if (existsSync(join(current, "package.json"))) {
+      try {
+        const pkg = JSON.parse(readFileSync2(join(current, "package.json"), "utf8"));
+        if (pkg.name) return { packageName: pkg.name, packageRoot: current };
+      } catch {
+      }
+    }
+    current = dirname(current);
+  }
+  return void 0;
+}
+function relPath(workspaceRoot, absolutePath) {
+  return relative(workspaceRoot, absolutePath).split("\\").join("/");
+}
+function stripJsonComments(text) {
+  return text.replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/^\s*\/\/.*$/gm, "");
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/find-api-files.ts
+import { readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// packages/dbx-cli/manifest-extract/src/lib/extract-crud.ts
+import { Node as Node2, Project as Project2 } from "ts-morph";
+var SUPPORTED_VERBS = /* @__PURE__ */ new Set(["create", "read", "update", "delete", "query"]);
+function extractCrudEntries(source) {
+  const project = new Project2({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  const sourceFile = project.createSourceFile(source.name, source.text, { overwrite: true });
+  const entries = [];
+  const modelKeys = [];
+  const crudConfigType = findTypeAliasByEnding(sourceFile, "ModelCrudFunctionsConfig");
+  const groupName = inferGroupName(sourceFile);
+  const functionsClassName = findFunctionsClassName(sourceFile);
+  const typeDocsCache = /* @__PURE__ */ new Map();
+  const resolveTypeDocs = (typeName) => {
+    if (!typeName) {
+      return void 0;
+    }
+    if (typeDocsCache.has(typeName)) {
+      return typeDocsCache.get(typeName);
+    }
+    const docs = readTypeDocs(sourceFile, typeName);
+    if (docs) {
+      typeDocsCache.set(typeName, docs);
+    }
+    return docs;
+  };
+  if (crudConfigType) {
+    const literal = crudConfigType.getTypeNode();
+    if (literal && Node2.isTypeLiteral(literal)) {
+      for (const member of literal.getMembers()) {
+        if (!Node2.isPropertySignature(member)) {
+          continue;
+        }
+        const modelName = member.getName();
+        modelKeys.push(modelName);
+        const valueNode = member.getTypeNode();
+        if (!valueNode) {
+          continue;
+        }
+        if (isNullLiteralType(valueNode)) {
+          continue;
+        }
+        if (Node2.isTypeLiteral(valueNode)) {
+          for (const verbMember of valueNode.getMembers()) {
+            if (!Node2.isPropertySignature(verbMember)) {
+              continue;
+            }
+            const verbName = verbMember.getName();
+            if (!SUPPORTED_VERBS.has(verbName)) {
+              continue;
+            }
+            const verb = verbName;
+            const verbValueNode = verbMember.getTypeNode();
+            if (!verbValueNode) {
+              continue;
+            }
+            collectVerbEntries({ modelName, verb, valueNode: verbValueNode, entries, fallbackDescription: readJsDocSummary(verbMember), resolveTypeDocs });
+          }
+        }
+      }
+    }
+  }
+  const functionTypeMap = findTypeAliasByEnding(sourceFile, "FunctionTypeMap");
+  if (functionTypeMap) {
+    const literal = functionTypeMap.getTypeNode();
+    if (literal && Node2.isTypeLiteral(literal)) {
+      for (const member of literal.getMembers()) {
+        if (!Node2.isPropertySignature(member)) {
+          continue;
+        }
+        const key = member.getName();
+        const valueNode = member.getTypeNode();
+        const tuple = valueNode ? readTupleParamsResult(valueNode) : void 0;
+        const paramsDocs = resolveTypeDocs(tuple?.params);
+        const resultDocs = resolveTypeDocs(tuple?.result);
+        entries.push({
+          model: key,
+          verb: "standalone",
+          specifier: void 0,
+          paramsTypeName: tuple?.params,
+          resultTypeName: tuple?.result,
+          line: member.getStartLineNumber(),
+          description: readJsDocSummary(member),
+          paramsTypeDescription: paramsDocs?.typeDescription,
+          paramsFields: paramsDocs?.fields,
+          resultTypeDescription: resultDocs?.typeDescription,
+          resultFields: resultDocs?.fields
+        });
+      }
+    }
+  }
+  return { groupName, modelKeys, entries, functionsClassName };
+}
+function findTypeAliasByEnding(sourceFile, ending) {
+  for (const alias of sourceFile.getTypeAliases()) {
+    if (alias.getName().endsWith(ending) && alias.getTypeNode()) {
+      return alias;
+    }
+  }
+  return void 0;
+}
+function findFunctionsClassName(sourceFile) {
+  for (const cls of sourceFile.getClasses()) {
+    if (!cls.isAbstract()) {
+      continue;
+    }
+    const name = cls.getName();
+    if (name?.endsWith("Functions")) {
+      return name;
+    }
+  }
+  return void 0;
+}
+function inferGroupName(sourceFile) {
+  for (const alias of sourceFile.getTypeAliases()) {
+    const name = alias.getName();
+    if (name.endsWith("ModelCrudFunctionsConfig")) {
+      const stem = name.slice(0, -"ModelCrudFunctionsConfig".length);
+      if (stem.length > 0) {
+        return stem;
+      }
+    }
+  }
+  for (const alias of sourceFile.getTypeAliases()) {
+    const name = alias.getName();
+    if (name.endsWith("FunctionTypeMap")) {
+      const stem = name.slice(0, -"FunctionTypeMap".length);
+      if (stem.length > 0) {
+        return stem;
+      }
+    }
+  }
+  return void 0;
+}
+function isNullLiteralType(node) {
+  if (Node2.isLiteralTypeNode(node)) {
+    const literal = node.getLiteral();
+    if (Node2.isNullLiteral(literal)) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectVerbEntries(input) {
+  const { modelName, verb, valueNode, entries, fallbackDescription, resolveTypeDocs } = input;
+  if (Node2.isTypeLiteral(valueNode)) {
+    for (const specMember of valueNode.getMembers()) {
+      if (!Node2.isPropertySignature(specMember)) {
+        continue;
+      }
+      const specifier = specMember.getName();
+      const leafNode = specMember.getTypeNode();
+      const leaf2 = leafNode ? readTupleParamsResult(leafNode) ?? readBareParams(leafNode) : void 0;
+      const paramsDocs2 = resolveTypeDocs(leaf2?.params);
+      const resultDocs2 = resolveTypeDocs(leaf2?.result);
+      entries.push({
+        model: modelName,
+        verb,
+        specifier,
+        paramsTypeName: leaf2?.params,
+        resultTypeName: leaf2?.result,
+        line: specMember.getStartLineNumber(),
+        description: readJsDocSummary(specMember),
+        paramsTypeDescription: paramsDocs2?.typeDescription,
+        paramsFields: paramsDocs2?.fields,
+        resultTypeDescription: resultDocs2?.typeDescription,
+        resultFields: resultDocs2?.fields
+      });
+    }
+    return;
+  }
+  const leaf = readTupleParamsResult(valueNode) ?? readBareParams(valueNode);
+  const paramsDocs = resolveTypeDocs(leaf?.params);
+  const resultDocs = resolveTypeDocs(leaf?.result);
+  entries.push({
+    model: modelName,
+    verb,
+    specifier: void 0,
+    paramsTypeName: leaf?.params,
+    resultTypeName: leaf?.result,
+    line: valueNode.getStartLineNumber(),
+    description: fallbackDescription,
+    paramsTypeDescription: paramsDocs?.typeDescription,
+    paramsFields: paramsDocs?.fields,
+    resultTypeDescription: resultDocs?.typeDescription,
+    resultFields: resultDocs?.fields
+  });
+}
+function readTupleParamsResult(node) {
+  if (!Node2.isTupleTypeNode(node)) {
+    return void 0;
+  }
+  const elements = node.getElements();
+  if (elements.length === 0) {
+    return void 0;
+  }
+  const params = elements[0] ? typeNodeName(elements[0]) : void 0;
+  const result = elements[1] ? typeNodeName(elements[1]) : void 0;
+  return { params, result };
+}
+function readBareParams(node) {
+  const params = typeNodeName(node);
+  if (!params) {
+    return void 0;
+  }
+  return { params, result: void 0 };
+}
+function typeNodeName(node) {
+  if (Node2.isTypeReference(node)) {
+    return node.getTypeName().getText();
+  }
+  const text = node.getText().trim();
+  return text.length > 0 ? text : void 0;
+}
+function readTypeDocs(sourceFile, typeName) {
+  const interfaceDecl = sourceFile.getInterface(typeName);
+  if (interfaceDecl) {
+    const typeDescription = readJsDocSummary(interfaceDecl);
+    const fields = [];
+    for (const property of interfaceDecl.getProperties()) {
+      const fieldName = property.getName();
+      const description = readJsDocSummary(property);
+      const typeNode = property.getTypeNode();
+      const typeText = typeNode?.getText().trim() ?? "";
+      const field = description ? { name: fieldName, typeText, description } : { name: fieldName, typeText };
+      fields.push(field);
+    }
+    if (!typeDescription && fields.length === 0) {
+      return void 0;
+    }
+    return { typeDescription, fields: fields.length > 0 ? fields : void 0 };
+  }
+  const typeAlias = sourceFile.getTypeAlias(typeName);
+  if (typeAlias) {
+    const typeDescription = readJsDocSummary(typeAlias);
+    return typeDescription ? { typeDescription } : void 0;
+  }
+  return void 0;
+}
+function readJsDocSummary(node) {
+  const docs = node.getJsDocs();
+  if (docs.length === 0) {
+    return void 0;
+  }
+  const last = docs[docs.length - 1];
+  const description = last.getDescription().trim();
+  return description.length > 0 ? description : void 0;
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/find-api-files.ts
+function findApiFiles(packageRoot) {
+  const libRoot = join2(packageRoot, "src", "lib");
+  if (!safeIsDirectory(libRoot)) return [];
+  const out = [];
+  const seenClassNames = /* @__PURE__ */ new Set();
+  for (const file of walkApiFiles(libRoot)) {
+    const text = readFileSync3(file, "utf8");
+    const extraction = extractCrudEntries({ name: file, text });
+    if (!extraction.functionsClassName) continue;
+    if (seenClassNames.has(extraction.functionsClassName)) continue;
+    seenClassNames.add(extraction.functionsClassName);
+    out.push({ filePath: file, className: extraction.functionsClassName, extraction });
+  }
+  return out;
+}
+function* walkApiFiles(dir) {
+  for (const entry of readdirSync(dir).sort()) {
+    if (entry === "node_modules" || entry === "dist") continue;
+    const p = join2(dir, entry);
+    const stat = statSync(p);
+    if (stat.isDirectory()) {
+      yield* walkApiFiles(p);
+    } else if (isApiFile(entry)) {
+      yield p;
+    }
+  }
+}
+function isApiFile(name) {
+  if (name.endsWith(".spec.ts") || name.endsWith(".test.ts")) return false;
+  return name.endsWith(".api.ts") || name.endsWith(".api.d.ts");
+}
+function safeIsDirectory(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/bind-validators.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3, resolve as resolve2 } from "node:path";
+function deriveValidatorName(paramsTypeName) {
+  if (!paramsTypeName) return "";
+  return paramsTypeName.charAt(0).toLowerCase() + paramsTypeName.slice(1) + "Type";
+}
+function isExportedFromPackage(input) {
+  const { packageRoot, identifier } = input;
+  const indexPath = locateBarrelEntry(packageRoot);
+  if (!indexPath) return false;
+  return findIdentifierInBarrelChain(indexPath, identifier, /* @__PURE__ */ new Set());
+}
+function locateBarrelEntry(packageRoot) {
+  const candidates = [join3(packageRoot, "src", "index.ts"), join3(packageRoot, "src", "index.d.ts"), join3(packageRoot, "index.d.ts"), join3(packageRoot, "index.ts")];
+  return candidates.find((candidate) => existsSync2(candidate));
+}
+var EXPORT_DECL_PATTERNS = [/export\s+(?:declare\s+)?const\s+IDENT\b/, /export\s+(?:declare\s+)?function\s+IDENT\b/, /export\s*\{[^}]*\bIDENT\b[^}]*\}/];
+function findIdentifierInBarrelChain(filePath, identifier, visited) {
+  if (visited.has(filePath)) return false;
+  visited.add(filePath);
+  let text;
+  try {
+    text = readFileSync4(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  for (const pattern of EXPORT_DECL_PATTERNS) {
+    const re = new RegExp(pattern.source.replace("IDENT", escapeRegExp(identifier)));
+    if (re.test(text)) return true;
+  }
+  const dir = dirname2(filePath);
+  for (const reExportTarget of collectReExportTargets(text)) {
+    const resolved = resolveReExport(dir, reExportTarget);
+    if (!resolved) continue;
+    if (findIdentifierInBarrelChain(resolved, identifier, visited)) return true;
+  }
+  return false;
+}
+function collectReExportTargets(text) {
+  const out = [];
+  const re = /export\s*(?:\*|\{[^}]*\})\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    out.push(match[1]);
+  }
+  return out;
+}
+function resolveReExport(fromDir, target) {
+  if (!target.startsWith(".")) return void 0;
+  const candidate = isAbsolute2(target) ? target : resolve2(fromDir, target);
+  let result;
+  for (const ext of [".ts", ".mts", ".d.ts", "/index.ts", "/index.mts", "/index.d.ts"]) {
+    const probe = hasTsModuleExtension(candidate) ? candidate : candidate + ext;
+    const resolved = resolveExistingTsPath(probe);
+    if (resolved) {
+      result = resolved;
+      break;
+    }
+  }
+  return result;
+}
+function hasTsModuleExtension(value) {
+  return value.endsWith(".ts") || value.endsWith(".mts");
+}
+function resolveExistingTsPath(probe) {
+  if (!existsSync2(probe)) return void 0;
+  const stat = statSync2(probe);
+  if (stat.isFile()) return probe;
+  if (!stat.isDirectory()) return void 0;
+  const sourceIndex = join3(probe, "index.ts");
+  if (existsSync2(sourceIndex)) return sourceIndex;
+  const declarationIndex = join3(probe, "index.d.ts");
+  return existsSync2(declarationIndex) ? declarationIndex : void 0;
+}
+function escapeRegExp(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/emit.ts
+import { format, resolveConfig } from "prettier";
+async function renderManifest(input) {
+  const { outputFile, entries, projectName, namespace } = input;
+  const importsByPackage = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.packageName || !entry.validatorName) continue;
+    const set = importsByPackage.get(entry.packageName) ?? /* @__PURE__ */ new Set();
+    set.add(entry.validatorName);
+    importsByPackage.set(entry.packageName, set);
+  }
+  const importLines = [...importsByPackage.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([pkg, names]) => {
+    const sortedNames = [...names].sort((a, b) => a.localeCompare(b)).join(", ");
+    return `import { ${sortedNames} } from '${pkg}';`;
+  });
+  const entryLines = entries.map((e) => renderEntry(e));
+  const source = `/* eslint-disable @nx/enforce-module-boundaries */
+// AUTO-GENERATED \u2014 DO NOT EDIT.
+// Run \`pnpm nx run ${projectName}:generate-api-manifest\` to refresh.
+
+${importLines.join("\n")}
+import { type CliApiManifest } from '@dereekb/dbx-cli';
+
+export const ${namespace}: CliApiManifest = [
+${entryLines.join(",\n")}
+];
+`;
+  return formatWithPrettier(source, outputFile);
+}
+function renderEntry({ entry, validatorName }) {
+  const fields = [
+    `model: ${JSON.stringify(entry.model)}`,
+    `verb: ${JSON.stringify(entry.verb)}`,
+    entry.specifier ? `specifier: ${JSON.stringify(entry.specifier)}` : void 0,
+    entry.paramsTypeName ? `paramsTypeName: ${JSON.stringify(entry.paramsTypeName)}` : void 0,
+    validatorName ? `paramsValidator: ${validatorName}` : void 0,
+    entry.resultTypeName ? `resultTypeName: ${JSON.stringify(entry.resultTypeName)}` : void 0,
+    `groupName: ${JSON.stringify(entry.groupName)}`,
+    `sourceFile: ${JSON.stringify(entry.sourceFile)}`,
+    entry.description ? `description: ${JSON.stringify(entry.description)}` : void 0,
+    entry.paramsTypeDescription ? `paramsTypeDescription: ${JSON.stringify(entry.paramsTypeDescription)}` : void 0,
+    entry.paramsFields && entry.paramsFields.length > 0 ? `paramsFields: ${renderDocFields(entry.paramsFields)}` : void 0,
+    entry.resultTypeDescription ? `resultTypeDescription: ${JSON.stringify(entry.resultTypeDescription)}` : void 0,
+    entry.resultFields && entry.resultFields.length > 0 ? `resultFields: ${renderDocFields(entry.resultFields)}` : void 0
+  ];
+  return `  { ${fields.filter((v) => Boolean(v)).join(", ")} }`;
+}
+function renderDocFields(fields) {
+  const items = fields.map((field) => {
+    const parts = [`name: ${JSON.stringify(field.name)}`, `typeText: ${JSON.stringify(field.typeText)}`];
+    if (field.description) parts.push(`description: ${JSON.stringify(field.description)}`);
+    return `{ ${parts.join(", ")} }`;
+  });
+  return `[${items.join(", ")}]`;
+}
+async function formatWithPrettier(source, outputFile) {
+  const config = await resolveConfig(outputFile);
+  return format(source, { ...config, filepath: outputFile });
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/main.ts
+var WORKSPACE_ROOT = process.cwd();
+async function main() {
+  const flags = parseFlags(process.argv.slice(2));
+  if (!flags.functionsConfig || !flags.output) {
+    printUsageAndExit();
+    return;
+  }
+  const functionsConfigPath = resolveWorkspacePath(flags.functionsConfig);
+  const outputFile = resolveWorkspacePath(flags.output);
+  const outputDir = dirname3(outputFile);
+  const projectName = flags.project ?? "<cli>";
+  const namespace = deriveNamespace(flags.project);
+  if (!existsSync3(functionsConfigPath)) {
+    throw new Error(`functions-config file not found: ${functionsConfigPath}`);
+  }
+  const groups = parseFunctionsConfig(functionsConfigPath);
+  if (groups.length === 0) {
+    throw new Error(`No function groups discovered in ${relPath(WORKSPACE_ROOT, functionsConfigPath)}.`);
+  }
+  const packageCache = /* @__PURE__ */ new Map();
+  const apiFilesCache = /* @__PURE__ */ new Map();
+  const collected = [];
+  let missingValidators = 0;
+  let skippedGroups = 0;
+  for (const group of groups) {
+    const pkg = resolveModuleToPackage({ workspaceRoot: WORKSPACE_ROOT, importingFile: functionsConfigPath, moduleSpecifier: group.importedFromModule });
+    if (!pkg) {
+      console.warn(`[skip] ${group.groupKey}: cannot resolve module '${group.importedFromModule}' for class ${group.className}`);
+      skippedGroups++;
+      continue;
+    }
+    if (!packageCache.has(pkg.packageRoot)) packageCache.set(pkg.packageRoot, pkg);
+    if (!apiFilesCache.has(pkg.packageRoot)) apiFilesCache.set(pkg.packageRoot, findApiFiles(pkg.packageRoot));
+    const apiFiles = apiFilesCache.get(pkg.packageRoot) ?? [];
+    const match = apiFiles.find((f) => f.className === group.className);
+    if (!match) {
+      console.warn(`[skip] ${group.groupKey}: no .api.{ts,d.ts} under ${pkg.packageName} declares 'export abstract class ${group.className}'`);
+      skippedGroups++;
+      continue;
+    }
+    if (match.extraction.entries.length === 0) {
+      console.warn(`[skip] ${group.groupKey}: ${group.className} is not a CRUD model group (no *ModelCrudFunctionsConfig in ${relPath(WORKSPACE_ROOT, match.filePath)})`);
+      skippedGroups++;
+      continue;
+    }
+    const groupName = match.extraction.groupName ?? group.className.replace(/Functions$/, "");
+    const sourceFileRel = relPath(WORKSPACE_ROOT, match.filePath);
+    for (const entry of match.extraction.entries) {
+      if (flags.only && !flags.only.has(entry.model)) continue;
+      if (entry.verb === "standalone") continue;
+      const enriched = { entry: { ...entry, groupName, sourceFile: sourceFileRel } };
+      if (entry.paramsTypeName) {
+        const validatorName = deriveValidatorName(entry.paramsTypeName);
+        const found = isExportedFromPackage({ packageRoot: pkg.packageRoot, identifier: validatorName });
+        if (found) {
+          enriched.packageName = pkg.packageName;
+          enriched.validatorName = validatorName;
+        } else {
+          missingValidators++;
+          const specPart = entry.specifier ? "/" + entry.specifier : "";
+          console.warn(`[no-validator] ${pkg.packageName} \xB7 ${entry.model}/${entry.verb}${specPart} \u2192 ${validatorName} not exported`);
+        }
+      }
+      collected.push(enriched);
+    }
+  }
+  collected.sort(compareEntries);
+  ensureOutputDir(outputDir);
+  const formatted = await renderManifest({ outputFile, entries: collected, projectName, namespace });
+  if (existsSync3(outputFile) && readFileSync5(outputFile, "utf8") === formatted) {
+    console.log(`[unchanged] ${relative2(WORKSPACE_ROOT, outputFile)}`);
+  } else {
+    writeFileSync(outputFile, formatted);
+    console.log(`[wrote] ${relative2(WORKSPACE_ROOT, outputFile)}`);
+  }
+  const groupCount = packageCache.size === 0 ? 0 : new Set(collected.map((c) => c.entry.groupName)).size;
+  console.log(`Summary: ${groupCount} groups \xB7 ${collected.length} entries \xB7 ${collected.length - missingValidators} validators bound \xB7 ${missingValidators} missing \xB7 ${skippedGroups} skipped`);
+  if (flags.strict && missingValidators > 0) {
+    console.error(`[strict] ${missingValidators} validator(s) missing \u2014 failing build.`);
+    process.exit(1);
+  }
+}
+function compareEntries(a, b) {
+  if (a.entry.model !== b.entry.model) return a.entry.model.localeCompare(b.entry.model);
+  if (a.entry.verb !== b.entry.verb) return a.entry.verb.localeCompare(b.entry.verb);
+  return (a.entry.specifier ?? "").localeCompare(b.entry.specifier ?? "");
+}
+function ensureOutputDir(outputDir) {
+  if (!existsSync3(outputDir)) mkdirSync(outputDir, { recursive: true });
+}
+function resolveWorkspacePath(value) {
+  return isAbsolute3(value) ? value : resolve3(WORKSPACE_ROOT, value);
+}
+function deriveNamespace(projectName) {
+  const base = (projectName ?? "cli").replaceAll(/[^a-zA-Z0-9]+/g, "_");
+  return `${base.toUpperCase()}_API_MANIFEST`;
+}
+function parseFlags(argv) {
+  let only;
+  let strict = false;
+  let functionsConfig;
+  let output;
+  let project;
+  for (const arg of argv) {
+    if (arg === "--strict") {
+      strict = true;
+    } else if (arg.startsWith("--only=")) {
+      const list = arg.slice("--only=".length).split(",").map((s) => s.trim()).filter(Boolean);
+      if (list.length > 0) only = new Set(list);
+    } else if (arg.startsWith("--functions-config=")) {
+      functionsConfig = arg.slice("--functions-config=".length);
+    } else if (arg.startsWith("--output=")) {
+      output = arg.slice("--output=".length);
+    } else if (arg.startsWith("--project=")) {
+      project = arg.slice("--project=".length);
+    }
+  }
+  return { only, strict, functionsConfig, output, project };
+}
+function printUsageAndExit() {
+  console.error(String.raw`generate-api-manifest
+
+Usage:
+  node dist/packages/dbx-cli/firebase-api-manifest/main.js \
+    --project=<name> \
+    --functions-config=<path-to-functions.ts> \
+    --output=<path-to-manifest.generated.ts> \
+    [--only=model[,model]] [--strict]
+
+Required flags:
+  --functions-config=<path>  Path to the app's functions.ts (workspace-relative ok).
+  --output=<path>            Path to the manifest TS file to write (workspace-relative ok).
+
+Optional:
+  --project=<name>           Project name to show in the regenerate banner.
+  --only=<csv>               Filter to listed model names.
+  --strict                   Fail when any validator binding is missing.`);
+  process.exit(1);
+}
+try {
+  await main();
+} catch (e) {
+  console.error(e);
+  process.exit(1);
+}