@dereekb/dbx-cli 13.37.0 → 13.39.0

package/firestore-query-manifest/main.js

@@ -0,0 +1,2063 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+
+// packages/dbx-cli/firestore-query-manifest/src/main.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "node:path";
+
+// packages/dbx-cli/firestore-query-manifest/package.json
+var package_default = {
+  name: "@dereekb/dbx-cli-firestore-query-manifest",
+  version: "13.39.0",
+  private: true,
+  type: "module",
+  devDependencies: {
+    eslint: "10.4.0"
+  },
+  peerDependencies: {
+    "@dereekb/dbx-cli": "13.39.0",
+    "@dereekb/util": "13.39.0"
+  }
+};
+
+// packages/util/src/lib/string/sort.ts
+var compareStrings = (a, b) => a.localeCompare(b);
+
+// packages/dbx-cli/src/lib/scan-helpers/emit-generated-ts.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { format, resolveConfig } from "prettier";
+// @__NO_SIDE_EFFECTS__
+function renderGroupedImportLines(imports) {
+  const importsByPackage = /* @__PURE__ */ new Map();
+  for (const { packageName, identifier } of imports) {
+    if (!packageName || !identifier) continue;
+    const set = importsByPackage.get(packageName) ?? /* @__PURE__ */ new Set();
+    set.add(identifier);
+    importsByPackage.set(packageName, set);
+  }
+  return [...importsByPackage.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([pkg, names]) => {
+    const sortedNames = [...names].sort(compareStrings).join(", ");
+    return `import { ${sortedNames} } from '${pkg}';`;
+  });
+}
+async function formatGeneratedTs(source, outputFile) {
+  const config = await resolveConfig(outputFile);
+  return format(source, { ...config, filepath: outputFile });
+}
+function writeGeneratedTsFile(input) {
+  const { outputFile, contents } = input;
+  const outputDir = dirname(outputFile);
+  let result;
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  if (existsSync(outputFile) && readFileSync(outputFile, "utf8") === contents) {
+    result = "unchanged";
+  } else {
+    writeFileSync(outputFile, contents);
+    result = "wrote";
+  }
+  return result;
+}
+
+// packages/dbx-cli/src/lib/scan-helpers/exported-from-package.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname as dirname2, isAbsolute, join, resolve } from "node:path";
+function isExportedFromPackage(input) {
+  const { packageRoot, identifier } = input;
+  const indexPath = locateBarrelEntry(packageRoot);
+  return indexPath ? findIdentifierInBarrelChain(indexPath, identifier, /* @__PURE__ */ new Set()) : false;
+}
+function locateBarrelEntry(packageRoot) {
+  const candidates = [join(packageRoot, "src", "index.ts"), join(packageRoot, "src", "index.d.ts"), join(packageRoot, "index.d.ts"), join(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) {
+  let result = false;
+  if (!visited.has(filePath)) {
+    visited.add(filePath);
+    const text = readFileTextSafe(filePath);
+    if (text !== void 0) {
+      result = barrelTextDeclaresIdentifier(text, identifier) || reExportChainHasIdentifier({ fromFile: filePath, text, identifier, visited });
+    }
+  }
+  return result;
+}
+function readFileTextSafe(filePath) {
+  let text;
+  try {
+    text = readFileSync2(filePath, "utf8");
+  } catch {
+    text = void 0;
+  }
+  return text;
+}
+function barrelTextDeclaresIdentifier(text, identifier) {
+  let result = false;
+  for (const pattern of EXPORT_DECL_PATTERNS) {
+    const re = new RegExp(pattern.source.replace("IDENT", escapeRegExp(identifier)));
+    if (re.test(text)) {
+      result = true;
+      break;
+    }
+  }
+  return result;
+}
+function reExportChainHasIdentifier(input) {
+  const { fromFile, text, identifier, visited } = input;
+  let result = false;
+  const dir = dirname2(fromFile);
+  for (const reExportTarget of collectReExportTargets(text)) {
+    const resolved = resolveReExport(dir, reExportTarget);
+    if (resolved && findIdentifierInBarrelChain(resolved, identifier, visited)) {
+      result = true;
+      break;
+    }
+  }
+  return result;
+}
+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) {
+  let result;
+  if (target.startsWith(".")) {
+    const candidate = isAbsolute(target) ? target : resolve(fromDir, target);
+    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) {
+  let result;
+  if (existsSync2(probe)) {
+    const stat = statSync(probe);
+    if (stat.isFile()) {
+      result = probe;
+    } else if (stat.isDirectory()) {
+      const sourceIndex = join(probe, "index.ts");
+      if (existsSync2(sourceIndex)) {
+        result = sourceIndex;
+      } else {
+        const declarationIndex = join(probe, "index.d.ts");
+        if (existsSync2(declarationIndex)) {
+          result = declarationIndex;
+        }
+      }
+    }
+  }
+  return result;
+}
+function escapeRegExp(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+
+// packages/dbx-cli/firestore-query-manifest/src/bind-factories.ts
+function bindQueryFactories(input) {
+  const { componentRoot, entries, isExported = isExportedFromPackage } = input;
+  const bound = [];
+  const warnings = [];
+  for (const entry of entries) {
+    const found = isExported({ packageRoot: componentRoot, identifier: entry.name });
+    if (!found) {
+      warnings.push(`[no-factory] ${entry.module} \xB7 ${entry.slug} \u2192 ${entry.name} not exported`);
+    }
+    bound.push({ entry, bound: found });
+  }
+  return { bound, warnings };
+}
+
+// packages/dbx-cli/firestore-query-manifest/src/emit.ts
+async function renderQueryManifest(input) {
+  const { outputFile, entries, projectName, namespace } = input;
+  const factoryImports = entries.filter((x) => x.bound).map((x) => ({ packageName: x.entry.module, identifier: x.entry.name }));
+  const importLines = renderGroupedImportLines(factoryImports);
+  const sorted = [...entries].sort((a, b) => compareStrings(a.entry.slug, b.entry.slug));
+  const source = `/* eslint-disable @nx/enforce-module-boundaries */
+// AUTO-GENERATED \u2014 DO NOT EDIT.
+// Run \`npx nx run ${projectName}:generate-firestore-query-manifest\` to refresh.
+
+${importLines.join("\n")}
+import { type CliFirestoreQueryManifest } from '@dereekb/dbx-cli';
+
+export const ${namespace}: CliFirestoreQueryManifest = [
+${sorted.map((x) => renderEntry(x)).join(",\n")}
+];
+`;
+  return formatGeneratedTs(source, outputFile);
+}
+function renderEntry({ entry, bound }) {
+  const fields = [
+    `slug: ${JSON.stringify(entry.slug)}`,
+    `name: ${JSON.stringify(entry.name)}`,
+    `module: ${JSON.stringify(entry.module)}`,
+    `subpath: ${JSON.stringify(entry.subpath)}`,
+    `model: ${JSON.stringify(entry.model)}`,
+    `collection: ${JSON.stringify(entry.collection)}`,
+    `isNested: ${entry.isNested ? "true" : "false"}`,
+    `scope: ${JSON.stringify(entry.scope)}`,
+    `signature: ${JSON.stringify(entry.signature)}`,
+    `params: ${renderParams(entry.params)}`,
+    entry.description ? `description: ${JSON.stringify(entry.description)}` : void 0,
+    entry.category ? `category: ${JSON.stringify(entry.category)}` : void 0,
+    entry.tags && entry.tags.length > 0 ? `tags: ${JSON.stringify(entry.tags)}` : void 0,
+    entry.example ? `example: ${JSON.stringify(entry.example)}` : void 0,
+    entry.relatedSlugs && entry.relatedSlugs.length > 0 ? `relatedSlugs: ${JSON.stringify(entry.relatedSlugs)}` : void 0,
+    entry.manual ? "manual: true" : void 0,
+    entry.skip ? "skip: true" : void 0,
+    entry.excluded ? "excluded: true" : void 0,
+    entry.dispatcher ? "dispatcher: true" : void 0,
+    bound ? `factory: ${entry.name}` : void 0
+  ];
+  return `  { ${fields.filter(Boolean).join(", ")} }`;
+}
+function renderParams(params) {
+  const items = params.map((param) => {
+    const parts = [`name: ${JSON.stringify(param.name)}`, `type: ${JSON.stringify(param.type)}`, param.description ? `description: ${JSON.stringify(param.description)}` : void 0, `optional: ${param.optional ? "true" : "false"}`];
+    return `{ ${parts.filter(Boolean).join(", ")} }`;
+  });
+  return `[${items.join(", ")}]`;
+}
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-build-manifest.ts
+import { relative, resolve as resolve2 } from "node:path";
+import { type as type3 } from "arktype";
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-schema.ts
+import { type } from "arktype";
+var DEFAULT_FIRESTORE_INDEX_DENSITY = "SPARSE_ALL";
+var FIRESTORE_WHERE_OPERATORS = ["==", "!=", "<", "<=", ">", ">=", "in", "not-in", "array-contains", "array-contains-any"];
+var ConstraintSequenceEntry = type({
+  kind: '"where" | "orderBy"',
+  fieldPath: "string",
+  "operator?": '"==" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "not-in" | "array-contains" | "array-contains-any"',
+  "direction?": '"asc" | "desc"',
+  "fromHelper?": "string"
+});
+var ConstraintSequence = type({
+  "pathLabel?": "string",
+  entries: ConstraintSequenceEntry.array()
+});
+var DerivedIndexField = type({
+  fieldPath: "string",
+  "order?": '"ASCENDING" | "DESCENDING"',
+  "arrayConfig?": '"CONTAINS"'
+});
+var DerivedComposite = type({
+  collectionGroup: "string",
+  queryScope: '"COLLECTION" | "COLLECTION_GROUP"',
+  fields: DerivedIndexField.array(),
+  density: '"SPARSE_ALL" | "SPARSE_ANY" | "DENSE"'
+});
+var DerivedFieldOverrideVariant = type({
+  queryScope: '"COLLECTION" | "COLLECTION_GROUP"',
+  "order?": '"ASCENDING" | "DESCENDING"',
+  "arrayConfig?": '"CONTAINS"'
+});
+var DerivedFieldOverride = type({
+  collectionGroup: "string",
+  fieldPath: "string",
+  variants: DerivedFieldOverrideVariant.array()
+});
+var ModelFirebaseIndexParamEntry = type({
+  name: "string",
+  type: "string",
+  description: "string",
+  optional: "boolean"
+});
+var ModelFirebaseIndexEntry = type({
+  slug: "string",
+  name: "string",
+  module: "string",
+  subpath: "string",
+  signature: "string",
+  description: "string",
+  model: "string",
+  collection: "string",
+  isNested: "boolean",
+  scope: '"COLLECTION" | "COLLECTION_GROUP"',
+  manual: "boolean",
+  skip: "boolean",
+  "specOnly?": "boolean",
+  "excluded?": "boolean",
+  category: "string",
+  params: ModelFirebaseIndexParamEntry.array(),
+  returns: "string",
+  tags: "string[]",
+  constraintSequences: ConstraintSequence.array(),
+  derivedComposites: DerivedComposite.array(),
+  derivedFieldOverrides: DerivedFieldOverride.array(),
+  "example?": "string",
+  "relatedSlugs?": "string[]",
+  "skillRefs?": "string[]",
+  "deprecated?": "boolean | string",
+  "since?": "string"
+});
+var ModelFirebaseIndexManifest = type({
+  version: "1",
+  source: "string",
+  module: "string",
+  generatedAt: "string",
+  generator: "string",
+  entries: ModelFirebaseIndexEntry.array()
+});
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-analyze.ts
+var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["==", "in"]);
+var RANGE_OPERATORS = /* @__PURE__ */ new Set(["<", "<=", ">", ">=", "!=", "not-in"]);
+var ARRAY_OPERATORS = /* @__PURE__ */ new Set(["array-contains", "array-contains-any"]);
+function analyzeModelFirebaseIndexEntries(entries) {
+  const out = [];
+  for (const entry of entries) {
+    out.push(analyzeEntry(entry));
+  }
+  return out;
+}
+function analyzeEntry(entry) {
+  if (entry.skip || entry.manual || entry.excluded || entry.constraintSequences.length === 0) {
+    return {
+      extractedEntry: entry,
+      derivedComposites: [],
+      derivedFieldOverrides: [],
+      warnings: []
+    };
+  }
+  const composites = [];
+  const fieldOverrides = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const sequence of entry.constraintSequences) {
+    const result = analyzeSequence({ sequence, collection: entry.collection, scope: entry.scope, factoryName: entry.name, allowArrayContainsAny: entry.allowArrayContainsAny });
+    for (const warning of result.warnings) {
+      warnings.push(warning);
+    }
+    if (result.kind === "composite") {
+      composites.push(result.composite);
+    } else if (result.kind === "fieldOverride") {
+      const key = result.fieldOverride.fieldPath;
+      const list = fieldOverrides.get(key) ?? [];
+      if (!list.some((v) => fieldOverrideVariantEquals(v, result.fieldOverride.variant))) {
+        list.push(result.fieldOverride.variant);
+      }
+      fieldOverrides.set(key, list);
+    }
+  }
+  const derivedFieldOverrides = [];
+  for (const [fieldPath, variants] of fieldOverrides) {
+    derivedFieldOverrides.push({ collectionGroup: entry.collection, fieldPath, variants });
+  }
+  return {
+    extractedEntry: entry,
+    derivedComposites: composites,
+    derivedFieldOverrides,
+    warnings
+  };
+}
+function bucketConstraints(entries) {
+  const equalities = [];
+  const ranges = [];
+  const arrays = [];
+  const orderBys = [];
+  const seenEqualityFields = /* @__PURE__ */ new Set();
+  const seenRangeFields = /* @__PURE__ */ new Set();
+  const seenArrayFields = /* @__PURE__ */ new Set();
+  const distinctFields = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    distinctFields.add(entry.fieldPath);
+    if (entry.kind === "orderBy") {
+      orderBys.push(entry);
+      continue;
+    }
+    const op = entry.operator ?? "==";
+    if (EQUALITY_OPERATORS.has(op)) {
+      if (!seenEqualityFields.has(entry.fieldPath)) {
+        seenEqualityFields.add(entry.fieldPath);
+        equalities.push(entry);
+      }
+    } else if (RANGE_OPERATORS.has(op)) {
+      if (!seenRangeFields.has(entry.fieldPath)) {
+        seenRangeFields.add(entry.fieldPath);
+        ranges.push(entry);
+      }
+    } else if (ARRAY_OPERATORS.has(op) && !seenArrayFields.has(entry.fieldPath)) {
+      seenArrayFields.add(entry.fieldPath);
+      arrays.push(entry);
+    }
+  }
+  return {
+    equalities,
+    ranges,
+    arrays,
+    orderBys,
+    distinctFieldCount: distinctFields.size
+  };
+}
+function analyzeSequence(input) {
+  const { sequence, collection, scope, factoryName, allowArrayContainsAny } = input;
+  const buckets = bucketConstraints(sequence.entries);
+  const warnings = [];
+  if (buckets.ranges.length > 1) {
+    warnings.push({ kind: "multiple-range-fields", factoryName, fields: buckets.ranges.map((r) => r.fieldPath) });
+  }
+  if (!allowArrayContainsAny) {
+    for (const arrayEntry of buckets.arrays) {
+      if (arrayEntry.operator === "array-contains-any") {
+        warnings.push({ kind: "unsupported-array-contains-any", factoryName, field: arrayEntry.fieldPath });
+      }
+    }
+  }
+  if (buckets.distinctFieldCount === 0) {
+    return { kind: "auto", warnings };
+  }
+  if (isSingleFieldQuery(buckets)) {
+    return analyzeSingleField({ buckets, collection, scope, warnings });
+  }
+  return analyzeMultiField({ buckets, sequenceEntries: sequence.entries, collection, scope, factoryName, warnings });
+}
+function isSingleFieldQuery(buckets) {
+  return buckets.distinctFieldCount === 1;
+}
+function analyzeSingleField(input) {
+  const { buckets, collection, scope, warnings } = input;
+  if (scope === "COLLECTION") {
+    return { kind: "auto", warnings };
+  }
+  const fieldPath = pickFirstFieldFromBuckets(buckets);
+  if (fieldPath === void 0) {
+    return { kind: "auto", warnings };
+  }
+  let variant;
+  if (buckets.arrays.length === 1) {
+    variant = { queryScope: "COLLECTION_GROUP", arrayConfig: "CONTAINS" };
+  } else if (buckets.orderBys.length === 1) {
+    const direction = buckets.orderBys[0].direction ?? "asc";
+    variant = { queryScope: "COLLECTION_GROUP", order: orderForDirection(direction) };
+  } else {
+    variant = { queryScope: "COLLECTION_GROUP", order: "ASCENDING" };
+  }
+  void collection;
+  return { kind: "fieldOverride", fieldOverride: { fieldPath, variant }, warnings };
+}
+function pickFirstFieldFromBuckets(buckets) {
+  let result;
+  if (buckets.equalities.length > 0) {
+    result = buckets.equalities[0].fieldPath;
+  } else if (buckets.ranges.length > 0) {
+    result = buckets.ranges[0].fieldPath;
+  } else if (buckets.arrays.length > 0) {
+    result = buckets.arrays[0].fieldPath;
+  } else if (buckets.orderBys.length > 0) {
+    result = buckets.orderBys[0].fieldPath;
+  }
+  return result;
+}
+function analyzeMultiField(input) {
+  const { buckets, collection, scope, factoryName, sequenceEntries, warnings } = input;
+  const fields = [];
+  const placedFields = /* @__PURE__ */ new Set();
+  const orderByByField = collectOrderByDirections({ orderBys: buckets.orderBys, factoryName, warnings });
+  for (const entry of sequenceEntries) {
+    if (entry.kind !== "where") {
+      continue;
+    }
+    if (placedFields.has(entry.fieldPath)) {
+      continue;
+    }
+    const op = entry.operator ?? "==";
+    if (EQUALITY_OPERATORS.has(op)) {
+      fields.push({ fieldPath: entry.fieldPath, order: "ASCENDING" });
+      placedFields.add(entry.fieldPath);
+    } else if (RANGE_OPERATORS.has(op)) {
+      const direction = orderByByField.get(entry.fieldPath) ?? "asc";
+      fields.push({ fieldPath: entry.fieldPath, order: orderForDirection(direction) });
+      placedFields.add(entry.fieldPath);
+    } else if (ARRAY_OPERATORS.has(op)) {
+      fields.push({ fieldPath: entry.fieldPath, arrayConfig: "CONTAINS" });
+      placedFields.add(entry.fieldPath);
+    }
+  }
+  for (const orderBy of buckets.orderBys) {
+    if (placedFields.has(orderBy.fieldPath)) {
+      continue;
+    }
+    const direction = orderBy.direction ?? "asc";
+    fields.push({ fieldPath: orderBy.fieldPath, order: orderForDirection(direction) });
+    placedFields.add(orderBy.fieldPath);
+  }
+  if (fields.length < 2) {
+    return { kind: "auto", warnings };
+  }
+  const composite = {
+    collectionGroup: collection,
+    queryScope: scope,
+    fields,
+    density: DEFAULT_FIRESTORE_INDEX_DENSITY
+  };
+  return { kind: "composite", composite, warnings };
+}
+function collectOrderByDirections(input) {
+  const { orderBys, factoryName, warnings } = input;
+  const out = /* @__PURE__ */ new Map();
+  const conflicts = /* @__PURE__ */ new Map();
+  for (const orderBy of orderBys) {
+    const direction = orderBy.direction ?? "asc";
+    const existing = out.get(orderBy.fieldPath);
+    if (existing === void 0) {
+      out.set(orderBy.fieldPath, direction);
+    } else if (existing !== direction) {
+      const set = conflicts.get(orderBy.fieldPath) ?? /* @__PURE__ */ new Set([existing]);
+      set.add(direction);
+      conflicts.set(orderBy.fieldPath, set);
+    }
+  }
+  for (const [field, dirs] of conflicts) {
+    warnings.push({ kind: "orderby-conflict", factoryName, field, directions: [...dirs] });
+  }
+  return out;
+}
+function orderForDirection(direction) {
+  return direction === "desc" ? "DESCENDING" : "ASCENDING";
+}
+function fieldOverrideVariantEquals(a, b) {
+  return a.queryScope === b.queryScope && a.order === b.order && a.arrayConfig === b.arrayConfig;
+}
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-extract.ts
+import { Node as Node2, SyntaxKind as SyntaxKind2 } from "ts-morph";
+
+// packages/dbx-cli/firestore-indexes/src/firestore-query-helpers.ts
+var FIRESTORE_QUERY_HELPERS = [
+  // Inequality helpers — single base where, no orderBy.
+  { name: "whereDateIsBefore", fieldArgIndex: 0, parts: [{ kind: "where", operator: "<" }] },
+  { name: "whereDateIsAfter", fieldArgIndex: 0, parts: [{ kind: "where", operator: ">" }] },
+  { name: "whereDateIsOnOrBefore", fieldArgIndex: 0, parts: [{ kind: "where", operator: "<=" }] },
+  { name: "whereDateIsOnOrAfter", fieldArgIndex: 0, parts: [{ kind: "where", operator: ">=" }] },
+  // *WithSort variants — base where + orderBy on the same field. Helper
+  // emits orderBy first, then where. Matches `constraint.template.ts`.
+  {
+    name: "whereDateIsBeforeWithSort",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" },
+      { kind: "where", operator: "<" }
+    ]
+  },
+  {
+    name: "whereDateIsAfterWithSort",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" },
+      { kind: "where", operator: ">" }
+    ]
+  },
+  {
+    name: "whereDateIsOnOrBeforeWithSort",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" },
+      { kind: "where", operator: "<=" }
+    ]
+  },
+  {
+    name: "whereDateIsOnOrAfterWithSort",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" },
+      { kind: "where", operator: ">=" }
+    ]
+  },
+  // Range helpers — two-bound where + orderBy.
+  {
+    name: "whereDateIsBetween",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "where", operator: ">=" },
+      { kind: "where", operator: "<=" },
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" }
+    ]
+  },
+  {
+    name: "whereDateIsInRange",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "where", operator: ">=" },
+      { kind: "where", operator: "<=" },
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" }
+    ]
+  },
+  // Dynamic single-field helper. The body branches on which DateRange bounds
+  // are present, but every branch operates on the same fieldPath argument and
+  // produces some subset of orderBy(field) + where(field,'>=') + where(field,'<=').
+  // For Firestore composite-index purposes the worst-case set collapses to a
+  // single ordered range index on that field — so the descriptor emits the
+  // worst case unconditionally. The body's internal conditionals are NOT
+  // scanned (helpers are opaque to the extractor; only tagged callers are).
+  {
+    name: "filterWithDateRange",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "where", operator: ">=" },
+      { kind: "where", operator: "<=" },
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" }
+    ]
+  },
+  // Prefix-string and child-doc helpers — range where + orderBy.
+  {
+    name: "whereStringValueHasPrefix",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "where", operator: ">=" },
+      { kind: "where", operator: "<" },
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" }
+    ]
+  },
+  {
+    name: "allChildDocumentsUnderRelativePath",
+    fieldArgIndex: 0,
+    directionArgIndex: 2,
+    defaultDirection: "asc",
+    parts: [
+      { kind: "where", operator: ">=" },
+      { kind: "where", operator: "<" },
+      { kind: "orderBy", useCallSiteDirection: true, direction: "asc" }
+    ]
+  }
+];
+function getFirestoreQueryHelperDescriptor(name) {
+  return FIRESTORE_QUERY_HELPERS.find((h) => h.name === name);
+}
+function expandFirestoreQueryHelper(input) {
+  const { descriptor, fieldPath, direction } = input;
+  const resolvedDirection = direction ?? descriptor.defaultDirection;
+  const out = [];
+  for (const part of descriptor.parts) {
+    if (part.kind === "where") {
+      const operator = part.operator ?? "==";
+      out.push({ kind: "where", fieldPath, operator, fromHelper: descriptor.name });
+    } else {
+      const direction2 = part.useCallSiteDirection && resolvedDirection !== void 0 ? resolvedDirection : part.direction ?? "asc";
+      out.push({ kind: "orderBy", fieldPath, direction: direction2, fromHelper: descriptor.name });
+    }
+  }
+  return out;
+}
+
+// packages/dbx-cli/src/lib/scan-helpers/scan-extract-utils.ts
+import { Node, SyntaxKind } from "ts-morph";
+function unwrapFenced(text) {
+  const trimmed = text.trim();
+  const match = /^```[a-zA-Z]*\n([\s\S]*?)\n```\s*$/.exec(trimmed);
+  return match ? match[1] : trimmed;
+}
+function splitListTagText(text) {
+  const out = [];
+  for (const piece of text.split(/[\s,]+/)) {
+    const trimmed = piece.trim();
+    if (trimmed.length > 0) {
+      out.push(trimmed);
+    }
+  }
+  return out;
+}
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-extract.ts
+var INDEX_MARKER = "dbxModelFirebaseIndex";
+var INDEX_DISPATCHER_TAG = "dbxModelFirebaseIndexDispatcher";
+var INDEX_MODEL_TAG = "dbxModelFirebaseIndexModel";
+var INDEX_SCOPE_TAG = "dbxModelFirebaseIndexScope";
+var INDEX_MANUAL_TAG = "dbxModelFirebaseIndexManual";
+var INDEX_SKIP_TAG = "dbxModelFirebaseIndexSkip";
+var INDEX_SPEC_FILES_ONLY_TAG = "dbxModelFirebaseIndexSpecFilesOnly";
+var INDEX_EXCLUDE_TAG = "dbxModelFirebaseIndexExclude";
+var INDEX_ALLOW_ARRAY_CONTAINS_ANY_TAG = "dbxModelFirebaseIndexAllowArrayContainsAny";
+var INDEX_CATEGORY_TAG = "dbxModelFirebaseIndexCategory";
+var INDEX_TAGS_TAG = "dbxModelFirebaseIndexTags";
+var INDEX_RELATED_TAG = "dbxModelFirebaseIndexRelated";
+var INDEX_SKILL_REFS_TAG = "dbxModelFirebaseIndexSkillRefs";
+var INDEX_SLUG_TAG = "dbxModelFirebaseIndexSlug";
+var INDEX_PATH_TAG = "dbxModelFirebaseIndexPath";
+var COMPLEX_BODY_SYNTAX_KINDS = /* @__PURE__ */ new Map([
+  [SyntaxKind2.IfStatement, "if"],
+  [SyntaxKind2.SwitchStatement, "switch"],
+  [SyntaxKind2.ConditionalExpression, "ternary"],
+  [SyntaxKind2.ForStatement, "loop"],
+  [SyntaxKind2.ForOfStatement, "loop"],
+  [SyntaxKind2.ForInStatement, "loop"],
+  [SyntaxKind2.WhileStatement, "loop"],
+  [SyntaxKind2.DoStatement, "loop"]
+]);
+var VALID_SCOPE_TAG_VALUES = /* @__PURE__ */ new Set(["COLLECTION", "COLLECTION_GROUP"]);
+var TRUE_TAG_VALUES = /* @__PURE__ */ new Set(["", "true", "yes"]);
+var FALSE_TAG_VALUES = /* @__PURE__ */ new Set(["false", "no"]);
+var WHERE_OPERATOR_SET = new Set(FIRESTORE_WHERE_OPERATORS);
+function extractModelFirebaseIndexEntries(input) {
+  const { project, identityResolver } = input;
+  const entries = [];
+  const warnings = [];
+  const slugProvenance = /* @__PURE__ */ new Map();
+  for (const sourceFile of project.getSourceFiles()) {
+    const filePath = sourceFile.getFilePath();
+    const candidates = collectTaggedFunctions(sourceFile);
+    for (const candidate of candidates) {
+      const built = buildEntry({ candidate, filePath, identityResolver });
+      if (built.kind === "ok") {
+        const previous = slugProvenance.get(built.entry.slug);
+        if (previous === void 0) {
+          slugProvenance.set(built.entry.slug, { name: built.entry.name, filePath, line: built.entry.line });
+          entries.push(built.entry);
+        } else {
+          warnings.push({ kind: "duplicate-slug", severity: "warning", name: built.entry.name, slug: built.entry.slug, previousName: previous.name, filePath, line: built.entry.line });
+        }
+      }
+      for (const warning of built.warnings) {
+        warnings.push(warning);
+      }
+    }
+  }
+  return { entries, warnings };
+}
+function collectTaggedFunctions(sourceFile) {
+  const out = [];
+  for (const decl of sourceFile.getFunctions()) {
+    if (!decl.isExported()) {
+      continue;
+    }
+    const jsDocs = findTaggedDocs(decl.getJsDocs());
+    if (jsDocs.length > 0) {
+      out.push({ decl, jsDocs });
+    }
+  }
+  return out;
+}
+function findTaggedDocs(jsDocs) {
+  let hasMarker = false;
+  for (const doc of jsDocs) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() === INDEX_MARKER) {
+        hasMarker = true;
+      }
+    }
+  }
+  return hasMarker ? jsDocs : [];
+}
+function readJsDocTags(jsDocs) {
+  const state = {
+    summaries: [],
+    slug: void 0,
+    model: void 0,
+    scope: void 0,
+    manual: false,
+    skip: false,
+    specOnly: false,
+    excluded: false,
+    dispatcher: false,
+    allowArrayContainsAny: false,
+    category: void 0,
+    explicitTags: [],
+    relatedSlugs: [],
+    skillRefs: [],
+    examples: [],
+    paramDescriptions: /* @__PURE__ */ new Map(),
+    returnsText: void 0,
+    deprecated: void 0,
+    since: void 0,
+    paths: []
+  };
+  for (const jsDoc of jsDocs) {
+    const description = jsDoc.getDescription().trim();
+    if (description.length > 0) {
+      state.summaries.push(description);
+    }
+    for (const tag of jsDoc.getTags()) {
+      const tagName = tag.getTagName();
+      const text = tag.getCommentText()?.trim() ?? "";
+      if (tagName === "param") {
+        const paramName = tag.getName?.() ?? extractParamName(tag.getText());
+        if (paramName !== void 0 && paramName.length > 0) {
+          state.paramDescriptions.set(paramName, text);
+        }
+      } else {
+        applyTag(state, tagName, text);
+      }
+    }
+  }
+  return {
+    summary: state.summaries.join("\n\n"),
+    slug: state.slug,
+    model: state.model,
+    scope: state.scope,
+    manual: state.manual,
+    skip: state.skip,
+    specOnly: state.specOnly,
+    excluded: state.excluded,
+    dispatcher: state.dispatcher,
+    allowArrayContainsAny: state.allowArrayContainsAny,
+    category: state.category,
+    explicitTags: state.explicitTags,
+    relatedSlugs: state.relatedSlugs,
+    skillRefs: state.skillRefs,
+    examples: state.examples,
+    paramDescriptions: state.paramDescriptions,
+    returnsText: state.returnsText,
+    deprecated: state.deprecated,
+    since: state.since,
+    paths: state.paths.map((p) => [...p])
+  };
+}
+function applyTag(state, name, text) {
+  switch (name) {
+    case INDEX_MARKER:
+      break;
+    case INDEX_SLUG_TAG:
+      state.slug = text;
+      break;
+    case INDEX_MODEL_TAG:
+      state.model = text;
+      break;
+    case INDEX_SCOPE_TAG:
+      state.scope = text;
+      break;
+    case INDEX_MANUAL_TAG:
+      state.manual = parseBooleanTag(text) ?? true;
+      break;
+    case INDEX_SKIP_TAG:
+      state.skip = parseBooleanTag(text) ?? true;
+      break;
+    case INDEX_SPEC_FILES_ONLY_TAG:
+      state.specOnly = parseBooleanTag(text) ?? true;
+      break;
+    case INDEX_EXCLUDE_TAG:
+      state.excluded = parseBooleanTag(text) ?? true;
+      break;
+    case INDEX_DISPATCHER_TAG:
+      state.dispatcher = parseBooleanTag(text) ?? true;
+      break;
+    case INDEX_ALLOW_ARRAY_CONTAINS_ANY_TAG:
+      state.allowArrayContainsAny = parseBooleanTag(text) ?? true;
+      break;
+    case INDEX_CATEGORY_TAG:
+      state.category = text;
+      break;
+    case INDEX_TAGS_TAG:
+      for (const tag of splitListTagText(text)) {
+        state.explicitTags.push(tag.toLowerCase());
+      }
+      break;
+    case INDEX_RELATED_TAG:
+      for (const slug of splitListTagText(text)) {
+        state.relatedSlugs.push(slug);
+      }
+      break;
+    case INDEX_SKILL_REFS_TAG:
+      for (const ref of splitListTagText(text)) {
+        state.skillRefs.push(ref);
+      }
+      break;
+    case INDEX_PATH_TAG: {
+      const fields = [...splitListTagText(text)];
+      if (fields.length > 0) {
+        state.paths.push(fields);
+      }
+      break;
+    }
+    case "example":
+      state.examples.push(unwrapFenced(text));
+      break;
+    case "returns":
+    case "return":
+      state.returnsText = text;
+      break;
+    case "deprecated":
+      state.deprecated = text.length > 0 ? text : true;
+      break;
+    case "since":
+      if (text.length > 0) {
+        state.since = text;
+      }
+      break;
+    default:
+      break;
+  }
+}
+function parseBooleanTag(text) {
+  const lowered = text.trim().toLowerCase();
+  let result;
+  if (TRUE_TAG_VALUES.has(lowered)) {
+    result = true;
+  } else if (FALSE_TAG_VALUES.has(lowered)) {
+    result = false;
+  }
+  return result;
+}
+function extractParamName(rawTag) {
+  const match = /@param\s+(?:\{[^}]*\}\s+)?(\S+)/.exec(rawTag);
+  return match?.[1];
+}
+function buildEntry(input) {
+  const { candidate, filePath, identityResolver } = input;
+  const warnings = [];
+  const name = candidate.decl.getName();
+  const line = candidate.decl.getStartLineNumber();
+  if (name === void 0 || name.length === 0) {
+    warnings.push({ kind: "missing-name", severity: "warning", filePath, line });
+    return { kind: "skipped", warnings };
+  }
+  const tags = readJsDocTags(candidate.jsDocs);
+  const resolved = resolveIdentity({ tags, identityResolver, name, filePath, line, warnings });
+  if (resolved === void 0) {
+    return { kind: "skipped", warnings };
+  }
+  const scope = resolveScope({ tags, resolved, name, filePath, line, warnings });
+  if (scope === void 0) {
+    return { kind: "skipped", warnings };
+  }
+  const modelTag = tags.model;
+  const entry = composeEntry({ candidate, tags, modelTag, resolved, scope, name, line, filePath, warnings });
+  return { kind: "ok", entry, warnings };
+}
+function resolveIdentity(input) {
+  const { tags, identityResolver, name, filePath, line, warnings } = input;
+  if (tags.model === void 0 || tags.model.length === 0) {
+    warnings.push({ kind: "missing-model-tag", severity: "warning", name, filePath, line });
+    return void 0;
+  }
+  const resolved = identityResolver.lookupByTypeName(tags.model);
+  if (resolved === void 0) {
+    warnings.push({ kind: "unresolved-model", severity: "warning", name, model: tags.model, filePath, line });
+    return void 0;
+  }
+  return resolved;
+}
+function composeEntry(input) {
+  const { candidate, tags, modelTag, resolved, scope, name, line, filePath, warnings } = input;
+  const slug = tags.slug && tags.slug.length > 0 ? tags.slug : toKebabCase(name);
+  const params = collectParams(candidate.decl, tags.paramDescriptions);
+  const returnType = candidate.decl.getReturnTypeNode()?.getText() ?? candidate.decl.getReturnType().getText();
+  const paramSignature = params.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ");
+  const returnSignature = returnType.length > 0 ? returnType : "unknown";
+  const signature = `${name}(${paramSignature}): ${returnSignature}`;
+  const returns = tags.returnsText && tags.returnsText.length > 0 ? tags.returnsText : returnType;
+  const example = tags.examples.length > 0 ? tags.examples[0] : "";
+  const category = tags.category && tags.category.length > 0 ? tags.category : "misc";
+  const tagSet = buildTagSet({ name, slug, summary: tags.summary, explicit: tags.explicitTags, category, model: modelTag });
+  const { constraintSequences, dispatcherDelegates } = resolveConstraintSequences({ candidate, tags, name, line, filePath, warnings });
+  if (tags.excluded) {
+    warnings.push({ kind: "excluded-factory", severity: "warning", name, filePath, line });
+  }
+  return {
+    slug,
+    name,
+    model: modelTag,
+    collection: resolved.collection,
+    isNested: resolved.isNested,
+    scope,
+    manual: tags.manual,
+    skip: tags.skip,
+    specOnly: tags.specOnly,
+    excluded: tags.excluded,
+    dispatcher: tags.dispatcher,
+    dispatcherDelegates,
+    allowArrayContainsAny: tags.allowArrayContainsAny,
+    category,
+    signature,
+    description: tags.summary,
+    params,
+    returns,
+    tags: tagSet,
+    ...tags.relatedSlugs.length > 0 ? { relatedSlugs: tags.relatedSlugs } : {},
+    ...tags.skillRefs.length > 0 ? { skillRefs: tags.skillRefs } : {},
+    example,
+    constraintSequences,
+    ...tags.deprecated === void 0 ? {} : { deprecated: tags.deprecated },
+    ...tags.since === void 0 ? {} : { since: tags.since },
+    filePath,
+    line
+  };
+}
+function resolveConstraintSequences(input) {
+  const { candidate, tags, name, line, filePath, warnings } = input;
+  const bodyResult = extractConstraintsFromBody({ decl: candidate.decl, factoryName: name, filePath, dispatcher: tags.dispatcher });
+  for (const warning of bodyResult.warnings) {
+    warnings.push(warning);
+  }
+  if (tags.skip || tags.specOnly || tags.dispatcher || bodyResult.skipped) {
+    return { constraintSequences: [], dispatcherDelegates: bodyResult.dispatcherDelegates };
+  }
+  const constraintSequences = buildConstraintSequences({
+    bodyEntries: bodyResult.entries,
+    conditionalFields: bodyResult.conditionalFields,
+    paths: tags.paths,
+    factoryName: name,
+    filePath,
+    line,
+    warnings
+  });
+  return { constraintSequences, dispatcherDelegates: [] };
+}
+function resolveScope(input) {
+  const { tags, resolved, name, filePath, line, warnings } = input;
+  let result;
+  if (tags.scope === void 0 || tags.scope.length === 0) {
+    result = resolved.isNested ? "COLLECTION_GROUP" : "COLLECTION";
+  } else if (VALID_SCOPE_TAG_VALUES.has(tags.scope)) {
+    result = tags.scope;
+  } else {
+    warnings.push({ kind: "unsupported-scope", severity: "warning", name, scope: tags.scope, filePath, line });
+    result = void 0;
+  }
+  return result;
+}
+function collectParams(decl, descriptions) {
+  const params = decl.getParameters();
+  const out = [];
+  for (const param of params) {
+    const name = param.getName();
+    const typeNode = param.getTypeNode()?.getText();
+    const type4 = typeNode ?? param.getType().getText() ?? "unknown";
+    const description = descriptions.get(name) ?? "";
+    const optional = param.isOptional() || param.hasInitializer();
+    out.push({ name, type: type4, description, optional });
+  }
+  return out;
+}
+function buildConstraintSequences(input) {
+  const { bodyEntries, conditionalFields, paths, factoryName, filePath, line, warnings } = input;
+  if (paths.length === 0) {
+    if (conditionalFields.length > 0) {
+      warnings.push({ kind: "missing-paths", severity: "warning", name: factoryName, conditionalFields, filePath, line });
+    }
+    return [{ pathLabel: "all", entries: [...bodyEntries] }];
+  }
+  const entriesByField = /* @__PURE__ */ new Map();
+  for (const entry of bodyEntries) {
+    const list = entriesByField.get(entry.fieldPath) ?? [];
+    list.push(entry);
+    entriesByField.set(entry.fieldPath, list);
+  }
+  const sequences = [];
+  for (const path of paths) {
+    const selected = [];
+    let matchedAnyField = false;
+    for (const field of path) {
+      const entriesForField = entriesByField.get(field);
+      if (entriesForField === void 0) {
+        warnings.push({ kind: "unknown-path-field", severity: "warning", name: factoryName, field, filePath, line });
+        continue;
+      }
+      matchedAnyField = true;
+      for (const entry of entriesForField) {
+        selected.push(entry);
+      }
+    }
+    if (!matchedAnyField) {
+      continue;
+    }
+    sequences.push({ pathLabel: path.join(","), entries: selected });
+  }
+  return sequences;
+}
+function extractConstraintsFromBody(input) {
+  const { decl, factoryName, filePath, dispatcher } = input;
+  const entries = [];
+  const conditionalFieldSet = /* @__PURE__ */ new Set();
+  const warnings = [];
+  const body = decl.getBody();
+  if (dispatcher) {
+    const violation = body === void 0 ? void 0 : findFirstConstraintCall(body);
+    if (violation !== void 0) {
+      warnings.push({ kind: "non-delegating-dispatcher", severity: "error", name: factoryName, callee: violation.callee, filePath, line: violation.line });
+    }
+    const dispatcherDelegates = body === void 0 ? [] : collectDispatcherDelegates(body);
+    return { entries, conditionalFields: [], warnings, skipped: true, dispatcherDelegates };
+  }
+  if (body !== void 0) {
+    const branch = findFirstBranchNode(body);
+    if (branch !== void 0) {
+      warnings.push({ kind: "complex-query-body", severity: "error", name: factoryName, branchKind: branch.branchKind, filePath, line: branch.line });
+      return { entries, conditionalFields: [], warnings, skipped: true, dispatcherDelegates: [] };
+    }
+  }
+  const initialVisited = /* @__PURE__ */ new Set([buildDeclKey(decl)]);
+  walkBodyInto({
+    decl,
+    factoryName,
+    filePath,
+    visited: initialVisited,
+    warnings,
+    entries,
+    conditionalFieldSet,
+    forcedConditional: void 0
+  });
+  const conditionalFields = [];
+  const seenConditional = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (conditionalFieldSet.has(entry.fieldPath) && !seenConditional.has(entry.fieldPath)) {
+      seenConditional.add(entry.fieldPath);
+      conditionalFields.push(entry.fieldPath);
+    }
+  }
+  return { entries, conditionalFields, warnings, skipped: false, dispatcherDelegates: [] };
+}
+function collectDispatcherDelegates(bodyNode) {
+  const calls = bodyNode.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  calls.sort((a, b) => a.getStart() - b.getStart());
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const call of calls) {
+    const expression = call.getExpression();
+    if (!Node2.isIdentifier(expression)) {
+      continue;
+    }
+    const name = expression.getText();
+    if (name.length === 0 || seen.has(name)) {
+      continue;
+    }
+    if (name === "where" || name === "orderBy" || getFirestoreQueryHelperDescriptor(name) !== void 0) {
+      continue;
+    }
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
+function walkBodyInto(input) {
+  const { decl, forcedConditional } = input;
+  const body = decl.getBody();
+  if (body === void 0) {
+    return;
+  }
+  const calls = body.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  calls.sort((a, b) => a.getStart() - b.getStart());
+  for (const call of calls) {
+    const callee = resolveCallExpressionCallee(call);
+    if (callee === void 0) {
+      continue;
+    }
+    const callConditional = forcedConditional ?? isWithinConditionalBranch(call, body);
+    processCallExpression({ ...input, body, call, callee, callConditional });
+  }
+}
+function resolveCallExpressionCallee(call) {
+  const expression = call.getExpression();
+  const isIdentifierCallee = Node2.isIdentifier(expression);
+  const isPropertyCallee = Node2.isPropertyAccessExpression(expression);
+  if (!isIdentifierCallee && !isPropertyCallee) {
+    return void 0;
+  }
+  const name = isIdentifierCallee ? expression.getText() : expression.getName();
+  if (name === void 0) {
+    return void 0;
+  }
+  return { expression, name, isIdentifierCallee };
+}
+function processCallExpression(input) {
+  const { callee } = input;
+  if (callee.name === "where") {
+    handleWhereCall(input);
+    return;
+  }
+  if (callee.name === "orderBy") {
+    handleOrderByCall(input);
+    return;
+  }
+  const descriptor = getFirestoreQueryHelperDescriptor(callee.name);
+  if (descriptor !== void 0) {
+    handleHelperCall({ ...input, descriptor });
+    return;
+  }
+  if (callee.isIdentifierCallee) {
+    tryTransitiveResolution({
+      call: input.call,
+      identifier: callee.expression,
+      calleeName: callee.name,
+      callConditional: input.callConditional,
+      factoryName: input.factoryName,
+      filePath: input.filePath,
+      visited: input.visited,
+      warnings: input.warnings,
+      entries: input.entries,
+      conditionalFieldSet: input.conditionalFieldSet
+    });
+  }
+}
+function pushUnresolvedFieldWarning(input, calleeLabel) {
+  input.warnings.push({ kind: "unresolved-field", severity: "warning", name: input.factoryName, callee: calleeLabel, filePath: input.filePath, line: input.call.getStartLineNumber() });
+}
+function recordConstraintEntry(input, entry) {
+  input.entries.push(entry);
+  if (input.callConditional) {
+    input.conditionalFieldSet.add(entry.fieldPath);
+  }
+}
+function handleWhereCall(input) {
+  const parsed = parseWhereCall(input.call);
+  if (parsed === void 0) {
+    pushUnresolvedFieldWarning(input, "where");
+    return;
+  }
+  recordConstraintEntry(input, parsed);
+}
+function handleOrderByCall(input) {
+  const parsed = parseOrderByCall(input.call);
+  if (parsed === void 0) {
+    pushUnresolvedFieldWarning(input, "orderBy");
+    return;
+  }
+  recordConstraintEntry(input, parsed);
+}
+function handleHelperCall(input) {
+  const { call, callee, descriptor } = input;
+  const args = call.getArguments();
+  const fieldArg = args[descriptor.fieldArgIndex];
+  const fieldPath = fieldArg === void 0 ? void 0 : readStringLiteral(fieldArg);
+  if (fieldPath === void 0) {
+    pushUnresolvedFieldWarning(input, callee.name);
+    return;
+  }
+  const direction = descriptor.directionArgIndex === void 0 ? void 0 : readDirectionLiteral(args[descriptor.directionArgIndex]);
+  for (const expanded of expandFirestoreQueryHelper({ descriptor, fieldPath, direction })) {
+    input.entries.push(expanded);
+  }
+  if (input.callConditional) {
+    input.conditionalFieldSet.add(fieldPath);
+  }
+}
+function tryTransitiveResolution(input) {
+  const { call, identifier, calleeName, callConditional, factoryName, filePath, visited, warnings, entries, conditionalFieldSet } = input;
+  const resolved = resolveCalleeDeclaration(identifier);
+  if (resolved === void 0) {
+    return;
+  }
+  const returnType = readReturnTypeText(resolved.decl);
+  if (!isConstraintRelatedReturnType(returnType)) {
+    return;
+  }
+  if (!resolved.hasBody) {
+    warnings.push({ kind: "unresolvable-transitive-callee", severity: "warning", name: factoryName, callee: calleeName, filePath, line: call.getStartLineNumber() });
+    return;
+  }
+  const calleeKey = buildDeclKey(resolved.decl);
+  if (visited.has(calleeKey)) {
+    warnings.push({ kind: "transitive-cycle", severity: "warning", name: factoryName, callee: calleeName, filePath, line: call.getStartLineNumber() });
+    return;
+  }
+  if (!isIndexTagged(resolved.decl)) {
+    const calleeFilePath = resolved.decl.getSourceFile().getFilePath();
+    const calleeLine = resolved.decl.getStartLineNumber();
+    warnings.push({ kind: "unannotated-query-helper", severity: "warning", name: factoryName, callee: calleeName, calleeFilePath, calleeLine, filePath, line: call.getStartLineNumber() });
+  }
+  const nextVisited = /* @__PURE__ */ new Set([...visited, calleeKey]);
+  walkBodyInto({
+    decl: resolved.decl,
+    factoryName,
+    filePath,
+    visited: nextVisited,
+    warnings,
+    entries,
+    conditionalFieldSet,
+    forcedConditional: callConditional
+  });
+}
+function resolveCalleeDeclaration(identifier) {
+  const symbol = identifier.getSymbol();
+  if (symbol === void 0) {
+    return void 0;
+  }
+  const aliased = symbol.getAliasedSymbol();
+  const declarations = (aliased ?? symbol).getDeclarations();
+  let result;
+  for (const d of declarations) {
+    if (Node2.isFunctionDeclaration(d) && d.isExported()) {
+      result = { decl: d, hasBody: d.getBody() !== void 0 };
+      break;
+    }
+  }
+  return result;
+}
+function isConstraintRelatedReturnType(returnType) {
+  if (returnType.length === 0) {
+    return false;
+  }
+  return returnType.includes("FirestoreQueryConstraint");
+}
+function readReturnTypeText(decl) {
+  const node = decl.getReturnTypeNode();
+  return node === void 0 ? decl.getReturnType().getText() : node.getText();
+}
+function isIndexTagged(decl) {
+  let result = false;
+  for (const doc of decl.getJsDocs()) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() === INDEX_MARKER) {
+        result = true;
+        break;
+      }
+    }
+    if (result) {
+      break;
+    }
+  }
+  return result;
+}
+function buildDeclKey(decl) {
+  const name = decl.getName() ?? "<anonymous>";
+  return `${decl.getSourceFile().getFilePath()}::${name}`;
+}
+function findFirstBranchNode(bodyNode) {
+  let result;
+  for (const [syntaxKind, branchKind] of COMPLEX_BODY_SYNTAX_KINDS) {
+    const nodes = bodyNode.getDescendantsOfKind(syntaxKind);
+    if (nodes.length > 0) {
+      const first = nodes.sort((a, b) => a.getStart() - b.getStart())[0];
+      const line = first.getStartLineNumber();
+      if (result === void 0 || line < result.line) {
+        result = { branchKind, line };
+      }
+    }
+  }
+  return result;
+}
+function getCallExpressionName(expression) {
+  if (Node2.isIdentifier(expression)) {
+    return expression.getText();
+  }
+  if (Node2.isPropertyAccessExpression(expression)) {
+    return expression.getName();
+  }
+  return void 0;
+}
+function findFirstConstraintCall(bodyNode) {
+  const calls = bodyNode.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  calls.sort((a, b) => a.getStart() - b.getStart());
+  let result;
+  for (const call of calls) {
+    const expression = call.getExpression();
+    const calleeName = getCallExpressionName(expression);
+    if (calleeName === void 0) {
+      continue;
+    }
+    if (calleeName === "where" || calleeName === "orderBy" || getFirestoreQueryHelperDescriptor(calleeName) !== void 0) {
+      result = { callee: calleeName, line: call.getStartLineNumber() };
+      break;
+    }
+  }
+  return result;
+}
+function isWithinConditionalBranch(call, bodyNode) {
+  let node = call.getParent();
+  let result = false;
+  while (node !== void 0 && node !== bodyNode) {
+    const kind = node.getKind();
+    if (kind === SyntaxKind2.IfStatement || kind === SyntaxKind2.ConditionalExpression || kind === SyntaxKind2.SwitchStatement || kind === SyntaxKind2.CaseClause) {
+      result = true;
+      break;
+    }
+    node = node.getParent();
+  }
+  return result;
+}
+function parseWhereCall(call) {
+  const args = call.getArguments();
+  if (args.length < 2) {
+    return void 0;
+  }
+  const fieldPath = readStringLiteral(args[0]);
+  if (fieldPath === void 0) {
+    return void 0;
+  }
+  const opLiteral = readStringLiteral(args[1]);
+  let operator = "==";
+  if (opLiteral !== void 0 && WHERE_OPERATOR_SET.has(opLiteral)) {
+    operator = opLiteral;
+  }
+  return { kind: "where", fieldPath, operator };
+}
+function parseOrderByCall(call) {
+  const args = call.getArguments();
+  if (args.length === 0) {
+    return void 0;
+  }
+  const fieldPath = readStringLiteral(args[0]);
+  if (fieldPath === void 0) {
+    return void 0;
+  }
+  const direction = readDirectionLiteral(args[1]) ?? "asc";
+  return { kind: "orderBy", fieldPath, direction };
+}
+function readStringLiteral(node) {
+  let result;
+  if (node !== void 0 && (Node2.isStringLiteral(node) || Node2.isNoSubstitutionTemplateLiteral(node))) {
+    result = node.getLiteralText();
+  }
+  return result;
+}
+function readDirectionLiteral(node) {
+  const text = readStringLiteral(node);
+  let result;
+  if (text === "asc" || text === "desc") {
+    result = text;
+  }
+  return result;
+}
+function toKebabCase(name) {
+  if (name.length === 0) {
+    return "";
+  }
+  const withSeparators = name.replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").replaceAll(/_+/g, "-").replaceAll(/\s+/g, "-");
+  return withSeparators.toLowerCase();
+}
+var STOPWORDS = /* @__PURE__ */ new Set(["the", "a", "an", "and", "or", "of", "for", "to", "in", "on", "at", "is", "are", "be", "this", "that", "with", "when", "if", "as", "by", "from", "into", "returns", "return", "query"]);
+function buildTagSet(input) {
+  const { name, slug, summary, explicit, category, model } = input;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  function add(token) {
+    const lower = token.toLowerCase();
+    if (lower.length === 0 || seen.has(lower)) {
+      return;
+    }
+    seen.add(lower);
+    out.push(lower);
+  }
+  for (const tag of explicit) {
+    add(tag);
+  }
+  add(category);
+  add(model);
+  for (const piece of slug.split("-")) {
+    add(piece);
+  }
+  add(name);
+  for (const piece of toKebabCase(model).split("-")) {
+    add(piece);
+  }
+  if (explicit.length === 0) {
+    const summaryTokens = summary.toLowerCase().replaceAll(/[^a-z0-9\s]+/g, " ").split(/\s+/).filter((t) => t.length > 2 && !STOPWORDS.has(t));
+    let added = 0;
+    for (const token of summaryTokens) {
+      if (added >= 8) {
+        break;
+      }
+      const before = out.length;
+      add(token);
+      if (out.length > before) {
+        added += 1;
+      }
+    }
+  }
+  return out;
+}
+
+// packages/dbx-cli/firestore-indexes/src/firestore-model-identity-resolver.ts
+import { Node as Node3, SyntaxKind as SyntaxKind3 } from "ts-morph";
+function buildIdentityResolverFromProject(project) {
+  const records = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    for (const statement of sourceFile.getVariableStatements()) {
+      for (const declaration of statement.getDeclarations()) {
+        const initializer = declaration.getInitializer();
+        if (initializer === void 0 || !Node3.isCallExpression(initializer)) {
+          continue;
+        }
+        const parsed = parseFirestoreModelIdentityCall(initializer);
+        if (parsed === void 0) {
+          continue;
+        }
+        records.push({
+          modelType: parsed.modelType,
+          collection: parsed.collection,
+          isNested: parsed.isNested,
+          identityConstName: declaration.getName()
+        });
+      }
+    }
+  }
+  return buildResolverFromRecords(records);
+}
+function parseFirestoreModelIdentityCall(call) {
+  const expression = call.getExpression();
+  let calleeName;
+  if (Node3.isIdentifier(expression)) {
+    calleeName = expression.getText();
+  } else if (Node3.isPropertyAccessExpression(expression)) {
+    calleeName = expression.getName();
+  }
+  if (calleeName !== "firestoreModelIdentity") {
+    return void 0;
+  }
+  const args = call.getArguments();
+  if (args.length === 0) {
+    return void 0;
+  }
+  const firstArg = args[0];
+  let isNested = false;
+  let stringArgsStart = 0;
+  if (firstArg.getKind() === SyntaxKind3.Identifier || firstArg.getKind() === SyntaxKind3.PropertyAccessExpression) {
+    isNested = true;
+    stringArgsStart = 1;
+  } else if (firstArg.getKind() !== SyntaxKind3.StringLiteral && firstArg.getKind() !== SyntaxKind3.NoSubstitutionTemplateLiteral) {
+    return void 0;
+  }
+  const stringArgs = [];
+  let invalidArg = false;
+  for (let i = stringArgsStart; i < args.length; i += 1) {
+    const arg = args[i];
+    if (Node3.isStringLiteral(arg) || Node3.isNoSubstitutionTemplateLiteral(arg)) {
+      stringArgs.push(arg.getLiteralText());
+    } else {
+      invalidArg = true;
+      break;
+    }
+  }
+  let result;
+  if (!invalidArg && stringArgs.length > 0) {
+    const modelType = stringArgs[0];
+    const collection = stringArgs.length >= 2 ? stringArgs[1] : modelType;
+    result = { modelType, collection, isNested };
+  }
+  return result;
+}
+function buildResolverFromRecords(records) {
+  const byModelType = /* @__PURE__ */ new Map();
+  const byIdentityConst = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!byModelType.has(record.modelType)) {
+      byModelType.set(record.modelType, record);
+    }
+    if (!byIdentityConst.has(record.identityConstName)) {
+      byIdentityConst.set(record.identityConstName, record);
+    }
+  }
+  function lookupByTypeName(typeName) {
+    const camel = toCamelCase(typeName);
+    let result = byModelType.get(camel);
+    result ??= byIdentityConst.get(`${camel}Identity`);
+    if (result === void 0) {
+      const lower = camel.toLowerCase();
+      result = records.find((r) => r.modelType.toLowerCase() === lower);
+    }
+    return result;
+  }
+  return {
+    lookupByTypeName,
+    lookupByModelType: (modelType) => byModelType.get(modelType),
+    lookupByIdentityConst: (identityConstName) => byIdentityConst.get(identityConstName),
+    all: () => records
+  };
+}
+function toCamelCase(typeName) {
+  if (typeName.length === 0) {
+    return typeName;
+  }
+  const firstChar = typeName.charAt(0);
+  let result;
+  if (firstChar >= "A" && firstChar <= "Z") {
+    result = firstChar.toLowerCase() + typeName.slice(1);
+  } else {
+    result = typeName;
+  }
+  return result;
+}
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-scan-config-schema.ts
+import { type as type2 } from "arktype";
+var ModelFirebaseIndexScanSection = type2({
+  "source?": "string",
+  "module?": "string",
+  include: "string[] >= 1",
+  "exclude?": "string[]",
+  "out?": "string"
+});
+var ModelFirebaseIndexScanConfig = type2({
+  version: "1",
+  modelFirebaseIndex: ModelFirebaseIndexScanSection
+});
+var DEFAULT_MODEL_FIREBASE_INDEX_SCAN_OUT_PATH = "model-firebase-index.mcp.generated.json";
+var MODEL_FIREBASE_INDEX_SCAN_CONFIG_FILENAME = "dbx-mcp.scan.json";
+
+// packages/dbx-cli/src/lib/scan-helpers/scan-io.ts
+import { glob as fsGlob, readFile as nodeReadFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
+import { Project } from "ts-morph";
+var defaultReadFile = (path) => nodeReadFile(path, "utf-8");
+var defaultGlobber = async (input) => {
+  const { projectRoot, include, exclude } = input;
+  const excludeMatchers = exclude.map(globToRegex);
+  const seen = /* @__PURE__ */ new Set();
+  const matches = [];
+  for (const pattern of include) {
+    for await (const match of fsGlob(pattern, { cwd: projectRoot })) {
+      if (excludeMatchers.some((rx) => rx.test(match))) {
+        continue;
+      }
+      if (!seen.has(match)) {
+        seen.add(match);
+        matches.push(match);
+      }
+    }
+  }
+  return matches;
+};
+async function loadPackageName(packagePath, readFile) {
+  let raw = null;
+  try {
+    raw = await readFile(packagePath);
+  } catch {
+    raw = null;
+  }
+  let result;
+  if (raw === null) {
+    result = { kind: "fail", outcome: { kind: "no-package", packagePath } };
+  } else {
+    let parsed;
+    let parseError = null;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      parseError = err instanceof Error ? err.message : String(err);
+    }
+    if (parseError === null) {
+      const name = parsed?.name;
+      if (typeof name !== "string" || name.length === 0) {
+        result = { kind: "fail", outcome: { kind: "invalid-package", packagePath, error: "package.json is missing a non-empty `name` field" } };
+      } else {
+        result = { kind: "ok", packageName: name };
+      }
+    } else {
+      result = { kind: "fail", outcome: { kind: "invalid-package", packagePath, error: parseError } };
+    }
+  }
+  return result;
+}
+async function loadScanSection(input) {
+  const { configPath, readFile, parseSection } = input;
+  const readResult = await readScanConfigRaw(configPath, readFile);
+  let result;
+  if (readResult.kind === "error") {
+    result = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: `failed to read config: ${readResult.error}` } };
+  } else if (readResult.kind === "enoent") {
+    result = { kind: "fail", outcome: { kind: "no-config", configPath } };
+  } else {
+    result = parseScanSectionFromRaw(readResult.raw, configPath, parseSection);
+  }
+  return result;
+}
+async function readScanConfigRaw(configPath, readFile) {
+  let result;
+  try {
+    const raw = await readFile(configPath);
+    result = { kind: "ok", raw };
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      result = { kind: "enoent" };
+    } else {
+      result = { kind: "error", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  return result;
+}
+function parseScanSectionFromRaw(raw, configPath, parseSection) {
+  const jsonResult = parseJsonString(raw);
+  let result;
+  if (jsonResult.ok) {
+    const sectionResult = parseSection(jsonResult.value);
+    if (sectionResult.ok) {
+      result = { kind: "ok", section: sectionResult.section };
+    } else {
+      result = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: sectionResult.error } };
+    }
+  } else {
+    result = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: jsonResult.error } };
+  }
+  return result;
+}
+function parseJsonString(raw) {
+  let result;
+  try {
+    result = { ok: true, value: JSON.parse(raw) };
+  } catch (err) {
+    result = { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+  return result;
+}
+async function buildScanProject(input) {
+  const { projectRoot, filePaths, readFile } = input;
+  const project = new Project({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  for (const relPath of filePaths) {
+    const absolute = resolvePath(projectRoot, relPath);
+    const text = await readFile(absolute);
+    project.createSourceFile(absolute, text, { overwrite: true });
+  }
+  return project;
+}
+function globToRegex(pattern) {
+  let body = "";
+  let index = 0;
+  while (index < pattern.length) {
+    const char = pattern[index];
+    if (char === "*" && pattern[index + 1] === "*") {
+      body += ".*";
+      index += 2;
+      if (pattern[index] === "/") {
+        index += 1;
+      }
+    } else if (char === "*") {
+      body += "[^/]*";
+      index += 1;
+    } else if (char === "?") {
+      body += "[^/]";
+      index += 1;
+    } else if (".+^${}()|[]\\".includes(char)) {
+      body += `\\${char}`;
+      index += 1;
+    } else {
+      body += char;
+      index += 1;
+    }
+  }
+  return new RegExp(`^${body}$`);
+}
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-build-manifest.ts
+var DEFAULT_READ_FILE = defaultReadFile;
+var DEFAULT_GLOBBER = defaultGlobber;
+async function buildModelFirebaseIndexManifest(input) {
+  const { projectRoot, generator, readFile = DEFAULT_READ_FILE, globber = DEFAULT_GLOBBER, now = () => /* @__PURE__ */ new Date() } = input;
+  const configPath = resolve2(projectRoot, MODEL_FIREBASE_INDEX_SCAN_CONFIG_FILENAME);
+  const packagePath = resolve2(projectRoot, "package.json");
+  const configOutcome = await loadScanSection({
+    configPath,
+    readFile,
+    parseSection: (parsed) => {
+      const validated2 = ModelFirebaseIndexScanConfig(parsed);
+      if (validated2 instanceof type3.errors) {
+        return { ok: false, error: validated2.summary };
+      }
+      return { ok: true, section: validated2.modelFirebaseIndex };
+    }
+  });
+  if (configOutcome.kind !== "ok") {
+    return configOutcome.outcome;
+  }
+  const scanSection = configOutcome.section;
+  const packageOutcome = await loadPackageName(packagePath, readFile);
+  if (packageOutcome.kind !== "ok") {
+    return packageOutcome.outcome;
+  }
+  const packageName = packageOutcome.packageName;
+  const filePaths = await globber({
+    projectRoot,
+    include: scanSection.include,
+    exclude: scanSection.exclude ?? []
+  });
+  const project = await buildScanProject({ projectRoot, filePaths, readFile });
+  const identityResolver = buildIdentityResolverFromProject(project);
+  const extractResult = extractModelFirebaseIndexEntries({ project, identityResolver, projectRoot });
+  const analyzed = analyzeModelFirebaseIndexEntries(extractResult.entries);
+  const buildWarnings = [];
+  for (const warning of extractResult.warnings) {
+    buildWarnings.push({ stage: "extract", warning });
+  }
+  for (const entry of analyzed) {
+    for (const warning of entry.warnings) {
+      buildWarnings.push({ stage: "analyze", warning });
+    }
+  }
+  const moduleName = scanSection.module ?? packageName;
+  const sourceLabel = scanSection.source ?? packageName;
+  const entries = analyzed.map((analyzedEntry) => assembleEntry({ analyzedEntry, moduleName, projectRoot }));
+  const manifest = {
+    version: 1,
+    source: sourceLabel,
+    module: moduleName,
+    generatedAt: now().toISOString(),
+    generator,
+    entries
+  };
+  const validated = ModelFirebaseIndexManifest(manifest);
+  let outcome;
+  if (validated instanceof type3.errors) {
+    outcome = { kind: "invalid-manifest", error: validated.summary };
+  } else {
+    const outPath = resolve2(projectRoot, scanSection.out ?? DEFAULT_MODEL_FIREBASE_INDEX_SCAN_OUT_PATH);
+    const entryFilePathsBySlug = /* @__PURE__ */ new Map();
+    const dispatcherSummaries = [];
+    for (const analyzedEntry of analyzed) {
+      const extracted = analyzedEntry.extractedEntry;
+      entryFilePathsBySlug.set(extracted.slug, extracted.filePath);
+      if (extracted.dispatcher) {
+        dispatcherSummaries.push({ slug: extracted.slug, name: extracted.name, delegates: [...extracted.dispatcherDelegates] });
+      }
+    }
+    outcome = {
+      kind: "success",
+      manifest: validated,
+      outPath,
+      scannedFileCount: filePaths.length,
+      extractWarnings: buildWarnings,
+      entryFilePathsBySlug,
+      dispatcherSummaries
+    };
+  }
+  return outcome;
+}
+var SRC_PREFIXES = ["/src/lib/", "/src/"];
+function deriveSubpath(filePath, projectRoot) {
+  const normalised = filePath.replaceAll("\\", "/");
+  const projectNormalised = projectRoot.replaceAll("\\", "/");
+  let relativePath;
+  if (normalised.startsWith(projectNormalised)) {
+    relativePath = normalised.slice(projectNormalised.length).replace(/^\/+/, "");
+  } else {
+    relativePath = relative(projectRoot, filePath).replaceAll("\\", "/");
+  }
+  for (const prefix of SRC_PREFIXES) {
+    const stripped = `/${relativePath}`;
+    const idx = stripped.indexOf(prefix);
+    if (idx >= 0) {
+      const remainder = stripped.slice(idx + prefix.length);
+      return remainder.replace(/\.ts$/, "");
+    }
+  }
+  return relativePath.replace(/\.ts$/, "");
+}
+function assembleEntry(input) {
+  const { analyzedEntry, moduleName, projectRoot } = input;
+  const entry = analyzedEntry.extractedEntry;
+  const subpath = deriveSubpath(entry.filePath, projectRoot);
+  const out = {
+    slug: entry.slug,
+    name: entry.name,
+    module: moduleName,
+    subpath,
+    signature: entry.signature,
+    description: entry.description,
+    model: entry.model,
+    collection: entry.collection,
+    isNested: entry.isNested,
+    scope: entry.scope,
+    manual: entry.manual,
+    skip: entry.skip,
+    ...entry.specOnly ? { specOnly: true } : {},
+    ...entry.excluded ? { excluded: true } : {},
+    category: entry.category,
+    params: entry.params.map((p) => ({ ...p })),
+    returns: entry.returns,
+    tags: [...entry.tags],
+    constraintSequences: entry.constraintSequences.map((s) => ({
+      ...s.pathLabel === void 0 ? {} : { pathLabel: s.pathLabel },
+      entries: s.entries.map((e) => ({ ...e }))
+    })),
+    derivedComposites: analyzedEntry.derivedComposites.map((c) => ({ ...c, fields: c.fields.map((f) => ({ ...f })) })),
+    derivedFieldOverrides: analyzedEntry.derivedFieldOverrides.map((f) => ({ ...f, variants: f.variants.map((v) => ({ ...v })) })),
+    ...entry.example.length > 0 ? { example: entry.example } : {},
+    ...entry.relatedSlugs && entry.relatedSlugs.length > 0 ? { relatedSlugs: [...entry.relatedSlugs] } : {},
+    ...entry.skillRefs && entry.skillRefs.length > 0 ? { skillRefs: [...entry.skillRefs] } : {},
+    ...entry.deprecated === void 0 ? {} : { deprecated: entry.deprecated },
+    ...entry.since === void 0 ? {} : { since: entry.since }
+  };
+  return out;
+}
+
+// packages/dbx-cli/firestore-query-manifest/src/find-query-entries.ts
+async function findQueryEntries(input) {
+  const { componentRoot, generator, buildManifest = buildModelFirebaseIndexManifest } = input;
+  const outcome = await buildManifest({ projectRoot: componentRoot, generator });
+  let result;
+  if (outcome.kind === "success") {
+    const dispatcherNames = new Set(outcome.dispatcherSummaries.map((x) => x.name));
+    const all = outcome.manifest.entries;
+    const kept = all.filter((x) => x.specOnly !== true);
+    result = {
+      kind: "success",
+      droppedSpecOnly: all.length - kept.length,
+      entries: kept.map((entry) => ({
+        slug: entry.slug,
+        name: entry.name,
+        module: entry.module,
+        subpath: entry.subpath,
+        model: entry.model,
+        collection: entry.collection,
+        isNested: entry.isNested,
+        scope: entry.scope,
+        signature: entry.signature,
+        params: entry.params.map((p) => ({ name: p.name, type: p.type, optional: p.optional, ...p.description ? { description: p.description } : {} })),
+        ...entry.description ? { description: entry.description } : {},
+        ...entry.category ? { category: entry.category } : {},
+        ...entry.tags.length > 0 ? { tags: entry.tags } : {},
+        ...entry.example ? { example: entry.example } : {},
+        ...entry.relatedSlugs && entry.relatedSlugs.length > 0 ? { relatedSlugs: entry.relatedSlugs } : {},
+        ...entry.manual ? { manual: true } : {},
+        ...entry.skip ? { skip: true } : {},
+        ...entry.excluded ? { excluded: true } : {},
+        ...dispatcherNames.has(entry.name) ? { dispatcher: true } : {}
+      }))
+    };
+  } else {
+    result = { kind: "failure", message: describeFailure(componentRoot, outcome) };
+  }
+  return result;
+}
+function describeFailure(componentRoot, outcome) {
+  let result;
+  switch (outcome.kind) {
+    case "no-config":
+      result = `${componentRoot}: no dbx-mcp.scan.json at ${outcome.configPath}. Add one with a \`modelFirebaseIndex.include\` glob.`;
+      break;
+    case "invalid-scan-config":
+      result = `${componentRoot}: dbx-mcp.scan.json at ${outcome.configPath} is invalid \u2014 ${outcome.error}`;
+      break;
+    case "no-package":
+      result = `${componentRoot}: no package.json at ${outcome.packagePath}; the entry \`module\` cannot be derived.`;
+      break;
+    case "invalid-package":
+      result = `${componentRoot}: package.json at ${outcome.packagePath} is invalid \u2014 ${outcome.error}`;
+      break;
+    default:
+      result = `${componentRoot}: the extracted manifest failed validation \u2014 ${outcome.error}`;
+      break;
+  }
+  return result;
+}
+
+// packages/dbx-cli/firestore-query-manifest/src/main.ts
+var WORKSPACE_ROOT = process.cwd();
+var GENERATOR = `@dereekb/dbx-cli-firestore-query-manifest@${package_default.version}`;
+async function main() {
+  const flags = parseFlags(process.argv.slice(2));
+  if (flags.components.length === 0 || !flags.output) {
+    printUsageAndExit();
+    return;
+  }
+  const outputFile = resolveWorkspacePath(flags.output);
+  const projectName = flags.project ?? "<cli>";
+  const namespace = deriveNamespace(flags.project);
+  const collected = [];
+  const warnings = [];
+  let droppedSpecOnly = 0;
+  for (const component of flags.components) {
+    const componentRoot = resolveWorkspacePath(component);
+    const found = await findQueryEntries({ componentRoot, generator: GENERATOR });
+    if (found.kind === "failure") {
+      console.error(found.message);
+      process.exit(1);
+      return;
+    }
+    droppedSpecOnly += found.droppedSpecOnly;
+    const bound = bindQueryFactories({ componentRoot, entries: found.entries });
+    collected.push(...bound.bound);
+    warnings.push(...bound.warnings);
+  }
+  for (const warning of warnings) {
+    console.warn(warning);
+  }
+  const formatted = await renderQueryManifest({ outputFile, entries: collected, projectName, namespace });
+  const relOutput = relative2(WORKSPACE_ROOT, outputFile);
+  if (flags.check) {
+    const current = existsSync3(outputFile) ? readFileSync3(outputFile, "utf8") : void 0;
+    if (current !== formatted) {
+      console.error(`[check] ${relOutput} is out of date \u2014 run the generator and commit the result.`);
+      process.exit(1);
+      return;
+    }
+    console.log(`[check] ${relOutput} is up to date.`);
+  } else {
+    const outcome = writeGeneratedTsFile({ outputFile, contents: formatted });
+    console.log(`[${outcome}] ${relOutput}`);
+  }
+  const boundCount = collected.filter((x) => x.bound).length;
+  console.log(`Summary: ${flags.components.length} component(s) \xB7 ${collected.length} entries \xB7 ${boundCount} invocable \xB7 ${collected.length - boundCount} unbound \xB7 ${droppedSpecOnly} spec-only dropped`);
+  if (flags.strict && boundCount < collected.length) {
+    console.error(`[strict] ${collected.length - boundCount} factor(y|ies) failed to bind \u2014 failing build.`);
+    process.exit(1);
+  }
+}
+function resolveWorkspacePath(value) {
+  return isAbsolute2(value) ? value : resolve3(WORKSPACE_ROOT, value);
+}
+function deriveNamespace(projectName) {
+  const base = (projectName ?? "cli").replaceAll(/[^a-zA-Z0-9]+/g, "_");
+  return `${base.toUpperCase()}_FIRESTORE_QUERY_MANIFEST`;
+}
+function parseFlags(argv) {
+  const components = [];
+  let output;
+  let project;
+  let strict = false;
+  let check = false;
+  for (const arg of argv) {
+    if (arg === "--strict") {
+      strict = true;
+    } else if (arg === "--check") {
+      check = true;
+    } else if (arg.startsWith("--component=")) {
+      const value = arg.slice("--component=".length).trim();
+      if (value) components.push(value);
+    } else if (arg.startsWith("--output=")) {
+      output = arg.slice("--output=".length);
+    } else if (arg.startsWith("--project=")) {
+      project = arg.slice("--project=".length);
+    }
+  }
+  return { components, output, project, strict, check };
+}
+function printUsageAndExit() {
+  console.error(String.raw`generate-firestore-query-manifest
+
+Usage:
+  node dist/packages/dbx-cli/firestore-query-manifest/main.js \
+    --project=<name> \
+    --component=<component-dir> [--component=<component-dir> ...] \
+    --output=<path-to-query.manifest.generated.ts> \
+    [--strict] [--check]
+
+Required flags:
+  --component=<dir>  A "-firebase" component root to scan. Repeatable.
+  --output=<path>    Path to the manifest TS file to write (workspace-relative ok).
+
+Optional:
+  --project=<name>   Project name for the regenerate banner; also derives the constant name.
+  --strict           Fail when any tagged factory is not exported from its component barrel.
+  --check            Do not write; fail when the committed file is out of date.`);
+  process.exit(1);
+}
+try {
+  await main();
+} catch (e) {
+  console.error(e);
+  process.exit(1);
+}