@dereekb/dbx-cli 13.11.4 → 13.11.6

package/firebase-api-manifest/main.js

@@ -3,7 +3,7 @@ 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 { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync6, 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
@@ -384,6 +384,368 @@ function readJsDocSummary(node) {
   return description.length > 0 ? description : void 0;
 }
 
+// packages/dbx-cli/manifest-extract/src/lib/extract-models.ts
+import { Node as Node3, Project as Project3 } from "ts-morph";
+var PASSTHROUGH_TYPE_WRAPPERS = /* @__PURE__ */ new Set(["Partial", "Required", "Readonly", "NonNullable", "MaybeMap", "Pick", "Omit"]);
+var IDENTITY_FN = "firestoreModelIdentity";
+var CONVERTER_FN_NAMES = ["snapshotConverterFunctions", "firestoreSubObject", "firestoreObjectArray"];
+var SUB_OBJECT_FN = "firestoreSubObject";
+var OBJECT_ARRAY_FN = "firestoreObjectArray";
+var SNAPSHOT_FN = "snapshotConverterFunctions";
+var FIELDS_LITERAL_KEY = "fields";
+var OBJECT_FIELD_KEY = "objectField";
+function extractModelsFromSource(input) {
+  const project = new Project3({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  const sourceFile = project.createSourceFile(input.name, input.text, { overwrite: true });
+  const identities = readIdentities(sourceFile);
+  const interfaces = readInterfaces(sourceFile);
+  const converters = readConverters(sourceFile);
+  const enums = readEnums(sourceFile);
+  const modelGroups = readModelGroups(sourceFile);
+  return { identities, interfaces, converters, enums, modelGroups };
+}
+function readIdentities(sourceFile) {
+  const out = [];
+  for (const statement of sourceFile.getVariableStatements()) {
+    if (!statement.isExported()) continue;
+    for (const decl of statement.getDeclarations()) {
+      const initializer = decl.getInitializer();
+      if (!initializer || !Node3.isCallExpression(initializer)) continue;
+      if (initializer.getExpression().getText() !== IDENTITY_FN) continue;
+      const parsed = parseIdentityArgs(initializer);
+      if (parsed) {
+        out.push({ identityConst: decl.getName(), ...parsed });
+      }
+    }
+  }
+  return out;
+}
+function parseIdentityArgs(call) {
+  const args = call.getArguments();
+  let result;
+  if (args.length === 1) {
+    const modelType = stringLiteralValue(args[0]);
+    if (modelType !== void 0) {
+      result = { modelType, collectionPrefix: void 0, parentIdentityConst: void 0 };
+    }
+  } else if (args.length === 2) {
+    const first = stringLiteralValue(args[0]);
+    if (first === void 0) {
+      const modelType = stringLiteralValue(args[1]);
+      if (modelType !== void 0) {
+        result = { modelType, collectionPrefix: void 0, parentIdentityConst: identifierName(args[0]) };
+      }
+    } else {
+      result = { modelType: first, collectionPrefix: stringLiteralValue(args[1]), parentIdentityConst: void 0 };
+    }
+  } else if (args.length >= 3) {
+    const modelType = stringLiteralValue(args[1]);
+    if (modelType !== void 0) {
+      result = { modelType, collectionPrefix: stringLiteralValue(args[2]), parentIdentityConst: identifierName(args[0]) };
+    }
+  }
+  return result;
+}
+function readInterfaces(sourceFile) {
+  const out = [];
+  for (const decl of sourceFile.getInterfaces()) {
+    if (!decl.isExported()) continue;
+    out.push(buildInterface(decl));
+  }
+  return out;
+}
+function buildInterface(decl) {
+  const jsDocs = decl.getJsDocs();
+  const hasDbxModelTag = jsDocsHaveTag(jsDocs, "dbxModel");
+  const extendsNames = decl.getExtends().map(resolveExtendsName);
+  const props = [];
+  for (const prop of decl.getProperties()) {
+    const propJsDocs = prop.getJsDocs();
+    const longName = readJsDocTagText(propJsDocs, "dbxModelVariable");
+    const syncFlag = readJsDocTagText(propJsDocs, "dbxModelVariableSyncFlag");
+    const tsType = (prop.getTypeNode()?.getText() ?? "").replaceAll(/\s+/g, " ").trim();
+    const optional = prop.hasQuestionToken() || tsType.startsWith("Maybe<");
+    props.push({
+      name: prop.getName(),
+      tsType,
+      optional,
+      description: readJsDocDescription(propJsDocs),
+      longName,
+      syncFlag
+    });
+  }
+  return {
+    name: decl.getName(),
+    description: readJsDocDescription(jsDocs),
+    hasDbxModelTag,
+    extendsNames,
+    props
+  };
+}
+function resolveExtendsName(expr) {
+  const head = expr.getExpression().getText();
+  let result = head;
+  if (PASSTHROUGH_TYPE_WRAPPERS.has(head)) {
+    const typeArgs = expr.getTypeArguments();
+    if (typeArgs.length > 0) {
+      const peeled = peelTypeNode(typeArgs[0]);
+      if (peeled !== void 0) {
+        result = peeled;
+      }
+    }
+  }
+  return result;
+}
+function peelTypeNode(node) {
+  let current = node;
+  while (Node3.isParenthesizedTypeNode(current)) {
+    current = current.getTypeNode();
+  }
+  let result;
+  if (Node3.isTypeReference(current)) {
+    const name = current.getTypeName().getText();
+    if (PASSTHROUGH_TYPE_WRAPPERS.has(name)) {
+      const inner = current.getTypeArguments();
+      if (inner.length > 0) {
+        result = peelTypeNode(inner[0]);
+      }
+    } else {
+      result = name;
+    }
+  }
+  return result;
+}
+function readConverters(sourceFile) {
+  const out = [];
+  for (const statement of sourceFile.getVariableStatements()) {
+    if (!statement.isExported()) continue;
+    for (const decl of statement.getDeclarations()) {
+      const initializer = decl.getInitializer();
+      if (!initializer || !Node3.isCallExpression(initializer)) continue;
+      const factory = initializer.getExpression().getText();
+      if (!isConverterFactoryName(factory)) continue;
+      const interfaceName = readGenericInterfaceName(initializer);
+      const fields = readConverterFields(initializer);
+      if (!fields) continue;
+      out.push({
+        converterConst: decl.getName(),
+        factory,
+        interfaceName,
+        fields,
+        line: decl.getStartLineNumber()
+      });
+    }
+  }
+  return out;
+}
+function isConverterFactoryName(name) {
+  return CONVERTER_FN_NAMES.includes(name);
+}
+function readGenericInterfaceName(call) {
+  const typeArgs = call.getTypeArguments();
+  let result;
+  if (typeArgs.length > 0) {
+    result = typeArgs[0].getText().replaceAll(/<[^>]*>/g, "").trim();
+  }
+  return result;
+}
+function readConverterFields(call) {
+  const fnName = call.getExpression().getText();
+  const args = call.getArguments();
+  if (args.length === 0) return void 0;
+  const config = args[0];
+  if (!Node3.isObjectLiteralExpression(config)) return void 0;
+  let fieldsLiteral;
+  if (fnName === SNAPSHOT_FN) {
+    fieldsLiteral = readObjectProperty(config, FIELDS_LITERAL_KEY);
+  } else {
+    const objectField = readPropertyValue(config, OBJECT_FIELD_KEY);
+    if (objectField && Node3.isObjectLiteralExpression(objectField)) {
+      fieldsLiteral = readObjectProperty(objectField, FIELDS_LITERAL_KEY);
+    }
+  }
+  if (!fieldsLiteral) return void 0;
+  return readFieldEntries(fieldsLiteral);
+}
+function readFieldEntries(fields) {
+  const out = [];
+  for (const property of fields.getProperties()) {
+    if (Node3.isPropertyAssignment(property)) {
+      const initializer = property.getInitializer();
+      const converterText = initializer ? initializer.getText().replaceAll(/\s+/g, " ").trim() : "";
+      const nested = initializer ? readNestedFromExpression(initializer) : void 0;
+      out.push({
+        key: property.getName(),
+        converter: converterText,
+        nestedConverterRef: nested?.ref,
+        nestedConverterInline: nested?.inline,
+        nestedIsArray: nested?.isArray
+      });
+    } else if (Node3.isShorthandPropertyAssignment(property)) {
+      const name = property.getName();
+      out.push({ key: name, converter: name });
+    }
+  }
+  return out;
+}
+function readNestedFromExpression(expr) {
+  if (!Node3.isCallExpression(expr)) return void 0;
+  const fnName = expr.getExpression().getText();
+  if (fnName !== SUB_OBJECT_FN && fnName !== OBJECT_ARRAY_FN) return void 0;
+  const args = expr.getArguments();
+  if (args.length === 0) return void 0;
+  const config = args[0];
+  if (!Node3.isObjectLiteralExpression(config)) return void 0;
+  const objectField = readPropertyValue(config, OBJECT_FIELD_KEY);
+  if (!objectField) return void 0;
+  const isArray = fnName === OBJECT_ARRAY_FN;
+  let result;
+  if (Node3.isIdentifier(objectField)) {
+    result = { ref: objectField.getText(), isArray };
+  } else if (Node3.isObjectLiteralExpression(objectField)) {
+    const fieldsLiteral = readObjectProperty(objectField, FIELDS_LITERAL_KEY);
+    if (fieldsLiteral) {
+      const inlineFields = readFieldEntries(fieldsLiteral);
+      result = {
+        inline: {
+          converterConst: void 0,
+          factory: fnName,
+          interfaceName: readGenericInterfaceName(expr),
+          fields: inlineFields,
+          line: expr.getStartLineNumber()
+        },
+        isArray
+      };
+    }
+  }
+  return result;
+}
+function readPropertyValue(literal, key) {
+  const property = literal.getProperty(key);
+  let result;
+  if (property && Node3.isPropertyAssignment(property)) {
+    result = property.getInitializer();
+  } else if (property && Node3.isShorthandPropertyAssignment(property)) {
+    result = property.getNameNode();
+  }
+  return result;
+}
+function readObjectProperty(literal, key) {
+  const value = readPropertyValue(literal, key);
+  return value && Node3.isObjectLiteralExpression(value) ? value : void 0;
+}
+function readEnums(sourceFile) {
+  const out = [];
+  for (const decl of sourceFile.getEnums()) {
+    if (!decl.isExported()) continue;
+    const values = [];
+    for (const member of decl.getMembers()) {
+      const value = member.getValue();
+      const description = readJsDocDescription(member.getJsDocs());
+      if (typeof value === "string" || typeof value === "number") {
+        values.push({ name: member.getName(), value, description });
+      }
+    }
+    out.push({
+      name: decl.getName(),
+      values,
+      description: readJsDocDescription(decl.getJsDocs())
+    });
+  }
+  return out;
+}
+function readModelGroups(sourceFile) {
+  const out = [];
+  for (const iface of sourceFile.getInterfaces()) {
+    if (!iface.isExported()) continue;
+    const groupTag = readJsDocTagText(iface.getJsDocs(), "dbxModelGroup");
+    if (!groupTag) continue;
+    const containerName = iface.getName();
+    if (!containerName.endsWith("FirestoreCollections")) continue;
+    const modelNames = [];
+    for (const prop of iface.getProperties()) {
+      const tsType = prop.getTypeNode()?.getText() ?? "";
+      const match = /([A-Z]\w*)FirestoreCollection(?:Factory)?(?:\b|<)/.exec(tsType);
+      if (match) modelNames.push(match[1]);
+    }
+    out.push({
+      name: groupTag,
+      containerName,
+      description: readJsDocDescription(iface.getJsDocs()),
+      modelNames
+    });
+  }
+  return out;
+}
+function jsDocsHaveTag(jsDocs, tagName) {
+  let found = false;
+  for (const jsDoc of jsDocs) {
+    for (const tag of jsDoc.getTags()) {
+      if (tag.getTagName() === tagName) {
+        found = true;
+        break;
+      }
+    }
+    if (found) break;
+  }
+  return found;
+}
+function readJsDocTagText(jsDocs, tagName) {
+  let result;
+  for (const jsDoc of jsDocs) {
+    for (const tag of jsDoc.getTags()) {
+      if (tag.getTagName() !== tagName) continue;
+      const text = tag.getCommentText()?.trim();
+      if (text !== void 0 && text.length > 0) {
+        result = text;
+        break;
+      }
+    }
+    if (result !== void 0) break;
+  }
+  return result;
+}
+function readJsDocDescription(jsDocs) {
+  let result;
+  for (const jsDoc of jsDocs) {
+    const description = jsDoc.getDescription().trim();
+    if (description.length === 0) continue;
+    const paragraph = firstParagraph(description);
+    if (paragraph.length > 0) {
+      result = paragraph;
+      break;
+    }
+  }
+  return result;
+}
+function firstParagraph(text) {
+  const lines = text.split("\n").map((line) => line.trim());
+  const collected = [];
+  for (const line of lines) {
+    if (line.startsWith("@")) break;
+    if (line.length === 0) {
+      if (collected.length > 0) break;
+      continue;
+    }
+    collected.push(line);
+  }
+  return collected.join(" ").trim();
+}
+function stringLiteralValue(node) {
+  let result;
+  if (Node3.isStringLiteral(node) || Node3.isNoSubstitutionTemplateLiteral(node)) {
+    result = node.getLiteralText();
+  }
+  return result;
+}
+function identifierName(node) {
+  let result;
+  if (Node3.isIdentifier(node)) {
+    result = node.getText();
+  }
+  return result;
+}
+
 // packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/find-api-files.ts
 function findApiFiles(packageRoot) {
   const libRoot = join2(packageRoot, "src", "lib");
@@ -424,9 +786,263 @@ function safeIsDirectory(p) {
   }
 }
 
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/find-model-files.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function findModelFiles(packageRoot) {
+  const libRoot = join3(packageRoot, "src", "lib");
+  if (!safeIsDirectory2(libRoot)) return [];
+  const out = [];
+  for (const filePath of walkSourceFiles(libRoot)) {
+    const text = readFileSync4(filePath, "utf8");
+    if (!textHasModelMarker(text)) continue;
+    const extraction = extractModelsFromSource({ name: filePath, text });
+    if (extraction.identities.length === 0 && extraction.modelGroups.length === 0 && extraction.converters.length === 0) continue;
+    out.push({ filePath, extraction });
+  }
+  return out;
+}
+function textHasModelMarker(text) {
+  if (text.includes("firestoreModelIdentity(")) return true;
+  if (text.includes("@dbxModelGroup")) return true;
+  if (text.includes("snapshotConverterFunctions")) return true;
+  if (text.includes("firestoreSubObject")) return true;
+  if (text.includes("firestoreObjectArray")) return true;
+  return false;
+}
+function* walkSourceFiles(dir) {
+  for (const entry of readdirSync2(dir).sort()) {
+    if (entry === "node_modules" || entry === "dist") continue;
+    const p = join3(dir, entry);
+    const stat = statSync2(p);
+    if (stat.isDirectory()) {
+      yield* walkSourceFiles(p);
+    } else if (isCandidateSourceFile(entry)) {
+      yield p;
+    }
+  }
+}
+function isCandidateSourceFile(name) {
+  if (!name.endsWith(".ts")) return false;
+  if (name.endsWith(".api.ts")) return false;
+  if (name.endsWith(".spec.ts")) return false;
+  if (name.endsWith(".test.ts")) return false;
+  if (name.endsWith(".id.ts")) return false;
+  if (name.endsWith(".d.ts")) return false;
+  return true;
+}
+function safeIsDirectory2(p) {
+  try {
+    return statSync2(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/assemble-models.ts
+var MAX_NESTED_DEPTH = 8;
+var LONG_NAME_RE = /^[a-z][a-zA-Z0-9]*$/;
+var ENUM_GENERIC_RE = /firestoreEnum<(\w+)>|optionalFirestoreEnum<(\w+)>/;
+function assembleModels(input) {
+  const registries = buildGlobalRegistries(input.extractions);
+  const accumulator = { seen: /* @__PURE__ */ new Set(), entries: [] };
+  for (const source of input.extractions) {
+    appendEntriesFromSource(source, registries, accumulator);
+  }
+  accumulator.entries.sort((a, b) => a.modelType.localeCompare(b.modelType));
+  return accumulator.entries;
+}
+function buildGlobalRegistries(extractions) {
+  const converterRegistry = /* @__PURE__ */ new Map();
+  const interfaceRegistry = /* @__PURE__ */ new Map();
+  const groupByModelName = /* @__PURE__ */ new Map();
+  for (const { extraction } of extractions) {
+    for (const converter of extraction.converters) {
+      if (converter.converterConst && !converterRegistry.has(converter.converterConst)) {
+        converterRegistry.set(converter.converterConst, converter);
+      }
+    }
+    for (const iface of extraction.interfaces) {
+      if (!interfaceRegistry.has(iface.name)) interfaceRegistry.set(iface.name, iface);
+    }
+    for (const group of extraction.modelGroups) {
+      for (const modelName of group.modelNames) {
+        if (!groupByModelName.has(modelName)) groupByModelName.set(modelName, group.name);
+      }
+    }
+  }
+  return { converterRegistry, interfaceRegistry, groupByModelName };
+}
+function appendEntriesFromSource(source, registries, accumulator) {
+  const enumNames = new Set(source.extraction.enums.map((e) => e.name));
+  for (const identity of source.extraction.identities) {
+    if (accumulator.seen.has(identity.identityConst)) continue;
+    const entry = buildEntryForIdentity({ identity, source, registries, enumNames });
+    if (entry) {
+      accumulator.seen.add(identity.identityConst);
+      accumulator.entries.push(entry);
+    }
+  }
+}
+function buildEntryForIdentity(input) {
+  const { identity, source, registries, enumNames } = input;
+  if (identity.collectionPrefix === void 0) return void 0;
+  const modelName = capitalize(identity.modelType);
+  const iface = registries.interfaceRegistry.get(modelName);
+  if (!iface?.hasDbxModelTag) return void 0;
+  const converter = findConverterForInterface(source.extraction, modelName) ?? findConverterFromRegistry(registries.converterRegistry, modelName);
+  if (!converter) return void 0;
+  const fields = buildFields({
+    converter,
+    iface,
+    interfaceRegistry: registries.interfaceRegistry,
+    converterRegistry: registries.converterRegistry,
+    enumNames,
+    depth: 0,
+    visitedConverters: /* @__PURE__ */ new Set()
+  });
+  const modelGroup = registries.groupByModelName.get(modelName);
+  return {
+    modelType: identity.modelType,
+    modelName,
+    ...modelGroup ? { modelGroup } : {},
+    identityConst: identity.identityConst,
+    collectionPrefix: identity.collectionPrefix,
+    ...identity.parentIdentityConst ? { parentIdentityConst: identity.parentIdentityConst } : {},
+    ...iface.description ? { description: iface.description } : {},
+    sourcePackage: source.sourcePackage,
+    sourceFile: source.sourceFile,
+    fields
+  };
+}
+function findConverterForInterface(extraction, interfaceName) {
+  return extraction.converters.find((c) => c.interfaceName === interfaceName);
+}
+function findConverterFromRegistry(registry, interfaceName) {
+  let result;
+  for (const converter of registry.values()) {
+    if (converter.interfaceName === interfaceName) {
+      result = converter;
+      break;
+    }
+  }
+  return result;
+}
+function buildFields(input) {
+  const out = [];
+  const propByName = /* @__PURE__ */ new Map();
+  if (input.iface) {
+    for (const prop of input.iface.props) propByName.set(prop.name, prop);
+    for (const ancestor of collectAncestors(input.iface, input.interfaceRegistry)) {
+      for (const prop of ancestor.props) {
+        if (!propByName.has(prop.name)) propByName.set(prop.name, prop);
+      }
+    }
+  }
+  for (const field of input.converter.fields) {
+    out.push(buildField({ ...input, field, propByName }));
+  }
+  return out;
+}
+function buildField(input) {
+  const { field, propByName } = input;
+  const prop = propByName.get(field.key);
+  const enumRef = resolveEnumRef(field.converter, prop?.tsType, input.enumNames);
+  const optional = prop?.optional ?? field.converter.startsWith("optionalFirestore");
+  const longName = resolveLongName(field.key, prop?.longName);
+  const nested = resolveNestedFields(input);
+  const out = {
+    name: field.key,
+    longName,
+    converter: field.converter,
+    ...prop?.tsType ? { tsType: prop.tsType } : {},
+    optional,
+    ...prop?.description ? { description: prop.description } : {},
+    ...enumRef ? { enumRef } : {},
+    ...prop?.syncFlag ? { syncFlag: prop.syncFlag } : {},
+    ...nested ? { nestedFields: nested.fields, nestedIsArray: nested.isArray } : {}
+  };
+  return out;
+}
+function resolveNestedFields(input) {
+  const { field } = input;
+  if (input.depth >= MAX_NESTED_DEPTH) return void 0;
+  let nestedConverter;
+  if (field.nestedConverterInline) {
+    nestedConverter = field.nestedConverterInline;
+  } else if (field.nestedConverterRef) {
+    if (input.visitedConverters.has(field.nestedConverterRef)) return void 0;
+    nestedConverter = input.converterRegistry.get(field.nestedConverterRef);
+  }
+  if (!nestedConverter) return void 0;
+  const nextVisited = new Set(input.visitedConverters);
+  if (nestedConverter.converterConst) nextVisited.add(nestedConverter.converterConst);
+  const nestedIface = nestedConverter.interfaceName ? input.interfaceRegistry.get(nestedConverter.interfaceName) : void 0;
+  const fields = buildFields({
+    converter: nestedConverter,
+    iface: nestedIface,
+    interfaceRegistry: input.interfaceRegistry,
+    converterRegistry: input.converterRegistry,
+    enumNames: input.enumNames,
+    depth: input.depth + 1,
+    visitedConverters: nextVisited
+  });
+  return { fields, isArray: field.nestedIsArray ?? false };
+}
+function collectAncestors(iface, registry) {
+  const out = [];
+  const visited = /* @__PURE__ */ new Set([iface.name]);
+  const stack = [iface];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const parentName of current.extendsNames) {
+      if (visited.has(parentName)) continue;
+      visited.add(parentName);
+      const parent = registry.get(parentName);
+      if (parent) {
+        out.push(parent);
+        stack.push(parent);
+      }
+    }
+  }
+  return out;
+}
+function resolveLongName(fieldName, propLongName) {
+  let result;
+  if (propLongName && LONG_NAME_RE.test(propLongName)) {
+    result = propLongName;
+  } else {
+    result = fieldName;
+  }
+  return result;
+}
+function resolveEnumRef(converter, tsType, enumNames) {
+  let result;
+  if (tsType) {
+    for (const name of enumNames) {
+      const re = new RegExp(String.raw`\b${name}\b`);
+      if (re.test(tsType)) {
+        result = name;
+        break;
+      }
+    }
+  }
+  if (!result) {
+    const m = ENUM_GENERIC_RE.exec(converter);
+    if (m) {
+      const name = m[1] ?? m[2];
+      if (enumNames.has(name)) result = name;
+    }
+  }
+  return result;
+}
+function capitalize(s) {
+  return s.length > 0 ? s[0].toUpperCase() + s.slice(1) : s;
+}
+
 // 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";
+import { existsSync as existsSync2, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync3 } from "node:fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "node:path";
 function deriveValidatorName(paramsTypeName) {
   if (!paramsTypeName) return "";
   return paramsTypeName.charAt(0).toLowerCase() + paramsTypeName.slice(1) + "Type";
@@ -438,7 +1054,7 @@ function isExportedFromPackage(input) {
   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")];
+  const candidates = [join4(packageRoot, "src", "index.ts"), join4(packageRoot, "src", "index.d.ts"), join4(packageRoot, "index.d.ts"), join4(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[^}]*\}/];
@@ -447,7 +1063,7 @@ function findIdentifierInBarrelChain(filePath, identifier, visited) {
   visited.add(filePath);
   let text;
   try {
-    text = readFileSync4(filePath, "utf8");
+    text = readFileSync5(filePath, "utf8");
   } catch {
     return false;
   }
@@ -491,12 +1107,12 @@ function hasTsModuleExtension(value) {
 }
 function resolveExistingTsPath(probe) {
   if (!existsSync2(probe)) return void 0;
-  const stat = statSync2(probe);
+  const stat = statSync3(probe);
   if (stat.isFile()) return probe;
   if (!stat.isDirectory()) return void 0;
-  const sourceIndex = join3(probe, "index.ts");
+  const sourceIndex = join4(probe, "index.ts");
   if (existsSync2(sourceIndex)) return sourceIndex;
-  const declarationIndex = join3(probe, "index.d.ts");
+  const declarationIndex = join4(probe, "index.d.ts");
   return existsSync2(declarationIndex) ? declarationIndex : void 0;
 }
 function escapeRegExp(value) {
@@ -506,7 +1122,7 @@ function escapeRegExp(value) {
 // 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 { outputFile, entries, projectName, namespace, modelEntries, modelNamespace, emitConverters = false } = input;
   const importsByPackage = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.packageName || !entry.validatorName) continue;
@@ -519,16 +1135,24 @@ async function renderManifest(input) {
     return `import { ${sortedNames} } from '${pkg}';`;
   });
   const entryLines = entries.map((e) => renderEntry(e));
+  const emitModels = Boolean(modelEntries && modelEntries.length > 0 && modelNamespace);
+  const dbxCliTypeImports = emitModels ? `import { type CliApiManifest, type CliModelManifest } from '@dereekb/dbx-cli';` : `import { type CliApiManifest } from '@dereekb/dbx-cli';`;
+  const modelSection = emitModels ? `
+
+export const ${modelNamespace}: CliModelManifest = [
+${(modelEntries ?? []).map((m) => renderModelEntry(m, emitConverters)).join(",\n")}
+];
+` : "";
   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';
+${dbxCliTypeImports}
 
 export const ${namespace}: CliApiManifest = [
 ${entryLines.join(",\n")}
-];
+];${modelSection}
 `;
   return formatWithPrettier(source, outputFile);
 }
@@ -562,6 +1186,41 @@ async function formatWithPrettier(source, outputFile) {
   const config = await resolveConfig(outputFile);
   return format(source, { ...config, filepath: outputFile });
 }
+function renderModelEntry(entry, emitConverters) {
+  const fields = [
+    `modelType: ${JSON.stringify(entry.modelType)}`,
+    `modelName: ${JSON.stringify(entry.modelName)}`,
+    entry.modelGroup ? `modelGroup: ${JSON.stringify(entry.modelGroup)}` : void 0,
+    `identityConst: ${JSON.stringify(entry.identityConst)}`,
+    `collectionPrefix: ${JSON.stringify(entry.collectionPrefix)}`,
+    entry.parentIdentityConst ? `parentIdentityConst: ${JSON.stringify(entry.parentIdentityConst)}` : void 0,
+    entry.description ? `description: ${JSON.stringify(entry.description)}` : void 0,
+    `sourcePackage: ${JSON.stringify(entry.sourcePackage)}`,
+    `sourceFile: ${JSON.stringify(entry.sourceFile)}`,
+    `fields: ${renderModelFields(entry.fields, emitConverters)}`
+  ];
+  return `  { ${fields.filter((v) => Boolean(v)).join(", ")} }`;
+}
+function renderModelFields(fields, emitConverters) {
+  if (fields.length === 0) return "[]";
+  const items = fields.map((field) => renderModelField(field, emitConverters));
+  return `[${items.join(", ")}]`;
+}
+function renderModelField(field, emitConverters) {
+  const parts = [
+    `name: ${JSON.stringify(field.name)}`,
+    `longName: ${JSON.stringify(field.longName)}`,
+    emitConverters && field.converter !== void 0 ? `converter: ${JSON.stringify(field.converter)}` : void 0,
+    field.tsType ? `tsType: ${JSON.stringify(field.tsType)}` : void 0,
+    `optional: ${field.optional ? "true" : "false"}`,
+    field.description ? `description: ${JSON.stringify(field.description)}` : void 0,
+    field.enumRef ? `enumRef: ${JSON.stringify(field.enumRef)}` : void 0,
+    field.syncFlag ? `syncFlag: ${JSON.stringify(field.syncFlag)}` : void 0,
+    field.nestedFields ? `nestedFields: ${renderModelFields(field.nestedFields, emitConverters)}` : void 0,
+    field.nestedFields ? `nestedIsArray: ${field.nestedIsArray ? "true" : "false"}` : void 0
+  ];
+  return `{ ${parts.filter((v) => Boolean(v)).join(", ")} }`;
+}
 
 // packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/main.ts
 var WORKSPACE_ROOT = process.cwd();
@@ -586,6 +1245,8 @@ async function main() {
   const packageCache = /* @__PURE__ */ new Map();
   const apiFilesCache = /* @__PURE__ */ new Map();
   const collected = [];
+  const modelSources = [];
+  const modelPackagesScanned = /* @__PURE__ */ new Set();
   let missingValidators = 0;
   let skippedGroups = 0;
   for (const group of groups) {
@@ -597,6 +1258,16 @@ async function main() {
     }
     if (!packageCache.has(pkg.packageRoot)) packageCache.set(pkg.packageRoot, pkg);
     if (!apiFilesCache.has(pkg.packageRoot)) apiFilesCache.set(pkg.packageRoot, findApiFiles(pkg.packageRoot));
+    if (flags.emitModels && !modelPackagesScanned.has(pkg.packageRoot)) {
+      modelPackagesScanned.add(pkg.packageRoot);
+      for (const match2 of findModelFiles(pkg.packageRoot)) {
+        modelSources.push({
+          sourcePackage: pkg.packageName,
+          sourceFile: relPath(WORKSPACE_ROOT, match2.filePath),
+          extraction: match2.extraction
+        });
+      }
+    }
     const apiFiles = apiFilesCache.get(pkg.packageRoot) ?? [];
     const match = apiFiles.find((f) => f.className === group.className);
     if (!match) {
@@ -631,16 +1302,19 @@ async function main() {
     }
   }
   collected.sort(compareEntries);
+  const modelEntries = flags.emitModels ? assembleModels({ extractions: modelSources }) : [];
+  const filteredModelEntries = flags.only ? modelEntries.filter((m) => flags.only?.has(m.modelType)) : modelEntries;
   ensureOutputDir(outputDir);
-  const formatted = await renderManifest({ outputFile, entries: collected, projectName, namespace });
-  if (existsSync3(outputFile) && readFileSync5(outputFile, "utf8") === formatted) {
+  const formatted = await renderManifest({ outputFile, entries: collected, projectName, namespace, modelEntries: filteredModelEntries, modelNamespace: deriveModelNamespace(flags.project), emitConverters: flags.emitModelConverters });
+  if (existsSync3(outputFile) && readFileSync6(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`);
+  const modelSummary = flags.emitModels ? ` \xB7 ${filteredModelEntries.length} models` : "";
+  console.log(`Summary: ${groupCount} groups \xB7 ${collected.length} entries \xB7 ${collected.length - missingValidators} validators bound \xB7 ${missingValidators} missing \xB7 ${skippedGroups} skipped${modelSummary}`);
   if (flags.strict && missingValidators > 0) {
     console.error(`[strict] ${missingValidators} validator(s) missing \u2014 failing build.`);
     process.exit(1);
@@ -661,15 +1335,25 @@ function deriveNamespace(projectName) {
   const base = (projectName ?? "cli").replaceAll(/[^a-zA-Z0-9]+/g, "_");
   return `${base.toUpperCase()}_API_MANIFEST`;
 }
+function deriveModelNamespace(projectName) {
+  const base = (projectName ?? "cli").replaceAll(/[^a-zA-Z0-9]+/g, "_");
+  return `${base.toUpperCase()}_MODEL_MANIFEST`;
+}
 function parseFlags(argv) {
   let only;
   let strict = false;
   let functionsConfig;
   let output;
   let project;
+  let emitModels = false;
+  let emitModelConverters = false;
   for (const arg of argv) {
     if (arg === "--strict") {
       strict = true;
+    } else if (arg === "--emit-models") {
+      emitModels = true;
+    } else if (arg === "--emit-model-converters") {
+      emitModelConverters = 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);
@@ -681,7 +1365,7 @@ function parseFlags(argv) {
       project = arg.slice("--project=".length);
     }
   }
-  return { only, strict, functionsConfig, output, project };
+  return { only, strict, functionsConfig, output, project, emitModels, emitModelConverters };
 }
 function printUsageAndExit() {
   console.error(String.raw`generate-api-manifest
@@ -700,7 +1384,13 @@ Required flags:
 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.`);
+  --strict                   Fail when any validator binding is missing.
+  --emit-models              Opt in to emitting <NAMESPACE>_MODEL_MANIFEST. Off by default —
+                             pair with the runtime \`modelManifest\` option on \`runCli\` to
+                             enable the built-in \`model-info\` command.
+  --emit-model-converters    Opt in to including each field's converter expression text inside
+                             the model manifest. Off by default — useful for downstream tooling
+                             (e.g. dbx-components MCP) but unused by the CLI.`);
   process.exit(1);
 }
 try {