@dereekb/firebase 13.11.15 → 13.11.16

package/eslint/index.cjs.js

@@ -0,0 +1,2290 @@
+'use strict';
+
+/**
+ * Returns the outermost statement node for a FunctionDeclaration — its `ExportNamedDeclaration`
+ * or `ExportDefaultDeclaration` parent if exported, otherwise the declaration itself. This is the
+ * node ESLint attaches leading comments to.
+ *
+ * @param node - The FunctionDeclaration AST node.
+ * @returns The statement node ESLint attaches leading comments to.
+ */ function getStatementAnchor(node) {
+    return node.parent && (node.parent.type === 'ExportNamedDeclaration' || node.parent.type === 'ExportDefaultDeclaration') ? node.parent : node;
+}
+/**
+ * Returns the JSDoc Block comment immediately preceding `anchor`, or `null` when
+ * the anchor has no JSDoc leader. Used by the `@dbx<Family>` companion-tag rules
+ * to locate the tagged declaration's documentation.
+ *
+ * @param sourceCode - The ESLint `SourceCode` object.
+ * @param anchor - The statement-level node ESLint attaches leading comments to.
+ * @returns The JSDoc block comment, or null when none is present.
+ */ function leadingJsdocFor(sourceCode, anchor) {
+    var comments = sourceCode.getCommentsBefore(anchor) || [];
+    var result = null;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = comments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var comment = _step.value;
+            if (comment.type === 'Block' && typeof comment.value === 'string' && comment.value.startsWith('*')) {
+                result = comment;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+
+function _array_like_to_array$3(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$3(arr, i) || _non_iterable_rest$1();
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
+var TAG_LINE_REGEX = /^@([A-Za-z_]\w*)\s*(.*)$/;
+var TYPE_ANNOTATION_REGEX = /^\{([^}]*)\}\s*(.*)$/;
+var PARAM_NAME_REGEX = /^([A-Za-z_$][A-Za-z0-9_$.[\]]*)\s*(.*)$/;
+var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
+/**
+ * Strips the leading whitespace + `*` + optional space prefix from a JSDoc body line and reports the length stripped.
+ *
+ * @param raw - The raw line as it appears in `comment.value`.
+ * @returns A `{ text, prefixLength }` pair.
+ *
+ * @example
+ * ```ts
+ * stripPrefix(' * @param x - desc'); // { text: '@param x - desc', prefixLength: 3 }
+ * stripPrefix(' *'); // { text: '', prefixLength: 2 }
+ * stripPrefix('* hello'); // { text: 'hello', prefixLength: 2 }
+ * ```
+ */ function stripPrefix(raw) {
+    var match = LINE_PREFIX_REGEX.exec(raw);
+    var result = {
+        text: raw,
+        prefixLength: 0
+    };
+    if (match) {
+        result.text = match[2];
+        result.prefixLength = match[1].length;
+    }
+    return result;
+}
+/**
+ * Splits the raw comment value into per-line views with prefix/offset metadata.
+ *
+ * @param commentValue - The `value` of an ESLint Block comment.
+ * @returns Array of parsed line records in source order.
+ */ function buildParsedLines(commentValue) {
+    var rawLines = commentValue.split('\n');
+    var runningOffset = 0;
+    return rawLines.map(function(raw, index) {
+        var _stripPrefix = stripPrefix(raw), stripped = _stripPrefix.text, prefixLength = _stripPrefix.prefixLength;
+        var text = stripped.trimEnd();
+        var blank = text.length === 0;
+        var valueOffsetStart = runningOffset;
+        var textOffsetStart = runningOffset + prefixLength;
+        runningOffset += raw.length + 1; // +1 for the consumed `\n` (overshoots on last line, harmless)
+        return {
+            raw: raw,
+            text: text,
+            blank: blank,
+            index: index,
+            valueOffsetStart: valueOffsetStart,
+            textOffsetStart: textOffsetStart
+        };
+    });
+}
+/**
+ * Returns the index of the first line that begins with a JSDoc `@tag`, or `-1` when none exists.
+ *
+ * @param lines - Parsed lines in source order.
+ * @returns Zero-based line index of the first tag, or `-1` when no tag is present.
+ */ function findFirstTagIndex(lines) {
+    var firstTagIndex = -1;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = lines.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array$1(_step.value, 2), i = _step_value[0], line = _step_value[1];
+            if (TAG_LINE_REGEX.test(line.text)) {
+                firstTagIndex = i;
+                break;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return firstTagIndex;
+}
+/**
+ * Trims leading and trailing blank lines from a contiguous run of description lines.
+ *
+ * @param descriptionLines - Description-section lines before any tag.
+ * @returns Sub-array with surrounding blank lines stripped.
+ */ function trimBlankBoundaries(descriptionLines) {
+    var descStart = 0;
+    var descEnd = descriptionLines.length;
+    while(descStart < descEnd && descriptionLines[descStart].blank)descStart += 1;
+    while(descEnd > descStart && descriptionLines[descEnd - 1].blank)descEnd -= 1;
+    return descriptionLines.slice(descStart, descEnd);
+}
+/**
+ * Splits the trimmed description lines into paragraphs separated by blank-line runs.
+ *
+ * @param trimmedDescription - Description lines with surrounding blank lines removed.
+ * @returns Paragraph strings joined by `\n`.
+ */ function buildDescriptionParagraphs(trimmedDescription) {
+    var descriptionParagraphs = [];
+    var paragraphBuffer = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = trimmedDescription[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var line = _step.value;
+            if (line.blank) {
+                if (paragraphBuffer.length > 0) {
+                    descriptionParagraphs.push(paragraphBuffer.join('\n'));
+                    paragraphBuffer = [];
+                }
+            } else {
+                paragraphBuffer.push(line.text);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (paragraphBuffer.length > 0) {
+        descriptionParagraphs.push(paragraphBuffer.join('\n'));
+    }
+    return descriptionParagraphs;
+}
+/**
+ * Pulls an optional `{Type}` annotation off the front of a tag remainder.
+ *
+ * @param remainder - The tag-line text after the `@tagName` prefix.
+ * @returns The annotation (or `undefined`) plus the remaining text.
+ */ function extractTypeAnnotation(remainder) {
+    var type;
+    var rest = remainder;
+    var typeMatch = TYPE_ANNOTATION_REGEX.exec(remainder);
+    if (typeMatch) {
+        type = typeMatch[1];
+        rest = typeMatch[2];
+    }
+    return {
+        type: type,
+        rest: rest
+    };
+}
+/**
+ * Pulls an optional parameter name off the front of a `@param` tag remainder.
+ *
+ * @param tagName - Tag name (only `'param'` extracts a name; other tags pass through).
+ * @param remainder - The tag-line text after the optional `{Type}` annotation.
+ * @returns The parameter name (or `undefined`) plus the remaining text.
+ */ function extractParamName(tagName, remainder) {
+    var name;
+    var rest = remainder;
+    if (tagName === 'param') {
+        var nameMatch = PARAM_NAME_REGEX.exec(remainder);
+        if (nameMatch) {
+            name = nameMatch[1];
+            rest = nameMatch[2];
+        }
+    }
+    return {
+        name: name,
+        rest: rest
+    };
+}
+/**
+ * Collects the tag line at `startIndex` plus every following non-tag continuation line.
+ *
+ * @param lines - All parsed lines in the comment.
+ * @param startIndex - Index of the `@tag` opening line.
+ * @returns The collected tag lines and the index of the next unconsumed line.
+ */ function collectTagLines(lines, startIndex) {
+    var tagLines = [
+        lines[startIndex]
+    ];
+    var j = startIndex + 1;
+    while(j < lines.length){
+        if (TAG_LINE_REGEX.test(lines[j].text)) break;
+        tagLines.push(lines[j]);
+        j += 1;
+    }
+    return {
+        tagLines: tagLines,
+        nextIndex: j
+    };
+}
+/**
+ * Joins the on-line remainder and continuation-line text into a tag description, dropping trailing
+ * blank lines while preserving interior blanks.
+ *
+ * @param remainder - The on-line remainder after stripping `@tagName {Type} name`.
+ * @param tagLines - All lines that belong to the tag (including the header line at index 0).
+ * @returns Description text joined by `\n`.
+ */ function buildTagDescription(remainder, tagLines) {
+    var descriptionParts = [];
+    if (remainder.length > 0) descriptionParts.push(remainder);
+    for(var k = 1; k < tagLines.length; k += 1){
+        descriptionParts.push(tagLines[k].text);
+    }
+    while(descriptionParts.length > 0 && descriptionParts.at(-1).trim().length === 0){
+        descriptionParts.pop();
+    }
+    return descriptionParts.join('\n');
+}
+/**
+ * Builds a single parsed-tag record starting at `startIndex` in the line array.
+ *
+ * @param lines - All parsed lines in the comment.
+ * @param startIndex - Index of the `@tag` opening line.
+ * @returns The parsed tag and the next unconsumed line index.
+ */ function parseTagAt(lines, startIndex) {
+    var line = lines[startIndex];
+    var match = TAG_LINE_REGEX.exec(line.text);
+    var tagName = match[1];
+    var _extractTypeAnnotation = extractTypeAnnotation(match[2]), type = _extractTypeAnnotation.type, afterType = _extractTypeAnnotation.rest;
+    var _extractParamName = extractParamName(tagName, afterType), name = _extractParamName.name, afterName = _extractParamName.rest;
+    var _collectTagLines = collectTagLines(lines, startIndex), tagLines = _collectTagLines.tagLines, nextIndex = _collectTagLines.nextIndex;
+    var description = buildTagDescription(afterName, tagLines);
+    return {
+        tag: {
+            tag: tagName,
+            name: name,
+            type: type,
+            description: description,
+            lines: tagLines,
+            startLineIndex: startIndex,
+            endLineIndex: nextIndex - 1
+        },
+        nextIndex: nextIndex
+    };
+}
+/**
+ * Parses every `@tag` block starting from `firstTagIndex` to the end of the line array.
+ *
+ * @param lines - All parsed lines in the comment.
+ * @param firstTagIndex - Index where tag parsing should begin (`-1` skips entirely).
+ * @returns All parsed tags in source order.
+ */ function parseTags(lines, firstTagIndex) {
+    var tags = [];
+    if (firstTagIndex !== -1) {
+        var i = firstTagIndex;
+        while(i < lines.length){
+            if (!TAG_LINE_REGEX.test(lines[i].text)) {
+                i += 1;
+                continue;
+            }
+            var _parseTagAt = parseTagAt(lines, i), tag = _parseTagAt.tag, nextIndex = _parseTagAt.nextIndex;
+            tags.push(tag);
+            i = nextIndex;
+        }
+    }
+    return tags;
+}
+/**
+ * Parses the value of an ESLint Block comment that represents a JSDoc into a structured form.
+ *
+ * @param commentValue - The `value` of an ESLint Block comment (text between `/*` and `*\/`, including the leading `*`).
+ * @returns A structured view of the JSDoc with description, paragraphs, and tags.
+ *
+ * @example
+ * ```ts
+ * const parsed = parseJsdocComment('*\n * Hello.\n *\n * @param x - The value.\n ');
+ * // parsed.description === 'Hello.'
+ * // parsed.tags[0].tag === 'param'
+ * // parsed.tags[0].name === 'x'
+ * // parsed.tags[0].description === 'The value.'
+ * ```
+ */ function parseJsdocComment(commentValue) {
+    var singleLine = !commentValue.includes('\n');
+    var lines = buildParsedLines(commentValue);
+    var firstTagIndex = findFirstTagIndex(lines);
+    var descriptionLines = firstTagIndex === -1 ? lines.slice() : lines.slice(0, firstTagIndex);
+    var trimmedDescription = trimBlankBoundaries(descriptionLines);
+    var description = trimmedDescription.map(function(l) {
+        return l.text;
+    }).join('\n');
+    var descriptionParagraphs = buildDescriptionParagraphs(trimmedDescription);
+    var tags = parseTags(lines, firstTagIndex);
+    return {
+        lines: lines,
+        descriptionLines: descriptionLines,
+        description: description,
+        descriptionParagraphs: descriptionParagraphs,
+        tags: tags,
+        singleLine: singleLine
+    };
+}
+
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+/**
+ * Module that publishes the `@dereekb/firebase` Firestore constraint factories (`where`, `orderBy`, etc.).
+ */ var FIREBASE_MODULE = '@dereekb/firebase';
+/**
+ * JSDoc tag name that marks an exported query factory whose body should be scanned by
+ * `dbx-components-mcp`'s index extractor (`packages/dbx-components-mcp/src/scan/model-firebase-index-extract.ts`).
+ */ var DBX_MODEL_FIREBASE_INDEX_MARKER = 'dbxModelFirebaseIndex';
+/**
+ * The canonical suffix expected on every `@dbxModelFirebaseIndex`-tagged factory name.
+ */ var QUERY_SUFFIX = 'Query';
+/**
+ * Index-affecting Firestore constraint factory identifiers exported from `@dereekb/firebase`
+ * (see `packages/firebase/src/lib/common/firestore/query/constraint.ts`). These shape the
+ * composite index Firestore needs to satisfy the query — calls to them must originate inside
+ * a `@dbxModelFirebaseIndex`-tagged function so the dbx-components-mcp index extractor can
+ * collect them.
+ *
+ * `where` and `orderBy` are the only constraint factories that influence composite indexes;
+ * pagination/cursor factories (`limit`, `limitToLast`, `whereDocumentId`, `startAt`/`After`,
+ * `endAt`/`Before`) only narrow the cursor/window of an already-indexed query and may be
+ * composed freely outside tagged factories — see {@link DEFAULT_PAGINATION_CONSTRAINT_NAMES}.
+ */ var DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES = [
+    'where',
+    'orderBy'
+];
+/**
+ * Pagination/cursor Firestore constraint factory identifiers exported from `@dereekb/firebase`.
+ * These do not influence composite indexes and may be composed externally — e.g. a generic
+ * pagination helper that appends `limit` + `startAfter` onto a caller-supplied tagged-query
+ * constraint array. The "tagged-firestore-constraints" rule does not flag calls to these by
+ * default.
+ */ var DEFAULT_PAGINATION_CONSTRAINT_NAMES = [
+    'limit',
+    'limitToLast',
+    'whereDocumentId',
+    'startAt',
+    'startAfter',
+    'endAt',
+    'endBefore'
+];
+/**
+ * Combined list of every Firestore constraint factory exported from `@dereekb/firebase`. Used
+ * by the body-coherence rule to ensure a tagged factory body contains at least one constraint
+ * call of any kind (index-affecting or pagination) before warning that the marker is orphaned.
+ */ var DEFAULT_CONSTRAINT_FACTORY_NAMES = _to_consumable_array$1(DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES).concat(_to_consumable_array$1(DEFAULT_PAGINATION_CONSTRAINT_NAMES));
+/**
+ * Creates an empty {@link ImportRegistry}.
+ *
+ * @returns A fresh empty registry.
+ */ function createImportRegistry() {
+    return {
+        bySource: new Map(),
+        localToSource: new Map(),
+        localToImported: new Map()
+    };
+}
+/**
+ * Records an `ImportDeclaration` node in the registry.
+ *
+ * @param registry - The registry to mutate.
+ * @param node - The ImportDeclaration AST node.
+ */ function trackImportDeclaration(registry, node) {
+    var _node_source;
+    var source = (_node_source = node.source) === null || _node_source === void 0 ? void 0 : _node_source.value;
+    if (source) {
+        var _registry_bySource_get, _node_specifiers;
+        var localNames = (_registry_bySource_get = registry.bySource.get(source)) !== null && _registry_bySource_get !== void 0 ? _registry_bySource_get : new Set();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = ((_node_specifiers = node.specifiers) !== null && _node_specifiers !== void 0 ? _node_specifiers : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var specifier = _step.value;
+                if (specifier.type === 'ImportSpecifier' || specifier.type === 'ImportDefaultSpecifier' || specifier.type === 'ImportNamespaceSpecifier') {
+                    var _specifier_local;
+                    var localName = (_specifier_local = specifier.local) === null || _specifier_local === void 0 ? void 0 : _specifier_local.name;
+                    if (localName) {
+                        var _ref;
+                        var _specifier_imported;
+                        localNames.add(localName);
+                        registry.localToSource.set(localName, source);
+                        var importedName = specifier.type === 'ImportSpecifier' ? (_ref = (_specifier_imported = specifier.imported) === null || _specifier_imported === void 0 ? void 0 : _specifier_imported.name) !== null && _ref !== void 0 ? _ref : localName : localName;
+                        registry.localToImported.set(localName, importedName);
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        registry.bySource.set(source, localNames);
+    }
+}
+/**
+ * Returns true when the given local identifier name was imported from the given module.
+ *
+ * @param registry - The import registry built from the file's import declarations.
+ * @param localName - The local identifier (as it appears in code).
+ * @param fromSource - The expected source-module string.
+ * @returns True when the local name maps to the given source.
+ */ function isImportedFrom(registry, localName, fromSource) {
+    return registry.localToSource.get(localName) === fromSource;
+}
+/**
+ * Returns the statement-level anchor node that ESLint attaches leading comments to for the
+ * given function-like node. For function declarations this is the declaration (or its
+ * `Export*Declaration` wrapper); for arrow/function expressions assigned to a variable, it
+ * is the variable declaration (or its `Export*Declaration` wrapper); otherwise `null`.
+ *
+ * @param node - The function-like AST node (FunctionDeclaration / FunctionExpression / ArrowFunctionExpression).
+ * @returns The anchor statement node, or null when the function has no JSDoc-anchorable container.
+ */ function getFunctionJsdocAnchor(node) {
+    var result = null;
+    if (node.type === 'FunctionDeclaration') {
+        result = node.parent && (node.parent.type === 'ExportNamedDeclaration' || node.parent.type === 'ExportDefaultDeclaration') ? node.parent : node;
+    } else if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+        var declarator = node.parent;
+        if ((declarator === null || declarator === void 0 ? void 0 : declarator.type) === 'VariableDeclarator') {
+            var declaration = declarator.parent;
+            if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'VariableDeclaration') {
+                var _declaration_parent, _declaration_parent1;
+                result = ((_declaration_parent = declaration.parent) === null || _declaration_parent === void 0 ? void 0 : _declaration_parent.type) === 'ExportNamedDeclaration' || ((_declaration_parent1 = declaration.parent) === null || _declaration_parent1 === void 0 ? void 0 : _declaration_parent1.type) === 'ExportDefaultDeclaration' ? declaration.parent : declaration;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Returns the function name when resolvable: `node.id.name` for declarations, or the
+ * containing `VariableDeclarator.id.name` for arrow/function expressions. Returns `null`
+ * when the function is anonymous in an unrecognized context.
+ *
+ * @param node - The function-like AST node.
+ * @returns The function name, or null when anonymous.
+ */ function getFunctionName(node) {
+    var _node_id;
+    var result = null;
+    if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') && ((_node_id = node.id) === null || _node_id === void 0 ? void 0 : _node_id.type) === 'Identifier') {
+        result = node.id.name;
+    } else if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+        var _declarator_id;
+        var declarator = node.parent;
+        if ((declarator === null || declarator === void 0 ? void 0 : declarator.type) === 'VariableDeclarator' && ((_declarator_id = declarator.id) === null || _declarator_id === void 0 ? void 0 : _declarator_id.type) === 'Identifier') {
+            result = declarator.id.name;
+        }
+    }
+    return result;
+}
+/**
+ * Returns the name-bearing AST node for reporting on a function: the `id` for a
+ * declaration, the `VariableDeclarator.id` for an arrow assignment, or the function node
+ * itself as a last resort.
+ *
+ * @param node - The function-like AST node.
+ * @returns The node to attach a `context.report` location to.
+ */ function getFunctionNameNode(node) {
+    var result = node;
+    if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') && node.id) {
+        result = node.id;
+    } else if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') {
+        var declarator = node.parent;
+        if ((declarator === null || declarator === void 0 ? void 0 : declarator.type) === 'VariableDeclarator' && declarator.id) {
+            result = declarator.id;
+        }
+    }
+    return result;
+}
+
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+/**
+ * ESLint rule that forbids inline `@dereekb/firebase` Firestore constraint factory calls
+ * (`where`, `orderBy`, `limit`, ...) outside a function whose leading JSDoc carries the
+ * `@dbxModelFirebaseIndex` marker. The dbx-components-mcp index extractor only sees
+ * constraints inside tagged factories — anything else is invisible to index generation
+ * and must be extracted into a dedicated `*Query` factory.
+ *
+ * Not auto-fixable: extracting an inline constraint into a new function requires choosing
+ * a name, signature, and call-site replacement that are outside the safe scope of an ESLint
+ * autofix.
+ */ var FIREBASE_REQUIRE_TAGGED_FIRESTORE_CONSTRAINTS_RULE = {
+    meta: {
+        type: 'problem',
+        fixable: undefined,
+        docs: {
+            description: 'Disallow `@dereekb/firebase` index-affecting Firestore constraint factory calls (`where`, `orderBy`) outside a `@dbxModelFirebaseIndex`-tagged query factory. Pagination/cursor factories (`limit`, `limitToLast`, `whereDocumentId`, `startAt`/`After`, `endAt`/`Before`) do not affect composite indexes and are not flagged.',
+            recommended: true
+        },
+        messages: {
+            inlineConstraintOutsideTaggedQuery: '`{{name}}(...)` from `@dereekb/firebase` must be called inside a `@dbxModelFirebaseIndex`-tagged query factory. Extract this constraint into a dedicated `*Query` function tagged with `@dbxModelFirebaseIndex` so dbx-components-mcp can index it, then run `dbx-cli-generate-firestore-indexes --component <dir>` to regenerate `firestore.indexes.json`.'
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    constraintNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    additionalConstraintNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    allowedImportSources: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    markerTag: {
+                        type: 'string'
+                    }
+                }
+            }
+        ]
+    },
+    create: function create(context) {
+        var _context_options_, _options_constraintNames, _options_additionalConstraintNames, _options_allowedImportSources, _options_markerTag;
+        var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
+        var sourceCode = context.sourceCode;
+        var baseNames = (_options_constraintNames = options.constraintNames) !== null && _options_constraintNames !== void 0 ? _options_constraintNames : DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES;
+        var constraintNames = new Set(_to_consumable_array(baseNames).concat(_to_consumable_array((_options_additionalConstraintNames = options.additionalConstraintNames) !== null && _options_additionalConstraintNames !== void 0 ? _options_additionalConstraintNames : [])));
+        var allowedSources = new Set((_options_allowedImportSources = options.allowedImportSources) !== null && _options_allowedImportSources !== void 0 ? _options_allowedImportSources : [
+            FIREBASE_MODULE
+        ]);
+        var markerTag = (_options_markerTag = options.markerTag) !== null && _options_markerTag !== void 0 ? _options_markerTag : DBX_MODEL_FIREBASE_INDEX_MARKER;
+        var registry = createImportRegistry();
+        var stack = [];
+        function jsdocHasMarker(anchor) {
+            var jsdoc = leadingJsdocFor(sourceCode, anchor);
+            var result = false;
+            if (jsdoc) {
+                var parsed = parseJsdocComment(jsdoc.value);
+                result = parsed.tags.some(function(t) {
+                    return t.tag === markerTag;
+                });
+            }
+            return result;
+        }
+        function pushFrame(node) {
+            var _ref;
+            var anchor = getFunctionJsdocAnchor(node);
+            var tagged = anchor ? jsdocHasMarker(anchor) : false;
+            var parent = stack.length > 0 ? stack[stack.length - 1] : null;
+            var taggedDeep = tagged || ((_ref = parent === null || parent === void 0 ? void 0 : parent.taggedDeep) !== null && _ref !== void 0 ? _ref : false);
+            stack.push({
+                node: node,
+                tagged: tagged,
+                taggedDeep: taggedDeep
+            });
+        }
+        function popFrame(node) {
+            if (stack.length > 0 && stack[stack.length - 1].node === node) {
+                stack.pop();
+            }
+        }
+        function isTrackedConstraintCall(node) {
+            var _node_callee;
+            var result = null;
+            if (((_node_callee = node.callee) === null || _node_callee === void 0 ? void 0 : _node_callee.type) === 'Identifier') {
+                var localName = node.callee.name;
+                var source = registry.localToSource.get(localName);
+                if (source && allowedSources.has(source) && isImportedFrom(registry, localName, source)) {
+                    var _registry_localToImported_get;
+                    var importedName = (_registry_localToImported_get = registry.localToImported.get(localName)) !== null && _registry_localToImported_get !== void 0 ? _registry_localToImported_get : localName;
+                    if (constraintNames.has(importedName)) {
+                        result = importedName;
+                    }
+                }
+            }
+            return result;
+        }
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                return trackImportDeclaration(registry, node);
+            },
+            FunctionDeclaration: function FunctionDeclaration(node) {
+                return pushFrame(node);
+            },
+            'FunctionDeclaration:exit': function(node) {
+                return popFrame(node);
+            },
+            FunctionExpression: function FunctionExpression(node) {
+                return pushFrame(node);
+            },
+            'FunctionExpression:exit': function(node) {
+                return popFrame(node);
+            },
+            ArrowFunctionExpression: function ArrowFunctionExpression(node) {
+                return pushFrame(node);
+            },
+            'ArrowFunctionExpression:exit': function(node) {
+                return popFrame(node);
+            },
+            CallExpression: function CallExpression(node) {
+                var name = isTrackedConstraintCall(node);
+                if (name) {
+                    var taggedAncestor = stack.some(function(frame) {
+                        return frame.tagged;
+                    });
+                    if (!taggedAncestor) {
+                        context.report({
+                            node: node,
+                            messageId: 'inlineConstraintOutsideTaggedQuery',
+                            data: {
+                                name: name
+                            }
+                        });
+                    }
+                }
+            }
+        };
+    }
+};
+
+var DEFAULT_STRIPPABLE_SUFFIXES = [
+    'Filter',
+    'Constraints',
+    'Builder'
+];
+/**
+ * Builds a rename suggestion: strips a recognized non-canonical suffix and appends the canonical
+ * `Query` suffix; otherwise appends `Query` directly.
+ *
+ * @param name - The current function name.
+ * @param suffix - The canonical suffix (default `'Query'`).
+ * @param strippable - Suffixes to strip before appending (default `['Filter', 'Constraints', 'Builder']`).
+ * @returns The suggested renamed identifier.
+ */ function buildRenameSuggestion(name, suffix, strippable) {
+    var result = "".concat(name).concat(suffix);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = strippable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var s = _step.value;
+            if (name.endsWith(s) && name.length > s.length) {
+                result = "".concat(name.slice(0, -s.length)).concat(suffix);
+                break;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * ESLint rule that enforces the canonical `Query` suffix on every `@dbxModelFirebaseIndex`-tagged
+ * function. Mirrors the naming used by the canonical fixtures in
+ * `packages/dbx-components-mcp/src/scan/model-firebase-index-extract.spec.ts` and production
+ * factories in `packages/firebase/src/lib/model/**\/*.query.ts`.
+ *
+ * Not auto-fixable: renaming across files (call sites + tests) is outside the safe scope of an
+ * ESLint autofix.
+ */ var FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_QUERY_SUFFIX_RULE = {
+    meta: {
+        type: 'suggestion',
+        fixable: undefined,
+        docs: {
+            description: 'Require the canonical `Query` suffix on `@dbxModelFirebaseIndex`-tagged factories.',
+            recommended: true
+        },
+        messages: {
+            queryFactoryNameMustEndWithQuery: '`@dbxModelFirebaseIndex`-tagged factory `{{name}}` must end with `{{suffix}}`. Rename to e.g. `{{suggestion}}` so dbx-components-mcp can identify it consistently.',
+            anonymousQueryFactory: '`@dbxModelFirebaseIndex`-tagged factories must be named (must end with `{{suffix}}`); anonymous functions are not allowed.'
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    suffix: {
+                        type: 'string'
+                    },
+                    markerTag: {
+                        type: 'string'
+                    },
+                    allowedSuffixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    strippableSuffixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        ]
+    },
+    create: function create(context) {
+        var _context_options_, _options_suffix, _options_markerTag, _options_allowedSuffixes, _options_strippableSuffixes;
+        var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
+        var sourceCode = context.sourceCode;
+        var suffix = (_options_suffix = options.suffix) !== null && _options_suffix !== void 0 ? _options_suffix : QUERY_SUFFIX;
+        var markerTag = (_options_markerTag = options.markerTag) !== null && _options_markerTag !== void 0 ? _options_markerTag : DBX_MODEL_FIREBASE_INDEX_MARKER;
+        var allowedSuffixes = (_options_allowedSuffixes = options.allowedSuffixes) !== null && _options_allowedSuffixes !== void 0 ? _options_allowedSuffixes : [];
+        var strippableSuffixes = (_options_strippableSuffixes = options.strippableSuffixes) !== null && _options_strippableSuffixes !== void 0 ? _options_strippableSuffixes : DEFAULT_STRIPPABLE_SUFFIXES;
+        function isTagged(anchor) {
+            var jsdoc = leadingJsdocFor(sourceCode, anchor);
+            var result = false;
+            if (jsdoc) {
+                var parsed = parseJsdocComment(jsdoc.value);
+                result = parsed.tags.some(function(t) {
+                    return t.tag === markerTag;
+                });
+            }
+            return result;
+        }
+        function nameMatchesSuffix(name) {
+            var matches = name.endsWith(suffix);
+            if (!matches) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = allowedSuffixes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var allowed = _step.value;
+                        if (name.endsWith(allowed)) {
+                            matches = true;
+                            break;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+            return matches;
+        }
+        function check(node) {
+            var anchor = getFunctionJsdocAnchor(node);
+            if (!anchor || !isTagged(anchor)) return;
+            var name = getFunctionName(node);
+            if (!name) {
+                context.report({
+                    node: getFunctionNameNode(node),
+                    messageId: 'anonymousQueryFactory',
+                    data: {
+                        suffix: suffix
+                    }
+                });
+                return;
+            }
+            if (!nameMatchesSuffix(name)) {
+                var suggestion = buildRenameSuggestion(name, suffix, strippableSuffixes);
+                context.report({
+                    node: getFunctionNameNode(node),
+                    messageId: 'queryFactoryNameMustEndWithQuery',
+                    data: {
+                        name: name,
+                        suffix: suffix,
+                        suggestion: suggestion
+                    }
+                });
+            }
+        }
+        return {
+            FunctionDeclaration: function FunctionDeclaration(node) {
+                return check(node);
+            },
+            FunctionExpression: function FunctionExpression(node) {
+                return check(node);
+            },
+            ArrowFunctionExpression: function ArrowFunctionExpression(node) {
+                return check(node);
+            }
+        };
+    }
+};
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Shared helpers for the `@dbx<Family>` companion-tag ESLint rules. Mirrors the
+ * scanner schemas in `packages/dbx-components-mcp/src/scan/*-extract.ts` so
+ * violations surface at lint time instead of at manifest-regeneration time.
+ *
+ * Each per-family rule supplies a {@link DbxTagFamilySpec} describing which
+ * companions are required/optional, what value format each accepts, and which
+ * messageId to emit when a check fails. The rule body itself only wires the
+ * visitors and message map; all value-format validation lives here.
+ */ /**
+ * Kebab-case slug pattern: lowercase letters/digits, words separated by single hyphens,
+ * starts with a letter. Used to validate slug/related/skill-ref values.
+ */ var KEBAB_SLUG_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+/**
+ * Pascal-case TypeScript identifier pattern (starts uppercase). Used for model
+ * identifiers and other `<ModelName>` style tag values.
+ */ var PASCAL_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9_$]*$/;
+/**
+ * Boolean tag-value vocabulary (case-insensitive). `''` and `true|yes` map to
+ * true; `false|no` map to false. Anything else is flagged as invalid.
+ */ var TRUE_TAG_VALUES = new Set([
+    '',
+    'true',
+    'yes'
+]);
+var FALSE_TAG_VALUES = new Set([
+    'false',
+    'no'
+]);
+/**
+ * Splits a comma-separated tag-value string into trimmed items, preserving order.
+ *
+ * @param value - Raw text following the tag name on a single line.
+ * @returns Non-empty trimmed segments in declaration order.
+ */ function splitCommaSeparated(value) {
+    return value.split(',').map(function(item) {
+        return item.trim();
+    }).filter(function(item) {
+        return item.length > 0;
+    });
+}
+/**
+ * Parses a boolean tag value using the workspace vocabulary
+ * (`''`/`true`/`yes` → true; `false`/`no` → false). Other inputs return `undefined`.
+ *
+ * @param text - The trimmed tag value text.
+ * @returns The parsed boolean, or `undefined` when the text is not in the vocabulary.
+ */ function parseBooleanTagValue(text) {
+    var lowered = text.trim().toLowerCase();
+    var result;
+    if (TRUE_TAG_VALUES.has(lowered)) {
+        result = true;
+    } else if (FALSE_TAG_VALUES.has(lowered)) {
+        result = false;
+    }
+    return result;
+}
+/**
+ * Returns the source-text offset of an offset-within-comment-value, given a Block comment node.
+ *
+ * @param commentNode - The ESLint Block comment AST node.
+ * @param valueOffset - The character offset within `comment.value`.
+ * @returns The character offset in the source file.
+ */ function commentValueToSourceOffset(commentNode, valueOffset) {
+    return commentNode.range[0] + 2 + valueOffset;
+}
+/**
+ * Returns the family marker + companion tag list for the given parsed JSDoc.
+ * Family membership is determined by tag-name prefix.
+ *
+ * @param parsed - The parsed JSDoc.
+ * @param marker - The bare family marker (e.g. `'dbxPipe'`).
+ * @returns The marker tag (if present), and all companion tags in source order.
+ */ function findFamilyTags(parsed, marker) {
+    var familyTags = parsed.tags.filter(function(t) {
+        return t.tag === marker || t.tag.startsWith(marker);
+    });
+    var markerTag = parsed.tags.find(function(t) {
+        return t.tag === marker;
+    });
+    return {
+        markerTag: markerTag,
+        familyTags: familyTags
+    };
+}
+/**
+ * Groups companion tags (those after the marker) by suffix. Marker entries are excluded.
+ *
+ * @param familyTags - The family tag list from {@link findFamilyTags}.
+ * @param marker - The bare family marker.
+ * @returns Lookup keyed by companion-suffix listing matching tags in declaration order.
+ */ function groupCompanionsBySuffix(familyTags, marker) {
+    var result = new Map();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = familyTags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var tag = _step.value;
+            var _result_get;
+            if (tag.tag === marker) continue;
+            var suffix = tag.tag.slice(marker.length);
+            var list = (_result_get = result.get(suffix)) !== null && _result_get !== void 0 ? _result_get : [];
+            list.push(tag);
+            result.set(suffix, list);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Per-format validators dispatched from {@link validateCompanionValue}. Each entry validates
+ * a single non-empty tag value and emits zero or more violations.
+ */ var VALUE_VALIDATORS = {
+    marker: function marker() {
+        return undefined;
+    },
+    'free-text': function() {
+        return undefined;
+    },
+    'comma-list-free-text': function() {
+        return undefined;
+    },
+    'kebab-slug': function(param) {
+        var spec = param.spec, value = param.value, lineIndex = param.lineIndex, emit = param.emit;
+        if (!KEBAB_SLUG_PATTERN.test(value)) emit({
+            kind: 'invalid-kebab',
+            suffix: spec.suffix,
+            value: value,
+            lineIndex: lineIndex
+        });
+    },
+    enum: function _enum(param) {
+        var spec = param.spec, value = param.value, lineIndex = param.lineIndex, emit = param.emit;
+        var format = spec.format;
+        if (!format.values.includes(value)) emit({
+            kind: 'invalid-enum',
+            suffix: spec.suffix,
+            value: value,
+            allowed: format.values,
+            lineIndex: lineIndex
+        });
+    },
+    'pascal-identifier': function(param) {
+        var spec = param.spec, value = param.value, lineIndex = param.lineIndex, emit = param.emit;
+        if (!PASCAL_IDENTIFIER_PATTERN.test(value)) emit({
+            kind: 'invalid-pascal',
+            suffix: spec.suffix,
+            value: value,
+            lineIndex: lineIndex
+        });
+    },
+    'comma-list-kebab-slug': function(param) {
+        var spec = param.spec, value = param.value, lineIndex = param.lineIndex, emit = param.emit;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = splitCommaSeparated(value)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var item = _step.value;
+                if (!KEBAB_SLUG_PATTERN.test(item)) emit({
+                    kind: 'comma-item-not-kebab',
+                    suffix: spec.suffix,
+                    value: item,
+                    lineIndex: lineIndex
+                });
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    },
+    'comma-list-lowercase': function(param) {
+        var spec = param.spec, tag = param.tag, value = param.value, lineIndex = param.lineIndex, emit = param.emit;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = splitCommaSeparated(value)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var item = _step.value;
+                if (/[A-Z]/.test(item)) emit({
+                    kind: 'tags-not-lowercase',
+                    suffix: spec.suffix,
+                    value: item,
+                    lineIndex: lineIndex,
+                    raw: tag
+                });
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    },
+    boolean: function boolean(param) {
+        var spec = param.spec, value = param.value, lineIndex = param.lineIndex, emit = param.emit;
+        if (parseBooleanTagValue(value) === undefined) emit({
+            kind: 'invalid-boolean',
+            suffix: spec.suffix,
+            value: value,
+            lineIndex: lineIndex
+        });
+    }
+};
+/**
+ * Validates one companion tag's value against the configured {@link DbxTagFormat}
+ * and emits zero-or-more violations. Used by {@link checkDbxTagFamily} to keep
+ * each rule's body small.
+ *
+ * @param spec - The companion spec being validated.
+ * @param tags - All occurrences of the companion in source order.
+ * @param emit - Callback for each violation.
+ */ function validateCompanionValue(spec, tags, emit) {
+    if (spec.format.kind === 'marker') return;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = tags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var tag = _step.value;
+            var value = tag.description.trim();
+            var lineIndex = tag.startLineIndex;
+            if (value.length === 0) {
+                if (spec.format.kind !== 'boolean') emit({
+                    kind: 'empty',
+                    suffix: spec.suffix,
+                    lineIndex: lineIndex
+                });
+                continue;
+            }
+            var validator = VALUE_VALIDATORS[spec.format.kind];
+            if (validator) validator({
+                spec: spec,
+                tag: tag,
+                value: value,
+                lineIndex: lineIndex,
+                emit: emit
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+function emitUnknownCompanions(groups, knownSuffixes, emit) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = groups.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), suffix = _step_value[0], instances = _step_value[1];
+            if (knownSuffixes.has(suffix)) continue;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = instances[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var tag = _step1.value;
+                    emit({
+                        kind: 'unknown',
+                        suffix: suffix,
+                        lineIndex: tag.startLineIndex
+                    });
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+function emitDuplicateCompanions(companion, instances, emit) {
+    for(var i = 1; i < instances.length; i += 1){
+        emit({
+            kind: 'duplicate',
+            suffix: companion.suffix,
+            lineIndex: instances[i].startLineIndex
+        });
+    }
+}
+function checkCompanion(input) {
+    var companion = input.companion, instances = input.instances, markerLineIndex = input.markerLineIndex, emit = input.emit;
+    if (instances.length === 0) {
+        if (companion.required) emit({
+            kind: 'missing',
+            suffix: companion.suffix,
+            lineIndex: markerLineIndex
+        });
+        return;
+    }
+    if (!companion.multiple && instances.length > 1) emitDuplicateCompanions(companion, instances, emit);
+    validateCompanionValue(companion, instances, emit);
+}
+/**
+ * Validates a `@dbx<Family>` marker plus its companion tags against the supplied spec.
+ * Reports unknown companions, missing required companions, duplicates, and per-companion
+ * value violations through `input.emit`.
+ *
+ * @param input - Parsed JSDoc, family spec, resolved marker/companion tags, and emit sink.
+ *
+ * @example
+ * ```ts
+ * checkDbxTagFamily({ parsed, spec, markerTag, familyTags, emit });
+ * ```
+ */ function checkDbxTagFamily(input) {
+    var spec = input.spec, markerTag = input.markerTag, familyTags = input.familyTags, emit = input.emit;
+    var knownSuffixes = new Set(spec.companions.map(function(c) {
+        return c.suffix;
+    }));
+    var groups = groupCompanionsBySuffix(familyTags, spec.marker);
+    emitUnknownCompanions(groups, knownSuffixes, emit);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = spec.companions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var companion = _step.value;
+            var _groups_get;
+            var instances = (_groups_get = groups.get(companion.suffix)) !== null && _groups_get !== void 0 ? _groups_get : [];
+            checkCompanion({
+                companion: companion,
+                instances: instances,
+                markerLineIndex: markerTag.startLineIndex,
+                emit: emit
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+/**
+ * Translates a JSDoc-line violation into an ESLint `context.report()` call by computing the
+ * source range of the offending line and attaching the supplied message + optional fixer.
+ *
+ * @param input - Reporting context (comment node, parsed JSDoc, source code, line index, message id, optional data + fixer, report sink).
+ *
+ * @example
+ * ```ts
+ * reportOnJsdocLine({ commentNode, parsed, sourceCode, lineIndex: tag.startLineIndex, messageId: 'unknown', report: context.report });
+ * ```
+ */ function reportOnJsdocLine(input) {
+    var _ref, _ref1;
+    var _line_text;
+    var commentNode = input.commentNode, parsed = input.parsed, sourceCode = input.sourceCode, lineIndex = input.lineIndex, messageId = input.messageId, data = input.data, report = input.report, fix = input.fix;
+    var line = parsed.lines[lineIndex];
+    var startInValue = (_ref = line === null || line === void 0 ? void 0 : line.textOffsetStart) !== null && _ref !== void 0 ? _ref : 0;
+    var endInValue = startInValue + ((_ref1 = line === null || line === void 0 ? void 0 : (_line_text = line.text) === null || _line_text === void 0 ? void 0 : _line_text.length) !== null && _ref1 !== void 0 ? _ref1 : 0);
+    var start = commentValueToSourceOffset(commentNode, startInValue);
+    var end = commentValueToSourceOffset(commentNode, endInValue);
+    report({
+        loc: {
+            type: 'SourceLocation',
+            start: sourceCode.getLocFromIndex(start),
+            end: sourceCode.getLocFromIndex(end)
+        },
+        messageId: messageId,
+        data: data,
+        fix: fix
+    });
+}
+/**
+ * Computes an auto-fix descriptor that lowercases every token after a `@dbx<Family>Tags` tag
+ * name. Returns `undefined` when the line is already canonical so the caller can short-circuit.
+ *
+ * @param input - Fix context (comment node, parsed JSDoc, source code, target tag).
+ * @returns Replacement range + text when a rewrite is needed; otherwise `undefined`.
+ *
+ * @example
+ * ```ts
+ * const fix = buildLowercaseTagsFix({ commentNode, parsed, sourceCode, tag });
+ * ```
+ */ function buildLowercaseTagsFix(input) {
+    var commentNode = input.commentNode, parsed = input.parsed, sourceCode = input.sourceCode, tag = input.tag;
+    var tagLine = parsed.lines[tag.startLineIndex];
+    var result;
+    if (tagLine) {
+        var tagLineSourceStart = commentValueToSourceOffset(commentNode, tagLine.textOffsetStart);
+        var tagLineSourceEnd = tagLineSourceStart + tagLine.text.length;
+        var sourceText = sourceCode.getText();
+        var lineSource = sourceText.slice(tagLineSourceStart, tagLineSourceEnd);
+        var lowered = lineSource.replace(/^(@[A-Za-z]+\s+)(.*)$/, function(_match, prefix, body) {
+            return "".concat(prefix).concat(body.toLowerCase());
+        });
+        if (lowered !== lineSource) {
+            result = {
+                startOffset: tagLineSourceStart,
+                endOffset: tagLineSourceEnd,
+                replacement: lowered
+            };
+        }
+    }
+    return result;
+}
+
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var DEFAULT_ALLOWED_SCOPES = [
+    'COLLECTION',
+    'COLLECTION_GROUP'
+];
+var DEFAULT_KNOWN_COMPANIONS = [
+    'Slug',
+    'Model',
+    'Scope',
+    'Dispatcher',
+    'Manual',
+    'Skip',
+    'AllowArrayContainsAny',
+    'Category',
+    'Tags',
+    'Related',
+    'SkillRefs',
+    'Path',
+    'Helper'
+];
+/**
+ * ESLint rule enforcing `@dbxModelFirebaseIndex` companion tags and body coherence.
+ * Mirrors the scanner schema at
+ * `packages/dbx-components-mcp/src/scan/model-firebase-index-extract.ts` (companion tag
+ * validation) and additionally cross-checks the function body so the tag stays in sync
+ * with the constraint calls it advertises.
+ */ var FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Require the canonical `@dbxModelFirebaseIndex*` companion tags on `@dbxModelFirebaseIndex`-tagged factories and verify the body matches the declared model.',
+            recommended: true
+        },
+        messages: {
+            missingModel: '`@dbxModelFirebaseIndex`-tagged factory is missing the required `@dbxModelFirebaseIndexModel <ModelName>` companion tag.',
+            invalidModelIdentifier: '`@dbxModelFirebaseIndexModel` value `{{value}}` is not a valid PascalCase identifier.',
+            invalidScope: '`@dbxModelFirebaseIndexScope` value `{{value}}` is not allowed. Use one of: {{allowed}}.',
+            invalidBooleanValue: '`@dbxModelFirebaseIndex{{name}}` value `{{value}}` is not a recognized boolean.',
+            slugNotKebab: '`@dbxModelFirebaseIndexSlug` value `{{value}}` is not a valid kebab-case slug.',
+            tagsNotLowercase: '`@dbxModelFirebaseIndexTags` token `{{value}}` contains uppercase characters; tokens should be lowercase.',
+            relatedNotKebab: '`@dbxModelFirebaseIndexRelated` item `{{value}}` is not a kebab-case slug.',
+            skillRefsNotKebab: '`@dbxModelFirebaseIndexSkillRefs` item `{{value}}` is not a kebab-case slug.',
+            unknownDbxModelFirebaseIndexTag: '`@dbxModelFirebaseIndex{{name}}` is not a recognized companion tag. Known companions: {{known}}.',
+            duplicateCompanionTag: '`@dbxModelFirebaseIndex{{name}}` is declared more than once.',
+            taggedFactoryHasNoConstraints: '`@dbxModelFirebaseIndex`-tagged factory `{{name}}` contains no `@dereekb/firebase` constraint calls. Add at least one (`where`/`orderBy`/...) or mark it `@dbxModelFirebaseIndexSkip true`.',
+            modelTagMismatchesGenericArg: '`@dbxModelFirebaseIndexModel` is `{{tagValue}}` but the body uses `{{constraint}}<{{generic}}>(...)`. They should match.',
+            nonLiteralFieldPathInTaggedQuery: 'Field path passed to `{{constraint}}(...)` in a `@dbxModelFirebaseIndex`-tagged factory must be a string literal so dbx-components-mcp can extract it.'
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowedScopes: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    knownCompanions: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    requireBareMarker: {
+                        type: 'boolean'
+                    },
+                    constraintNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    allowDynamicFieldPaths: {
+                        type: 'boolean'
+                    },
+                    checkBodyCoherence: {
+                        type: 'boolean'
+                    }
+                }
+            }
+        ]
+    },
+    create: function create(context) {
+        var _context_options_, _options_allowedScopes, _options_knownCompanions, _options_constraintNames;
+        var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
+        var sourceCode = context.sourceCode;
+        var allowedScopes = (_options_allowedScopes = options.allowedScopes) !== null && _options_allowedScopes !== void 0 ? _options_allowedScopes : DEFAULT_ALLOWED_SCOPES;
+        var knownCompanions = (_options_knownCompanions = options.knownCompanions) !== null && _options_knownCompanions !== void 0 ? _options_knownCompanions : DEFAULT_KNOWN_COMPANIONS;
+        var requireBareMarker = options.requireBareMarker !== false;
+        var constraintNames = new Set((_options_constraintNames = options.constraintNames) !== null && _options_constraintNames !== void 0 ? _options_constraintNames : DEFAULT_CONSTRAINT_FACTORY_NAMES);
+        var allowDynamicFieldPaths = options.allowDynamicFieldPaths === true;
+        var checkBodyCoherence = options.checkBodyCoherence !== false;
+        var allCompanions = [
+            {
+                suffix: 'Slug',
+                format: {
+                    kind: 'kebab-slug'
+                }
+            },
+            {
+                suffix: 'Model',
+                required: true,
+                format: {
+                    kind: 'pascal-identifier'
+                }
+            },
+            {
+                suffix: 'Scope',
+                format: {
+                    kind: 'enum',
+                    values: allowedScopes
+                }
+            },
+            {
+                suffix: 'Dispatcher',
+                format: {
+                    kind: 'boolean'
+                }
+            },
+            {
+                suffix: 'Manual',
+                format: {
+                    kind: 'boolean'
+                }
+            },
+            {
+                suffix: 'Skip',
+                format: {
+                    kind: 'boolean'
+                }
+            },
+            {
+                suffix: 'AllowArrayContainsAny',
+                format: {
+                    kind: 'boolean'
+                }
+            },
+            {
+                suffix: 'Category',
+                format: {
+                    kind: 'free-text'
+                }
+            },
+            {
+                suffix: 'Tags',
+                format: {
+                    kind: 'comma-list-lowercase'
+                }
+            },
+            {
+                suffix: 'Related',
+                format: {
+                    kind: 'comma-list-kebab-slug'
+                }
+            },
+            {
+                suffix: 'SkillRefs',
+                format: {
+                    kind: 'comma-list-kebab-slug'
+                }
+            },
+            {
+                suffix: 'Path',
+                multiple: true,
+                format: {
+                    kind: 'comma-list-free-text'
+                }
+            },
+            {
+                suffix: 'Helper',
+                format: {
+                    kind: 'free-text'
+                }
+            }
+        ];
+        var spec = {
+            marker: DBX_MODEL_FIREBASE_INDEX_MARKER,
+            companions: allCompanions.filter(function(c) {
+                return knownCompanions.includes(c.suffix);
+            })
+        };
+        function handleCommaItem(input) {
+            var commentNode = input.commentNode, parsed = input.parsed, suffix = input.suffix, value = input.value, lineIndex = input.lineIndex;
+            if (suffix === 'Related') reportOnJsdocLine({
+                commentNode: commentNode,
+                parsed: parsed,
+                sourceCode: sourceCode,
+                lineIndex: lineIndex,
+                messageId: 'relatedNotKebab',
+                data: {
+                    value: value
+                },
+                report: context.report
+            });
+            else if (suffix === 'SkillRefs') reportOnJsdocLine({
+                commentNode: commentNode,
+                parsed: parsed,
+                sourceCode: sourceCode,
+                lineIndex: lineIndex,
+                messageId: 'skillRefsNotKebab',
+                data: {
+                    value: value
+                },
+                report: context.report
+            });
+        }
+        function handleTagsNotLowercase(commentNode, parsed, v) {
+            if (v.suffix !== 'Tags') return;
+            var fix = buildLowercaseTagsFix({
+                commentNode: commentNode,
+                parsed: parsed,
+                sourceCode: sourceCode,
+                tag: v.raw
+            });
+            var fixer = fix ? function(fixer2) {
+                return fixer2.replaceTextRange([
+                    fix.startOffset,
+                    fix.endOffset
+                ], fix.replacement);
+            } : undefined;
+            reportOnJsdocLine({
+                commentNode: commentNode,
+                parsed: parsed,
+                sourceCode: sourceCode,
+                lineIndex: v.lineIndex,
+                messageId: 'tagsNotLowercase',
+                data: {
+                    value: v.value
+                },
+                report: context.report,
+                fix: fixer
+            });
+        }
+        function handleViolation(commentNode, parsed, v) {
+            switch(v.kind){
+                case 'missing':
+                case 'empty':
+                    if (v.suffix === 'Model') reportOnJsdocLine({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        sourceCode: sourceCode,
+                        lineIndex: v.lineIndex,
+                        messageId: 'missingModel',
+                        report: context.report
+                    });
+                    break;
+                case 'invalid-kebab':
+                    if (v.suffix === 'Slug') reportOnJsdocLine({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        sourceCode: sourceCode,
+                        lineIndex: v.lineIndex,
+                        messageId: 'slugNotKebab',
+                        data: {
+                            value: v.value
+                        },
+                        report: context.report
+                    });
+                    break;
+                case 'invalid-pascal':
+                    if (v.suffix === 'Model') reportOnJsdocLine({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        sourceCode: sourceCode,
+                        lineIndex: v.lineIndex,
+                        messageId: 'invalidModelIdentifier',
+                        data: {
+                            value: v.value
+                        },
+                        report: context.report
+                    });
+                    break;
+                case 'invalid-enum':
+                    if (v.suffix === 'Scope') reportOnJsdocLine({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        sourceCode: sourceCode,
+                        lineIndex: v.lineIndex,
+                        messageId: 'invalidScope',
+                        data: {
+                            value: v.value,
+                            allowed: v.allowed.join(', ')
+                        },
+                        report: context.report
+                    });
+                    break;
+                case 'invalid-boolean':
+                    reportOnJsdocLine({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        sourceCode: sourceCode,
+                        lineIndex: v.lineIndex,
+                        messageId: 'invalidBooleanValue',
+                        data: {
+                            name: v.suffix,
+                            value: v.value
+                        },
+                        report: context.report
+                    });
+                    break;
+                case 'comma-item-not-kebab':
+                    handleCommaItem({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        suffix: v.suffix,
+                        value: v.value,
+                        lineIndex: v.lineIndex
+                    });
+                    break;
+                case 'tags-not-lowercase':
+                    handleTagsNotLowercase(commentNode, parsed, v);
+                    break;
+                case 'unknown':
+                    reportOnJsdocLine({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        sourceCode: sourceCode,
+                        lineIndex: v.lineIndex,
+                        messageId: 'unknownDbxModelFirebaseIndexTag',
+                        data: {
+                            name: v.suffix,
+                            known: knownCompanions.join(', ')
+                        },
+                        report: context.report
+                    });
+                    break;
+                case 'duplicate':
+                    reportOnJsdocLine({
+                        commentNode: commentNode,
+                        parsed: parsed,
+                        sourceCode: sourceCode,
+                        lineIndex: v.lineIndex,
+                        messageId: 'duplicateCompanionTag',
+                        data: {
+                            name: v.suffix
+                        },
+                        report: context.report
+                    });
+                    break;
+            }
+        }
+        function checkJsdoc(commentNode, parsed) {
+            var _findFamilyTags = findFamilyTags(parsed, spec.marker), markerTag = _findFamilyTags.markerTag, familyTags = _findFamilyTags.familyTags;
+            if (familyTags.length === 0 || requireBareMarker && !markerTag) return;
+            var triggerTag = markerTag !== null && markerTag !== void 0 ? markerTag : familyTags[0];
+            checkDbxTagFamily({
+                spec: spec,
+                markerTag: triggerTag,
+                familyTags: familyTags,
+                emit: function emit(v) {
+                    return handleViolation(commentNode, parsed, v);
+                }
+            });
+        }
+        function getModelTagValue(parsed) {
+            var tag = parsed.tags.find(function(t) {
+                return t.tag === "".concat(DBX_MODEL_FIREBASE_INDEX_MARKER, "Model");
+            });
+            return tag ? tag.description.trim() : null;
+        }
+        function getSkipTagValue(parsed) {
+            var tag = parsed.tags.find(function(t) {
+                return t.tag === "".concat(DBX_MODEL_FIREBASE_INDEX_MARKER, "Skip");
+            });
+            var result = false;
+            if (tag) {
+                var value = parseBooleanTagValue(tag.description.trim());
+                result = value === true;
+            }
+            return result;
+        }
+        function collectConstraintCallsIntoArray(node, results) {
+            var _node_callee;
+            if (!node || (typeof node === "undefined" ? "undefined" : _type_of$1(node)) !== 'object') return;
+            if (node.type === 'CallExpression' && ((_node_callee = node.callee) === null || _node_callee === void 0 ? void 0 : _node_callee.type) === 'Identifier' && constraintNames.has(node.callee.name)) {
+                var _node_arguments;
+                var genericName = extractGenericIdentifier(node);
+                var firstArg = (_node_arguments = node.arguments) === null || _node_arguments === void 0 ? void 0 : _node_arguments[0];
+                var fieldPathArgIsLiteral = (firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'Literal' && typeof firstArg.value === 'string';
+                results.push({
+                    node: node,
+                    name: node.callee.name,
+                    genericName: genericName,
+                    fieldPathArgIsLiteral: fieldPathArgIsLiteral
+                });
+            }
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Object.keys(node)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var key = _step.value;
+                    if (key === 'parent') continue;
+                    var value = node[key];
+                    if (Array.isArray(value)) {
+                        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                        try {
+                            for(var _iterator1 = value[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                var child = _step1.value;
+                                if (child && (typeof child === "undefined" ? "undefined" : _type_of$1(child)) === 'object' && typeof child.type === 'string') collectConstraintCallsIntoArray(child, results);
+                            }
+                        } catch (err) {
+                            _didIteratorError1 = true;
+                            _iteratorError1 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                    _iterator1.return();
+                                }
+                            } finally{
+                                if (_didIteratorError1) {
+                                    throw _iteratorError1;
+                                }
+                            }
+                        }
+                    } else if (value && (typeof value === "undefined" ? "undefined" : _type_of$1(value)) === 'object' && typeof value.type === 'string') {
+                        collectConstraintCallsIntoArray(value, results);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        function extractGenericIdentifier(callNode) {
+            var _callNode_typeArguments;
+            var params = (_callNode_typeArguments = callNode.typeArguments) !== null && _callNode_typeArguments !== void 0 ? _callNode_typeArguments : callNode.typeParameters;
+            var result = null;
+            if (params && Array.isArray(params.params) && params.params.length > 0) {
+                var _first_typeName;
+                var first = params.params[0];
+                if ((first === null || first === void 0 ? void 0 : first.type) === 'TSTypeReference' && ((_first_typeName = first.typeName) === null || _first_typeName === void 0 ? void 0 : _first_typeName.type) === 'Identifier') {
+                    result = first.typeName.name;
+                }
+            }
+            return result;
+        }
+        function checkBody(node, parsed) {
+            if (!checkBodyCoherence) return;
+            var skip = getSkipTagValue(parsed);
+            if (skip) return;
+            var calls = [];
+            if (node.body) collectConstraintCallsIntoArray(node.body, calls);
+            if (calls.length === 0) {
+                var _getFunctionName, _node_id;
+                var name = (_getFunctionName = getFunctionName(node)) !== null && _getFunctionName !== void 0 ? _getFunctionName : '<anonymous>';
+                context.report({
+                    node: (_node_id = node.id) !== null && _node_id !== void 0 ? _node_id : node,
+                    messageId: 'taggedFactoryHasNoConstraints',
+                    data: {
+                        name: name
+                    }
+                });
+                return;
+            }
+            var modelTagValue = getModelTagValue(parsed);
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = calls[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var call = _step.value;
+                    if (modelTagValue && call.genericName && call.genericName !== modelTagValue) {
+                        context.report({
+                            node: call.node,
+                            messageId: 'modelTagMismatchesGenericArg',
+                            data: {
+                                tagValue: modelTagValue,
+                                constraint: call.name,
+                                generic: call.genericName
+                            }
+                        });
+                    }
+                    if (!allowDynamicFieldPaths && !call.fieldPathArgIsLiteral && call.name !== 'limit' && call.name !== 'limitToLast' && call.name !== 'startAt' && call.name !== 'startAfter' && call.name !== 'endAt' && call.name !== 'endBefore') {
+                        context.report({
+                            node: call.node,
+                            messageId: 'nonLiteralFieldPathInTaggedQuery',
+                            data: {
+                                constraint: call.name
+                            }
+                        });
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        function checkFunction(node) {
+            if (!node.body) return;
+            var anchor = node.parent && (node.parent.type === 'ExportNamedDeclaration' || node.parent.type === 'ExportDefaultDeclaration') ? node.parent : node;
+            var commentNode = leadingJsdocFor(sourceCode, getStatementAnchor(anchor));
+            if (!commentNode) return;
+            var parsed = parseJsdocComment(commentNode.value);
+            var markerTag = findFamilyTags(parsed, spec.marker).markerTag;
+            if (!markerTag && requireBareMarker) return;
+            checkJsdoc(commentNode, parsed);
+            checkBody(node, parsed);
+        }
+        return {
+            FunctionDeclaration: function FunctionDeclaration(node) {
+                return checkFunction(node);
+            }
+        };
+    }
+};
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+/**
+ * Default JSDoc tag name used to mark a factory as an index dispatcher (boolean tag).
+ */ var DEFAULT_DISPATCHER_TAG = 'dbxModelFirebaseIndexDispatcher';
+/**
+ * Default suffix used to recognise a presumed-tagged query factory by name (single-file scope).
+ */ var DEFAULT_PRESUMED_TAGGED_SUFFIX = 'Query';
+/**
+ * ESLint rule enforcing that `@dbxModelFirebaseIndexDispatcher`-tagged factories delegate to
+ * other `@dbxModelFirebaseIndex`-tagged query factories instead of building constraints directly.
+ *
+ * A dispatcher must never:
+ *
+ *   1. Call a `@dereekb/firebase` constraint factory (`where`/`orderBy`/`limit`/...) directly.
+ *   2. Construct its own `FirestoreQueryConstraint[]` array via `[].push(...)`-style assembly.
+ *
+ * Permitted bodies return another tagged factory's result directly, spread several tagged
+ * factories' results into a return array, or use a conditional to pick between tagged
+ * factories — matching the dispatcher pattern documented at
+ * `packages/dbx-components-mcp/src/tools/validate-app-model-firebase-index.tool.ts`.
+ *
+ * Not auto-fixable: extracting an inline constraint into a sibling tagged factory requires
+ * choosing a name + signature + call-site replacement that is outside the safe scope of an
+ * ESLint autofix.
+ */ var FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE = {
+    meta: {
+        type: 'problem',
+        fixable: undefined,
+        docs: {
+            description: 'Disallow inline `@dereekb/firebase` constraint factory calls and ad-hoc constraint-array construction inside `@dbxModelFirebaseIndexDispatcher`-tagged factories. Dispatchers must delegate to other `@dbxModelFirebaseIndex`-tagged `*Query` factories.',
+            recommended: true
+        },
+        messages: {
+            dispatcherUsesInlineConstraint: '`{{name}}(...)` from `@dereekb/firebase` is not allowed inside a `@dbxModelFirebaseIndexDispatcher`-tagged factory. Dispatchers must call other `@dbxModelFirebaseIndex`-tagged query factories instead of building constraints directly.',
+            dispatcherBuildsConstraintArray: '`@dbxModelFirebaseIndexDispatcher`-tagged factories must not construct their own constraint arrays. Return the result of other tagged `*Query` factories directly (or spread them into a return array).'
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    constraintNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    allowedImportSources: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    markerTag: {
+                        type: 'string'
+                    },
+                    dispatcherTag: {
+                        type: 'string'
+                    },
+                    presumedTaggedSuffix: {
+                        type: 'string'
+                    }
+                }
+            }
+        ]
+    },
+    create: function create(context) {
+        var _context_options_, _options_constraintNames, _options_allowedImportSources, _options_markerTag, _options_dispatcherTag, _options_presumedTaggedSuffix;
+        var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
+        var sourceCode = context.sourceCode;
+        var constraintNames = new Set((_options_constraintNames = options.constraintNames) !== null && _options_constraintNames !== void 0 ? _options_constraintNames : DEFAULT_CONSTRAINT_FACTORY_NAMES);
+        var allowedSources = new Set((_options_allowedImportSources = options.allowedImportSources) !== null && _options_allowedImportSources !== void 0 ? _options_allowedImportSources : [
+            FIREBASE_MODULE
+        ]);
+        var markerTag = (_options_markerTag = options.markerTag) !== null && _options_markerTag !== void 0 ? _options_markerTag : DBX_MODEL_FIREBASE_INDEX_MARKER;
+        var dispatcherTagName = (_options_dispatcherTag = options.dispatcherTag) !== null && _options_dispatcherTag !== void 0 ? _options_dispatcherTag : DEFAULT_DISPATCHER_TAG;
+        // presumedTaggedSuffix is reserved for future heuristics — the current detection only flags
+        // disallowed patterns, so callee-name allow-listing is not consulted here. Read it once so the
+        // option stays documented and validated against the schema.
+        (_options_presumedTaggedSuffix = options.presumedTaggedSuffix) !== null && _options_presumedTaggedSuffix !== void 0 ? _options_presumedTaggedSuffix : DEFAULT_PRESUMED_TAGGED_SUFFIX;
+        var registry = createImportRegistry();
+        function jsdocFlagsDispatcher(anchor) {
+            var jsdoc = leadingJsdocFor(sourceCode, anchor);
+            var result = false;
+            if (jsdoc) {
+                var parsed = parseJsdocComment(jsdoc.value);
+                var hasMarker = parsed.tags.some(function(t) {
+                    return t.tag === markerTag;
+                });
+                if (hasMarker) {
+                    var dispatcherTag = parsed.tags.find(function(t) {
+                        return t.tag === dispatcherTagName;
+                    });
+                    if (dispatcherTag) {
+                        var value = parseBooleanTagValue(dispatcherTag.description.trim());
+                        result = value === true;
+                    }
+                }
+            }
+            return result;
+        }
+        function resolveConstraintCallName(node) {
+            var _node_callee;
+            var result = null;
+            if (((_node_callee = node.callee) === null || _node_callee === void 0 ? void 0 : _node_callee.type) === 'Identifier') {
+                var localName = node.callee.name;
+                var source = registry.localToSource.get(localName);
+                if (source && allowedSources.has(source) && isImportedFrom(registry, localName, source)) {
+                    var _registry_localToImported_get;
+                    var importedName = (_registry_localToImported_get = registry.localToImported.get(localName)) !== null && _registry_localToImported_get !== void 0 ? _registry_localToImported_get : localName;
+                    if (constraintNames.has(importedName)) {
+                        result = importedName;
+                    }
+                }
+            }
+            return result;
+        }
+        function recordCallExpression(node, constraintCalls, pushReceivers) {
+            var _node_callee, _node_callee_property, _node_callee_object;
+            var constraintName = resolveConstraintCallName(node);
+            if (constraintName) {
+                constraintCalls.push({
+                    node: node,
+                    name: constraintName
+                });
+            }
+            if (((_node_callee = node.callee) === null || _node_callee === void 0 ? void 0 : _node_callee.type) === 'MemberExpression' && ((_node_callee_property = node.callee.property) === null || _node_callee_property === void 0 ? void 0 : _node_callee_property.type) === 'Identifier' && node.callee.property.name === 'push' && ((_node_callee_object = node.callee.object) === null || _node_callee_object === void 0 ? void 0 : _node_callee_object.type) === 'Identifier') {
+                pushReceivers.add(node.callee.object.name);
+            }
+        }
+        function recordVariableDeclarator(node, emptyArrayDeclarators) {
+            var _node_id, _node_init;
+            if (((_node_id = node.id) === null || _node_id === void 0 ? void 0 : _node_id.type) === 'Identifier' && ((_node_init = node.init) === null || _node_init === void 0 ? void 0 : _node_init.type) === 'ArrayExpression' && Array.isArray(node.init.elements) && node.init.elements.length === 0) {
+                emptyArrayDeclarators.push({
+                    node: node,
+                    name: node.id.name
+                });
+            }
+        }
+        function scanBody(body) {
+            var constraintCalls = [];
+            var emptyArrayDeclarators = [];
+            var pushReceivers = new Set();
+            function visit(node) {
+                if (!node || (typeof node === "undefined" ? "undefined" : _type_of(node)) !== 'object') return;
+                if (node.type === 'CallExpression') {
+                    recordCallExpression(node, constraintCalls, pushReceivers);
+                } else if (node.type === 'VariableDeclarator') {
+                    recordVariableDeclarator(node, emptyArrayDeclarators);
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Object.keys(node)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var key = _step.value;
+                        if (key === 'parent') continue;
+                        var value = node[key];
+                        if (Array.isArray(value)) {
+                            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                            try {
+                                for(var _iterator1 = value[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                    var child = _step1.value;
+                                    if (child && (typeof child === "undefined" ? "undefined" : _type_of(child)) === 'object' && typeof child.type === 'string') visit(child);
+                                }
+                            } catch (err) {
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                            }
+                        } else if (value && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && typeof value.type === 'string') {
+                            visit(value);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+            visit(body);
+            return {
+                constraintCalls: constraintCalls,
+                emptyArrayDeclarators: emptyArrayDeclarators,
+                pushReceivers: pushReceivers
+            };
+        }
+        function reportViolations(scan) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = scan.constraintCalls[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var call = _step.value;
+                    context.report({
+                        node: call.node,
+                        messageId: 'dispatcherUsesInlineConstraint',
+                        data: {
+                            name: call.name
+                        }
+                    });
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = scan.emptyArrayDeclarators[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var decl = _step1.value;
+                    if (scan.pushReceivers.has(decl.name)) {
+                        context.report({
+                            node: decl.node,
+                            messageId: 'dispatcherBuildsConstraintArray'
+                        });
+                    }
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+        function check(node) {
+            if (!node.body) return;
+            var anchor = getFunctionJsdocAnchor(node);
+            if (!anchor) return;
+            if (!jsdocFlagsDispatcher(anchor)) return;
+            var scan = scanBody(node.body);
+            reportViolations(scan);
+        }
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                return trackImportDeclaration(registry, node);
+            },
+            FunctionDeclaration: function FunctionDeclaration(node) {
+                return check(node);
+            },
+            FunctionExpression: function FunctionExpression(node) {
+                return check(node);
+            },
+            ArrowFunctionExpression: function ArrowFunctionExpression(node) {
+                return check(node);
+            }
+        };
+    }
+};
+
+/**
+ * ESLint plugin for `@dereekb/firebase` rules.
+ *
+ * Register as a plugin in your flat ESLint config, then enable individual rules
+ * under the chosen plugin prefix (e.g. 'dereekb-firebase/require-tagged-firestore-constraints').
+ */ var FIREBASE_ESLINT_PLUGIN = {
+    rules: {
+        'require-tagged-firestore-constraints': FIREBASE_REQUIRE_TAGGED_FIRESTORE_CONSTRAINTS_RULE,
+        'require-dbx-model-firebase-index-query-suffix': FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_QUERY_SUFFIX_RULE,
+        'require-dbx-model-firebase-index-companion-tags': FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE,
+        'require-dbx-model-firebase-index-valid-dispatcher': FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE
+    }
+};
+/**
+ * camelCase alias of {@link FIREBASE_ESLINT_PLUGIN} matching the conventional ESLint plugin export name.
+ *
+ * @dbxAllowConstantName
+ */ var firebaseESLintPlugin = FIREBASE_ESLINT_PLUGIN;
+
+exports.DBX_MODEL_FIREBASE_INDEX_MARKER = DBX_MODEL_FIREBASE_INDEX_MARKER;
+exports.DEFAULT_CONSTRAINT_FACTORY_NAMES = DEFAULT_CONSTRAINT_FACTORY_NAMES;
+exports.DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES = DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES;
+exports.DEFAULT_PAGINATION_CONSTRAINT_NAMES = DEFAULT_PAGINATION_CONSTRAINT_NAMES;
+exports.FIREBASE_ESLINT_PLUGIN = FIREBASE_ESLINT_PLUGIN;
+exports.FIREBASE_MODULE = FIREBASE_MODULE;
+exports.FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE = FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE;
+exports.FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_QUERY_SUFFIX_RULE = FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_QUERY_SUFFIX_RULE;
+exports.FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE = FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE;
+exports.FIREBASE_REQUIRE_TAGGED_FIRESTORE_CONSTRAINTS_RULE = FIREBASE_REQUIRE_TAGGED_FIRESTORE_CONSTRAINTS_RULE;
+exports.QUERY_SUFFIX = QUERY_SUFFIX;
+exports.firebaseESLintPlugin = firebaseESLintPlugin;