@dereekb/dbx-cli 13.11.15 → 13.11.17

package/generate-firestore-indexes/main.js

@@ -0,0 +1,2202 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+
+// packages/dbx-cli/generate-firestore-indexes/package.json
+var package_default = {
+  name: "@dereekb/dbx-cli-generate-firestore-indexes",
+  version: "13.11.17",
+  private: true,
+  type: "module",
+  devDependencies: {
+    eslint: "10.4.0"
+  }
+};
+
+// 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/firestore-indexes-generate.ts
+function generateFirestoreIndexesJson(input) {
+  const { entries, existingJson } = input;
+  const { generatedComposites, overrideVariants } = collectDerivedEntries(entries);
+  const dedupedComposites = dedupeCompositesPreservingFirst(generatedComposites);
+  const generatedFieldOverrides = buildFieldOverrideEntries(overrideVariants);
+  const preservedFieldOverrides = pickPreservedFieldOverrides({ existingJson, generatedFieldOverrides });
+  const allFieldOverrides = [...generatedFieldOverrides, ...preservedFieldOverrides];
+  const preservedComposites = pickPreservedComposites({ existingJson, generatedComposites: dedupedComposites });
+  const allComposites = [...dedupedComposites, ...preservedComposites];
+  const sortedComposites = [...allComposites].sort(compareComposites);
+  const sortedFieldOverrides = [...allFieldOverrides].sort(compareFieldOverrides);
+  const json = {
+    indexes: sortedComposites,
+    fieldOverrides: sortedFieldOverrides
+  };
+  const diff = computeDiff({ existingJson, json });
+  return { json, diff };
+}
+function serializeFirestoreIndexesJson(json) {
+  return `${JSON.stringify(json, null, 2)}
+`;
+}
+function collectDerivedEntries(entries) {
+  const generatedComposites = [];
+  const overrideVariants = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.skip || entry.manual) {
+      continue;
+    }
+    for (const composite of entry.derivedComposites) {
+      generatedComposites.push(buildCompositeJson(composite));
+    }
+    for (const fieldOverride of entry.derivedFieldOverrides) {
+      mergeFieldOverrideVariants(overrideVariants, fieldOverride);
+    }
+  }
+  return { generatedComposites, overrideVariants };
+}
+function mergeFieldOverrideVariants(overrideVariants, fieldOverride) {
+  const key = `${fieldOverride.collectionGroup}::${fieldOverride.fieldPath}`;
+  const list = overrideVariants.get(key) ?? [];
+  for (const variant of fieldOverride.variants) {
+    if (!list.some((v) => variantsEqual(v, variant))) {
+      list.push(variant);
+    }
+  }
+  overrideVariants.set(key, list);
+}
+function buildCompositeJson(composite) {
+  const fields = composite.fields.map((field) => buildIndexField(field));
+  const lastOrdered = [...composite.fields].reverse().find((f) => f.order !== void 0);
+  const tiebreakerOrder = lastOrdered?.order ?? "ASCENDING";
+  fields.push({ fieldPath: "__name__", order: tiebreakerOrder });
+  return {
+    collectionGroup: composite.collectionGroup,
+    queryScope: composite.queryScope,
+    fields,
+    density: composite.density ?? DEFAULT_FIRESTORE_INDEX_DENSITY
+  };
+}
+function buildIndexField(field) {
+  if (field.arrayConfig !== void 0) {
+    return { fieldPath: field.fieldPath, arrayConfig: field.arrayConfig };
+  }
+  return { fieldPath: field.fieldPath, order: field.order ?? "ASCENDING" };
+}
+function dedupeCompositesPreservingFirst(composites) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const composite of composites) {
+    const key = compositeKey(composite);
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(composite);
+    }
+  }
+  return out;
+}
+function compositeKey(composite) {
+  const fields = composite.fields.map((f) => {
+    if (f.arrayConfig !== void 0) {
+      return `${f.fieldPath}:array:${f.arrayConfig}`;
+    }
+    return `${f.fieldPath}:${f.order ?? "ASCENDING"}`;
+  }).join("|");
+  return `${composite.collectionGroup}::${composite.queryScope}::${fields}`;
+}
+function buildFieldOverrideEntries(overrideVariants) {
+  const entries = [];
+  for (const [key, variants] of overrideVariants) {
+    const [collectionGroup, fieldPath] = key.split("::");
+    const variantList = padWithCollectionQuartet(variants);
+    entries.push({
+      collectionGroup,
+      fieldPath,
+      ttl: false,
+      indexes: variantList
+    });
+  }
+  return entries;
+}
+function padWithCollectionQuartet(variants) {
+  const collectionGroupVariants = variants.filter((v) => v.queryScope === "COLLECTION_GROUP");
+  if (collectionGroupVariants.length === 0) {
+    return [];
+  }
+  const out = [
+    { queryScope: "COLLECTION", order: "ASCENDING" },
+    { queryScope: "COLLECTION", order: "DESCENDING" },
+    { queryScope: "COLLECTION", arrayConfig: "CONTAINS" }
+  ];
+  for (const variant of collectionGroupVariants) {
+    if (!out.some((v) => variantJsonEqual(v, variant))) {
+      out.push({ ...variant });
+    }
+  }
+  return out;
+}
+function variantsEqual(a, b) {
+  return a.queryScope === b.queryScope && a.order === b.order && a.arrayConfig === b.arrayConfig;
+}
+function variantJsonEqual(a, b) {
+  return a.queryScope === b.queryScope && a.order === b.order && a.arrayConfig === b.arrayConfig;
+}
+function pickPreservedFieldOverrides(input) {
+  const { existingJson, generatedFieldOverrides } = input;
+  if (existingJson === void 0) {
+    return [];
+  }
+  const generatedKeys = new Set(generatedFieldOverrides.map(fieldOverrideKey));
+  const out = [];
+  for (const fieldOverride of existingJson.fieldOverrides) {
+    if (!generatedKeys.has(fieldOverrideKey(fieldOverride))) {
+      out.push(fieldOverride);
+    }
+  }
+  return out;
+}
+function pickPreservedComposites(input) {
+  const { existingJson, generatedComposites } = input;
+  if (existingJson === void 0) {
+    return [];
+  }
+  const generatedCollections = new Set(generatedComposites.map((c) => c.collectionGroup));
+  const out = [];
+  for (const composite of existingJson.indexes) {
+    if (!generatedCollections.has(composite.collectionGroup)) {
+      out.push(composite);
+    }
+  }
+  return out;
+}
+function fieldOverrideKey(entry) {
+  return `${entry.collectionGroup}::${entry.fieldPath}`;
+}
+function compareComposites(a, b) {
+  let result2 = a.collectionGroup.localeCompare(b.collectionGroup);
+  if (result2 === 0) {
+    result2 = a.queryScope.localeCompare(b.queryScope);
+  }
+  if (result2 === 0) {
+    result2 = compositeKey(a).localeCompare(compositeKey(b));
+  }
+  return result2;
+}
+function compareFieldOverrides(a, b) {
+  let result2 = a.collectionGroup.localeCompare(b.collectionGroup);
+  if (result2 === 0) {
+    result2 = a.fieldPath.localeCompare(b.fieldPath);
+  }
+  return result2;
+}
+function computeDiff(input) {
+  const { existingJson, json } = input;
+  const newKeys = new Set(json.indexes.map(compositeKey));
+  const oldKeys = new Set((existingJson?.indexes ?? []).map(compositeKey));
+  const added = [];
+  const removed = [];
+  const unchanged = [];
+  for (const key of newKeys) {
+    if (oldKeys.has(key)) {
+      unchanged.push(key);
+    } else {
+      added.push(key);
+    }
+  }
+  for (const key of oldKeys) {
+    if (!newKeys.has(key)) {
+      removed.push(key);
+    }
+  }
+  const newOverrideKeys = new Set(json.fieldOverrides.map(fieldOverrideKey));
+  const oldOverrideKeys = new Set((existingJson?.fieldOverrides ?? []).map(fieldOverrideKey));
+  const fieldOverridesAdded = [];
+  const fieldOverridesRemoved = [];
+  const fieldOverridesUnchanged = [];
+  for (const key of newOverrideKeys) {
+    if (oldOverrideKeys.has(key)) {
+      fieldOverridesUnchanged.push(key);
+    } else {
+      fieldOverridesAdded.push(key);
+    }
+  }
+  for (const key of oldOverrideKeys) {
+    if (!newOverrideKeys.has(key)) {
+      fieldOverridesRemoved.push(key);
+    }
+  }
+  const byLocale = (a, b) => a.localeCompare(b);
+  added.sort(byLocale);
+  removed.sort(byLocale);
+  unchanged.sort(byLocale);
+  fieldOverridesAdded.sort(byLocale);
+  fieldOverridesRemoved.sort(byLocale);
+  fieldOverridesUnchanged.sort(byLocale);
+  return {
+    added,
+    removed,
+    unchanged,
+    fieldOverridesAdded,
+    fieldOverridesRemoved,
+    fieldOverridesUnchanged
+  };
+}
+
+// packages/dbx-cli/firestore-indexes/src/generate-firestore-indexes-cli.ts
+import { readFile as nodeReadFile2, writeFile as nodeWriteFile } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-build-manifest.ts
+import { relative, resolve } from "node:path";
+import { type as type3 } from "arktype";
+
+// 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 result2 = analyzeSequence({ sequence, collection: entry.collection, scope: entry.scope, factoryName: entry.name, allowArrayContainsAny: entry.allowArrayContainsAny });
+    for (const warning of result2.warnings) {
+      warnings.push(warning);
+    }
+    if (result2.kind === "composite") {
+      composites.push(result2.composite);
+    } else if (result2.kind === "fieldOverride") {
+      const key = result2.fieldOverride.fieldPath;
+      const list = fieldOverrides.get(key) ?? [];
+      if (!list.some((v) => fieldOverrideVariantEquals(v, result2.fieldOverride.variant))) {
+        list.push(result2.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 result2;
+  if (buckets.equalities.length > 0) {
+    result2 = buckets.equalities[0].fieldPath;
+  } else if (buckets.ranges.length > 0) {
+    result2 = buckets.ranges[0].fieldPath;
+  } else if (buckets.arrays.length > 0) {
+    result2 = buckets.arrays[0].fieldPath;
+  } else if (buckets.orderBys.length > 0) {
+    result2 = buckets.orderBys[0].fieldPath;
+  }
+  return result2;
+}
+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 result2;
+  if (TRUE_TAG_VALUES.has(lowered)) {
+    result2 = true;
+  } else if (FALSE_TAG_VALUES.has(lowered)) {
+    result2 = false;
+  }
+  return result2;
+}
+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 result2;
+  if (tags.scope === void 0 || tags.scope.length === 0) {
+    result2 = resolved.isNested ? "COLLECTION_GROUP" : "COLLECTION";
+  } else if (VALID_SCOPE_TAG_VALUES.has(tags.scope)) {
+    result2 = tags.scope;
+  } else {
+    warnings.push({ kind: "unsupported-scope", severity: "warning", name, scope: tags.scope, filePath, line });
+    result2 = void 0;
+  }
+  return result2;
+}
+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 result2;
+  for (const d of declarations) {
+    if (Node2.isFunctionDeclaration(d) && d.isExported()) {
+      result2 = { decl: d, hasBody: d.getBody() !== void 0 };
+      break;
+    }
+  }
+  return result2;
+}
+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 result2 = false;
+  for (const doc of decl.getJsDocs()) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() === INDEX_MARKER) {
+        result2 = true;
+        break;
+      }
+    }
+    if (result2) {
+      break;
+    }
+  }
+  return result2;
+}
+function buildDeclKey(decl) {
+  const name = decl.getName() ?? "<anonymous>";
+  return `${decl.getSourceFile().getFilePath()}::${name}`;
+}
+function findFirstBranchNode(bodyNode) {
+  let result2;
+  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 (result2 === void 0 || line < result2.line) {
+        result2 = { branchKind, line };
+      }
+    }
+  }
+  return result2;
+}
+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 result2;
+  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) {
+      result2 = { callee: calleeName, line: call.getStartLineNumber() };
+      break;
+    }
+  }
+  return result2;
+}
+function isWithinConditionalBranch(call, bodyNode) {
+  let node = call.getParent();
+  let result2 = false;
+  while (node !== void 0 && node !== bodyNode) {
+    const kind = node.getKind();
+    if (kind === SyntaxKind2.IfStatement || kind === SyntaxKind2.ConditionalExpression || kind === SyntaxKind2.SwitchStatement || kind === SyntaxKind2.CaseClause) {
+      result2 = true;
+      break;
+    }
+    node = node.getParent();
+  }
+  return result2;
+}
+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 result2;
+  if (node !== void 0 && (Node2.isStringLiteral(node) || Node2.isNoSubstitutionTemplateLiteral(node))) {
+    result2 = node.getLiteralText();
+  }
+  return result2;
+}
+function readDirectionLiteral(node) {
+  const text = readStringLiteral(node);
+  let result2;
+  if (text === "asc" || text === "desc") {
+    result2 = text;
+  }
+  return result2;
+}
+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 result2;
+  if (!invalidArg && stringArgs.length > 0) {
+    const modelType = stringArgs[0];
+    const collection = stringArgs.length >= 2 ? stringArgs[1] : modelType;
+    result2 = { modelType, collection, isNested };
+  }
+  return result2;
+}
+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 result2 = byModelType.get(camel);
+    result2 ??= byIdentityConst.get(`${camel}Identity`);
+    if (result2 === void 0) {
+      const lower = camel.toLowerCase();
+      result2 = records.find((r) => r.modelType.toLowerCase() === lower);
+    }
+    return result2;
+  }
+  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 result2;
+  if (firstChar >= "A" && firstChar <= "Z") {
+    result2 = firstChar.toLowerCase() + typeName.slice(1);
+  } else {
+    result2 = typeName;
+  }
+  return result2;
+}
+
+// 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 result2;
+  if (raw === null) {
+    result2 = { 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) {
+        result2 = { kind: "fail", outcome: { kind: "invalid-package", packagePath, error: "package.json is missing a non-empty `name` field" } };
+      } else {
+        result2 = { kind: "ok", packageName: name };
+      }
+    } else {
+      result2 = { kind: "fail", outcome: { kind: "invalid-package", packagePath, error: parseError } };
+    }
+  }
+  return result2;
+}
+async function loadScanSection(input) {
+  const { configPath, readFile, parseSection } = input;
+  const readResult = await readScanConfigRaw(configPath, readFile);
+  let result2;
+  if (readResult.kind === "error") {
+    result2 = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: `failed to read config: ${readResult.error}` } };
+  } else if (readResult.kind === "enoent") {
+    result2 = { kind: "fail", outcome: { kind: "no-config", configPath } };
+  } else {
+    result2 = parseScanSectionFromRaw(readResult.raw, configPath, parseSection);
+  }
+  return result2;
+}
+async function readScanConfigRaw(configPath, readFile) {
+  let result2;
+  try {
+    const raw = await readFile(configPath);
+    result2 = { kind: "ok", raw };
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      result2 = { kind: "enoent" };
+    } else {
+      result2 = { kind: "error", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  return result2;
+}
+function parseScanSectionFromRaw(raw, configPath, parseSection) {
+  const jsonResult = parseJsonString(raw);
+  let result2;
+  if (jsonResult.ok) {
+    const sectionResult = parseSection(jsonResult.value);
+    if (sectionResult.ok) {
+      result2 = { kind: "ok", section: sectionResult.section };
+    } else {
+      result2 = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: sectionResult.error } };
+    }
+  } else {
+    result2 = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: jsonResult.error } };
+  }
+  return result2;
+}
+function parseJsonString(raw) {
+  let result2;
+  try {
+    result2 = { ok: true, value: JSON.parse(raw) };
+  } catch (err) {
+    result2 = { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+  return result2;
+}
+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 = resolve(projectRoot, MODEL_FIREBASE_INDEX_SCAN_CONFIG_FILENAME);
+  const packagePath = resolve(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 = resolve(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-indexes/src/model-firebase-index-runtime.ts
+// @__NO_SIDE_EFFECTS__
+function createModelFirebaseIndexRegistryFromEntries(input) {
+  const all = [...input.entries];
+  const bySlug = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  const byCollection = /* @__PURE__ */ new Map();
+  const byModel = /* @__PURE__ */ new Map();
+  const byModule = /* @__PURE__ */ new Map();
+  const byCategory = /* @__PURE__ */ new Map();
+  const byTag = /* @__PURE__ */ new Map();
+  const collectionSet = /* @__PURE__ */ new Set();
+  const modelSet = /* @__PURE__ */ new Set();
+  const moduleSet = /* @__PURE__ */ new Set();
+  const categorySet = /* @__PURE__ */ new Set();
+  for (const entry of all) {
+    if (!bySlug.has(entry.slug)) {
+      bySlug.set(entry.slug, entry);
+    }
+    if (!byName.has(entry.name)) {
+      byName.set(entry.name, entry);
+    }
+    pushInto(byCollection, entry.collection, entry);
+    pushInto(byModel, entry.model, entry);
+    pushInto(byModule, entry.module, entry);
+    pushInto(byCategory, entry.category, entry);
+    for (const tag of entry.tags) {
+      pushInto(byTag, tag.toLowerCase(), entry);
+    }
+    collectionSet.add(entry.collection);
+    modelSet.add(entry.model);
+    moduleSet.add(entry.module);
+    categorySet.add(entry.category);
+  }
+  const collections = Array.from(collectionSet).sort((a, b) => a.localeCompare(b));
+  const models = Array.from(modelSet).sort((a, b) => a.localeCompare(b));
+  const modules = Array.from(moduleSet).sort((a, b) => a.localeCompare(b));
+  const categories = Array.from(categorySet).sort((a, b) => a.localeCompare(b));
+  return {
+    all,
+    loadedSources: [...input.loadedSources],
+    collections,
+    models,
+    modules,
+    categories,
+    findBySlug: (slug) => bySlug.get(slug),
+    findByName: (name) => byName.get(name),
+    findByCollection: (collection) => byCollection.get(collection) ?? [],
+    findByModel: (model) => byModel.get(model) ?? [],
+    findByModule: (module) => byModule.get(module) ?? [],
+    findByCategory: (category) => byCategory.get(category) ?? [],
+    findByTag: (tag) => byTag.get(tag.toLowerCase()) ?? []
+  };
+}
+function toModelFirebaseIndexEntryInfo(entry) {
+  return {
+    slug: entry.slug,
+    name: entry.name,
+    module: entry.module,
+    subpath: entry.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,
+    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: entry.derivedComposites.map((c) => ({ ...c, fields: c.fields.map((f) => ({ ...f })) })),
+    derivedFieldOverrides: entry.derivedFieldOverrides.map((f) => ({ ...f, variants: f.variants.map((v) => ({ ...v })) })),
+    example: entry.example ?? "",
+    relatedSlugs: entry.relatedSlugs ?? [],
+    skillRefs: entry.skillRefs ?? [],
+    deprecated: entry.deprecated ?? false,
+    since: entry.since ?? ""
+  };
+}
+function pushInto(map, key, entry) {
+  const existing = map.get(key);
+  if (existing === void 0) {
+    map.set(key, [entry]);
+  } else {
+    existing.push(entry);
+  }
+}
+
+// packages/dbx-cli/firestore-indexes/src/generate-firestore-indexes-cli.ts
+var DEFAULT_BIN_NAME = "dbx-cli-generate-firestore-indexes";
+function buildUsage(binName) {
+  return [
+    `Usage: ${binName} --component <dir> [--output <path>] [--check] [--json] [--help]`,
+    "",
+    "Generates `firestore.indexes.json` from `@dbxModelFirebaseIndex`-tagged factories.",
+    "",
+    "Options:",
+    "  --component <dir>  Required. Relative path to the `-firebase` component package.",
+    "  --output <path>    Output path. Defaults to `firestore.indexes.json` at the cwd.",
+    "  --check            Compare against the on-disk file; exit 1 on drift, do not write.",
+    "  --json             Print the diff summary as JSON instead of human-readable text.",
+    "  --help             Show this message."
+  ].join("\n");
+}
+async function runGenerateFirestoreIndexesCli(input) {
+  const { argv, cwd, generator, binName = DEFAULT_BIN_NAME, readFile = (path) => nodeReadFile2(path, "utf-8"), writeFile = nodeWriteFile, stdout = (m) => console.log(m), stderr = (m) => console.error(m) } = input;
+  const usage = buildUsage(binName);
+  const parsed = parseArgv(argv);
+  if (parsed.help) {
+    stdout(usage);
+    return { exitCode: 0 };
+  }
+  if (parsed.error !== void 0) {
+    stderr(parsed.error);
+    stderr(usage);
+    return { exitCode: 2 };
+  }
+  if (parsed.component === void 0) {
+    stderr("generate-firestore-indexes: --component is required");
+    stderr(usage);
+    return { exitCode: 2 };
+  }
+  const componentAbs = resolve2(cwd, parsed.component);
+  const outputAbs = resolve2(cwd, parsed.output);
+  const buildOutcome = await buildModelFirebaseIndexManifest({
+    projectRoot: componentAbs,
+    generator
+  });
+  if (buildOutcome.kind !== "success") {
+    stderr(formatBuildFailure(buildOutcome));
+    return { exitCode: 1 };
+  }
+  const entries = buildOutcome.manifest.entries.map(toModelFirebaseIndexEntryInfo);
+  const registry = createModelFirebaseIndexRegistryFromEntries({ entries, loadedSources: [buildOutcome.manifest.source] });
+  const existingJson = await readExistingIndexes({ outputAbs, readFile, stderr });
+  const { json, diff } = generateFirestoreIndexesJson({ entries: registry.all, existingJson });
+  const serialized = serializeFirestoreIndexesJson(json);
+  if (parsed.check) {
+    const existingSerialized = existingJson === void 0 ? "" : serializeFirestoreIndexesJson(existingJson);
+    const drift = existingSerialized !== serialized || diff.added.length > 0 || diff.removed.length > 0 || diff.fieldOverridesAdded.length > 0 || diff.fieldOverridesRemoved.length > 0;
+    if (parsed.json) {
+      stdout(JSON.stringify({ drift, diff, generatedComposites: json.indexes.length, generatedFieldOverrides: json.fieldOverrides.length }, null, 2));
+    } else {
+      stdout(formatCheckSummary({ drift, outputPath: parsed.output, diff, generatedComposites: json.indexes.length, generatedFieldOverrides: json.fieldOverrides.length }));
+    }
+    return { exitCode: drift ? 1 : 0 };
+  }
+  await writeFile(outputAbs, serialized);
+  if (parsed.json) {
+    stdout(JSON.stringify({ wrote: parsed.output, diff, generatedComposites: json.indexes.length, generatedFieldOverrides: json.fieldOverrides.length }, null, 2));
+  } else {
+    stdout(formatWriteSummary({ outputPath: parsed.output, diff, generatedComposites: json.indexes.length, generatedFieldOverrides: json.fieldOverrides.length }));
+  }
+  return { exitCode: 0 };
+}
+function parseArgv(argv) {
+  let component;
+  let output = "firestore.indexes.json";
+  let check = false;
+  let json = false;
+  let help = false;
+  let error;
+  let i = 0;
+  while (i < argv.length && error === void 0) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--component":
+        i += 1;
+        if (i >= argv.length) {
+          error = "generate-firestore-indexes: --component requires a value";
+        } else {
+          component = argv[i];
+        }
+        break;
+      case "--output":
+        i += 1;
+        if (i >= argv.length) {
+          error = "generate-firestore-indexes: --output requires a value";
+        } else {
+          output = argv[i];
+        }
+        break;
+      case "--check":
+        check = true;
+        break;
+      case "--json":
+        json = true;
+        break;
+      case "--help":
+      case "-h":
+        help = true;
+        break;
+      default:
+        error = `generate-firestore-indexes: unrecognised argument "${arg}"`;
+        break;
+    }
+    i += 1;
+  }
+  return { component, output, check, json, help, error };
+}
+async function readExistingIndexes(input) {
+  const { outputAbs, readFile, stderr } = input;
+  let text = null;
+  let readFailed = false;
+  try {
+    text = await readFile(outputAbs);
+  } catch (err) {
+    readFailed = true;
+    const code = err.code;
+    if (code !== "ENOENT") {
+      stderr(`generate-firestore-indexes: could not read existing ${outputAbs}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  let result2;
+  if (!readFailed && text !== null) {
+    let parsed;
+    let parseFailed = false;
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      parseFailed = true;
+      stderr(`generate-firestore-indexes: existing ${outputAbs} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!parseFailed) {
+      if (parsed === null || typeof parsed !== "object") {
+        stderr(`generate-firestore-indexes: existing ${outputAbs} top-level value is not an object`);
+      } else {
+        const raw = parsed;
+        const indexes = Array.isArray(raw.indexes) ? raw.indexes : [];
+        const fieldOverrides = Array.isArray(raw.fieldOverrides) ? raw.fieldOverrides : [];
+        result2 = { indexes, fieldOverrides };
+      }
+    }
+  }
+  return result2;
+}
+function formatBuildFailure(outcome) {
+  let message;
+  switch (outcome.kind) {
+    case "no-config":
+      message = `generate-firestore-indexes: no scan config found at ${outcome.configPath}`;
+      break;
+    case "invalid-scan-config":
+      message = `generate-firestore-indexes: invalid scan config at ${outcome.configPath}: ${outcome.error}`;
+      break;
+    case "no-package":
+      message = `generate-firestore-indexes: no package.json found at ${outcome.packagePath}`;
+      break;
+    case "invalid-package":
+      message = `generate-firestore-indexes: invalid package.json at ${outcome.packagePath}: ${outcome.error}`;
+      break;
+    case "invalid-manifest":
+      message = `generate-firestore-indexes: manifest validation failed: ${outcome.error}`;
+      break;
+  }
+  return message;
+}
+function formatWriteSummary(input) {
+  const { outputPath, diff, generatedComposites, generatedFieldOverrides } = input;
+  const lines = [`generate-firestore-indexes: wrote ${outputPath}`, `  composites: ${generatedComposites} (added ${diff.added.length}, removed ${diff.removed.length}, unchanged ${diff.unchanged.length})`, `  fieldOverrides: ${generatedFieldOverrides} (added ${diff.fieldOverridesAdded.length}, removed ${diff.fieldOverridesRemoved.length}, unchanged ${diff.fieldOverridesUnchanged.length})`];
+  return appendDiffSection(lines, diff).join("\n");
+}
+function formatCheckSummary(input) {
+  const { drift, outputPath, diff, generatedComposites, generatedFieldOverrides } = input;
+  const headline = drift ? `generate-firestore-indexes: drift detected against ${outputPath}` : `generate-firestore-indexes: in sync (${outputPath})`;
+  const lines = [headline, `  composites: ${generatedComposites} (added ${diff.added.length}, removed ${diff.removed.length}, unchanged ${diff.unchanged.length})`, `  fieldOverrides: ${generatedFieldOverrides} (added ${diff.fieldOverridesAdded.length}, removed ${diff.fieldOverridesRemoved.length}, unchanged ${diff.fieldOverridesUnchanged.length})`];
+  return appendDiffSection(lines, diff).join("\n");
+}
+function appendDiffSection(lines, diff) {
+  if (diff.added.length > 0) {
+    lines.push("  Added composites:");
+    for (const k of diff.added) lines.push(`    + ${k}`);
+  }
+  if (diff.removed.length > 0) {
+    lines.push("  Removed composites:");
+    for (const k of diff.removed) lines.push(`    - ${k}`);
+  }
+  if (diff.fieldOverridesAdded.length > 0) {
+    lines.push("  Added fieldOverrides:");
+    for (const k of diff.fieldOverridesAdded) lines.push(`    + ${k}`);
+  }
+  if (diff.fieldOverridesRemoved.length > 0) {
+    lines.push("  Removed fieldOverrides:");
+    for (const k of diff.fieldOverridesRemoved) lines.push(`    - ${k}`);
+  }
+  return lines;
+}
+
+// packages/dbx-cli/generate-firestore-indexes/src/main.ts
+var result = await runGenerateFirestoreIndexesCli({
+  argv: process.argv.slice(2),
+  cwd: process.cwd(),
+  generator: `@dereekb/dbx-cli-generate-firestore-indexes@${package_default.version}`
+});
+process.exit(result.exitCode);