@dasasian/firebase-structured-logger 0.9.0 → 1.0.0

package/dist/shared/nodeModules.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Reading facts out of an installed `node_modules` tree.
+ *
+ * Shared by `fsl doctor` (duplicate Storage copies, installed peer versions) and
+ * `smoke/install.ts` (the same duplicate-copy check, against a real install). Moved
+ * here so the two do not carry their own copies of the same walker — doctor's fake
+ * projects and the smoke install are different trees, but "find every copy of this
+ * package under here" is the same question in both.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageJson = readPackageJson;
+exports.findPackageCopies = findPackageCopies;
+exports.findTopLevelVersion = findTopLevelVersion;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Read `<dir>/package.json`, distinguishing "not installed" from "installed but
+ * unreadable" — doctor treats the second as `could-not-check`, never as absent.
+ */
+function readPackageJson(dir) {
+    const file = path.join(dir, 'package.json');
+    if (!fs.existsSync(file))
+        return { ok: false, reason: 'missing' };
+    try {
+        return { ok: true, pkg: JSON.parse(fs.readFileSync(file, 'utf-8')) };
+    }
+    catch {
+        return { ok: false, reason: 'malformed' };
+    }
+}
+/**
+ * Every installed copy of `packageName` under `rootDir/node_modules`, including
+ * copies nested under another package's own `node_modules` (npm dedupe leaves
+ * exactly one; an un-deduped tree can have several).
+ */
+function findPackageCopies(rootDir, packageName) {
+    const found = [];
+    const targetSuffix = path.join(...packageName.split('/'));
+    const walk = (nodeModules) => {
+        if (!fs.existsSync(nodeModules))
+            return;
+        for (const entry of safeReaddir(nodeModules)) {
+            if (entry.startsWith('.'))
+                continue;
+            const entryDir = path.join(nodeModules, entry);
+            const pkgDirs = entry.startsWith('@')
+                ? safeReaddir(entryDir).map((n) => path.join(entryDir, n))
+                : [entryDir];
+            for (const pkgDir of pkgDirs) {
+                if (pkgDir.endsWith(targetSuffix)) {
+                    const read = readPackageJson(pkgDir);
+                    if (read.ok && typeof read.pkg.version === 'string') {
+                        found.push({ dir: pkgDir, version: read.pkg.version });
+                    }
+                }
+                walk(path.join(pkgDir, 'node_modules'));
+            }
+        }
+    };
+    walk(path.join(rootDir, 'node_modules'));
+    return found;
+}
+function safeReaddir(dir) {
+    try {
+        return fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The version of `packageName` installed directly under one of `searchDirs`,
+ * checked in order — the first directory with a top-level copy wins. Used to
+ * resolve peers (`firebase`, `firebase-admin`, `firebase-functions`), which are
+ * singletons in a working tree, unlike `@google-cloud/storage`.
+ */
+function findTopLevelVersion(searchDirs, packageName) {
+    for (const dir of searchDirs) {
+        const pkgDir = path.join(dir, 'node_modules', ...packageName.split('/'));
+        const read = readPackageJson(pkgDir);
+        if (read.ok && typeof read.pkg.version === 'string')
+            return read.pkg.version;
+    }
+    return undefined;
+}
+//# sourceMappingURL=nodeModules.js.map

package/dist/shared/nodeModules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeModules.js","sourceRoot":"","sources":["../../src/shared/nodeModules.ts"],"names":[],"mappings":"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"}

package/dist/shared/versionRange.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The one range shape this package's own `peerDependencies` use: `>=X.Y.Z`.
+ *
+ * Not a general semver comparator — `unsupported-peer` reads ranges from this
+ * package's own `package.json` at runtime rather than copying them into doctor
+ * (so the two cannot drift), and every peer range there is a plain minimum today.
+ * If a future range needs `^` or `||`, this returns `undefined` rather than a
+ * wrong answer, and the caller skips the check instead of guessing.
+ */
+/**
+ * Whether `version` meets `range`, or `undefined` when `range` is not a plain
+ * `>=X.Y.Z` minimum — the caller's signal to skip rather than misreport.
+ */
+export declare function meetsMinimum(version: string, range: string): boolean | undefined;
+/** The leading major version number in a string like `22.11.0`, `^22`, or `nodejs20`. */
+export declare function leadingMajorVersion(text: string): number | undefined;
+//# sourceMappingURL=versionRange.d.ts.map

package/dist/shared/versionRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versionRange.d.ts","sourceRoot":"","sources":["../../src/shared/versionRange.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkBH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAOhF;AAED,yFAAyF;AACzF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGpE"}

package/dist/shared/versionRange.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * The one range shape this package's own `peerDependencies` use: `>=X.Y.Z`.
+ *
+ * Not a general semver comparator — `unsupported-peer` reads ranges from this
+ * package's own `package.json` at runtime rather than copying them into doctor
+ * (so the two cannot drift), and every peer range there is a plain minimum today.
+ * If a future range needs `^` or `||`, this returns `undefined` rather than a
+ * wrong answer, and the caller skips the check instead of guessing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meetsMinimum = meetsMinimum;
+exports.leadingMajorVersion = leadingMajorVersion;
+const VERSION = /^(\d+)\.(\d+)\.(\d+)/;
+const MINIMUM_RANGE = /^>=\s*(\d+)\.(\d+)\.(\d+)/;
+function parseVersion(version) {
+    const match = VERSION.exec(version);
+    if (!match)
+        return undefined;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compare(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return 0;
+}
+/**
+ * Whether `version` meets `range`, or `undefined` when `range` is not a plain
+ * `>=X.Y.Z` minimum — the caller's signal to skip rather than misreport.
+ */
+function meetsMinimum(version, range) {
+    const rangeMatch = MINIMUM_RANGE.exec(range.trim());
+    if (!rangeMatch)
+        return undefined;
+    const minimum = [Number(rangeMatch[1]), Number(rangeMatch[2]), Number(rangeMatch[3])];
+    const parsed = parseVersion(version);
+    if (!parsed)
+        return undefined;
+    return compare(parsed, minimum) >= 0;
+}
+/** The leading major version number in a string like `22.11.0`, `^22`, or `nodejs20`. */
+function leadingMajorVersion(text) {
+    const match = /(\d+)/.exec(text);
+    return match ? Number(match[1]) : undefined;
+}
+//# sourceMappingURL=versionRange.js.map

package/dist/shared/versionRange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"versionRange.js","sourceRoot":"","sources":["../../src/shared/versionRange.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAsBH,oCAOC;AAGD,kDAGC;AAjCD,MAAM,OAAO,GAAG,sBAAsB,CAAA;AACtC,MAAM,aAAa,GAAG,2BAA2B,CAAA;AAEjD,SAAS,YAAY,CAAC,OAAe;IACnC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACnC,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAA;IAC5B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAC/D,CAAC;AAED,SAAS,OAAO,CAAC,CAA2B,EAAE,CAA2B;IACvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;IACvC,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,OAAe,EAAE,KAAa;IACzD,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAA;IACnD,IAAI,CAAC,UAAU;QAAE,OAAO,SAAS,CAAA;IACjC,MAAM,OAAO,GAA6B,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/G,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAAA;IACpC,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAA;IAC7B,OAAO,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;AACtC,CAAC;AAED,yFAAyF;AACzF,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAChC,OAAO,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AAC7C,CAAC"}

package/dist/tools/doctor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `fsl doctor` — checks a project's setup from disk and reports how it will behave.
+ *
+ * Every fact comes from a file with a fixed format: `firebase.json`, `package.json`,
+ * each installed package's own `package.json`, `dist/`, and the embedded `.release`
+ * marker. Nothing
+ * here parses source code or guesses at behavior — a check that cannot read what it
+ * needs reports `could-not-check`, never a pass (see CLAUDE.md, "fsl doctor — facts,
+ * not guesses"). The finding ids, levels, and the `--json` shape are the README's
+ * "Check your setup" section, verbatim; this file exists to make that section true.
+ */
+export type SetupKind = 'firebase' | 'node' | 'browser-only' | 'backend-only';
+export type LoggingPath = 'firebase-functions' | 'stdout' | 'none';
+export type TraceSource = 'trigger' | 'header' | 'none';
+export type StoragePath = 'firebase-admin' | 'google-cloud-storage' | 'none';
+export type FindingLevel = 'error' | 'warning';
+export type FindingId = 'maps-published' | 'node-version' | 'callable-without-firebase-functions' | 'could-not-check' | 'duplicate-storage' | 'unsupported-peer' | 'embedded-maps-without-release';
+export interface DoctorSetup {
+    kind: SetupKind;
+    backend: string | null;
+    dist: string | null;
+    logging: LoggingPath;
+    trace: TraceSource;
+    storage: StoragePath;
+    callable: boolean;
+}
+export interface DoctorFinding {
+    id: FindingId;
+    level: FindingLevel;
+    message: string;
+    fix: string;
+}
+export interface DoctorReport {
+    setup: DoctorSetup;
+    findings: DoctorFinding[];
+    exitCode: number;
+}
+export interface DoctorOptions {
+    projectRoot: string;
+    backend?: string;
+    dist?: string;
+}
+/**
+ * A peer whose supported range cannot be evaluated is `could-not-check`, never a pass:
+ * the ranges are read from this package's own `peerDependencies`, and a range shape
+ * `meetsMinimum` does not understand must surface rather than skip the check.
+ */
+export declare function checkUnsupportedPeers(searchDirs: string[], ownPeerDependencies: Record<string, string>, findings: DoctorFinding[]): void;
+export declare function runDoctor(options: DoctorOptions): DoctorReport;
+/** `report.exitCode` ignores `--strict`; the CLI applies it here. */
+export declare function exitCodeFor(report: DoctorReport, strict: boolean): number;
+/** Renders the human-readable report `fsl doctor` prints without `--json`. */
+export declare function formatDoctorReport(report: DoctorReport): string;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/tools/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/tools/doctor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,cAAc,GAAG,cAAc,CAAA;AAC7E,MAAM,MAAM,WAAW,GAAG,oBAAoB,GAAG,QAAQ,GAAG,MAAM,CAAA;AAClE,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAA;AACvD,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,sBAAsB,GAAG,MAAM,CAAA;AAC5E,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,SAAS,CAAA;AAE9C,MAAM,MAAM,SAAS,GACjB,gBAAgB,GAChB,cAAc,GACd,qCAAqC,GACrC,iBAAiB,GACjB,mBAAmB,GACnB,kBAAkB,GAClB,+BAA+B,CAAA;AAEnC,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,OAAO,EAAE,WAAW,CAAA;IACpB,KAAK,EAAE,WAAW,CAAA;IAClB,OAAO,EAAE,WAAW,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,SAAS,CAAA;IACb,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,WAAW,CAAA;IAClB,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAkMD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAAE,EACpB,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3C,QAAQ,EAAE,aAAa,EAAE,GACxB,IAAI,CAuBN;AA8BD,wBAAgB,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAoC9D;AAED,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAIzE;AA2BD,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CA+B/D"}

package/dist/tools/doctor.js

@@ -0,0 +1,381 @@
+"use strict";
+/**
+ * `fsl doctor` — checks a project's setup from disk and reports how it will behave.
+ *
+ * Every fact comes from a file with a fixed format: `firebase.json`, `package.json`,
+ * each installed package's own `package.json`, `dist/`, and the embedded `.release`
+ * marker. Nothing
+ * here parses source code or guesses at behavior — a check that cannot read what it
+ * needs reports `could-not-check`, never a pass (see CLAUDE.md, "fsl doctor — facts,
+ * not guesses"). The finding ids, levels, and the `--json` shape are the README's
+ * "Check your setup" section, verbatim; this file exists to make that section true.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUnsupportedPeers = checkUnsupportedPeers;
+exports.runDoctor = runDoctor;
+exports.exitCodeFor = exitCodeFor;
+exports.formatDoctorReport = formatDoctorReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const paths_js_1 = require("../shared/paths.js");
+const nodeModules_js_1 = require("../shared/nodeModules.js");
+const versionRange_js_1 = require("../shared/versionRange.js");
+const PEER_PACKAGES = ['firebase', 'firebase-admin', 'firebase-functions'];
+function readFirebaseJson(projectRoot) {
+    const file = path.join(projectRoot, 'firebase.json');
+    if (!fs.existsSync(file))
+        return { ok: 'absent' };
+    try {
+        return { ok: true, config: JSON.parse(fs.readFileSync(file, 'utf-8')) };
+    }
+    catch {
+        return {
+            ok: false,
+            finding: couldNotCheck('firebase.json could not be parsed as JSON.', 'Fix the syntax error in firebase.json.'),
+        };
+    }
+}
+function couldNotCheck(message, fix) {
+    return { id: 'could-not-check', level: 'error', message, fix };
+}
+function firstOf(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+function hostingPublicDirs(hosting) {
+    const configs = Array.isArray(hosting) ? hosting : hosting ? [hosting] : [];
+    return configs.map((c) => c.public).filter((p) => typeof p === 'string');
+}
+/**
+ * Determine the setup this project has, from `firebase.json` when present, or from
+ * `--backend`/`--dist` otherwise. `dist` here is "the folder hosting serves" — under
+ * Firebase that is `hosting.public`; outside Firebase it is whatever `--dist` names.
+ */
+function detectSetup(options, findings) {
+    const firebaseJson = readFirebaseJson(options.projectRoot);
+    if (firebaseJson.ok === false) {
+        findings.push(firebaseJson.finding);
+        return { kind: 'firebase', backendDir: null, distDirs: [] };
+    }
+    if (firebaseJson.ok === true) {
+        const functionsConfig = firstOf(firebaseJson.config.functions);
+        const backend = functionsConfig?.source ?? 'functions';
+        const distDirs = hostingPublicDirs(firebaseJson.config.hosting);
+        return {
+            kind: 'firebase',
+            backendDir: path.resolve(options.projectRoot, backend),
+            distDirs: distDirs.map((d) => path.resolve(options.projectRoot, d)),
+        };
+    }
+    const backendDir = options.backend ? path.resolve(options.projectRoot, options.backend) : null;
+    const distDirs = options.dist ? [path.resolve(options.projectRoot, options.dist)] : [];
+    const kind = backendDir && distDirs.length ? 'node' : backendDir ? 'backend-only' : distDirs.length ? 'browser-only' : 'backend-only';
+    return { kind, backendDir, distDirs };
+}
+function findMapFiles(dir) {
+    const results = [];
+    if (!fs.existsSync(dir))
+        return results;
+    const walk = (current) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.isFile() && entry.name.endsWith('.map'))
+                results.push(full);
+        }
+    };
+    walk(dir);
+    return results;
+}
+function checkMapsPublished(distDirs, findings) {
+    for (const dist of distDirs) {
+        const maps = findMapFiles(dist);
+        if (maps.length === 0)
+            continue;
+        findings.push({
+            id: 'maps-published',
+            level: 'error',
+            message: `${maps.length} .map file(s) found under ${dist}, which hosting serves — your source code is public.`,
+            fix: `Run fsl upload-sourcemaps before deploying, so maps leave ${dist} instead of being published.`,
+        });
+        return;
+    }
+}
+function checkNodeVersion(backendDir, firebaseRuntime, findings) {
+    if (!backendDir)
+        return;
+    if (firebaseRuntime) {
+        const major = (0, versionRange_js_1.leadingMajorVersion)(firebaseRuntime);
+        if (major !== undefined && major < 22) {
+            findings.push({
+                id: 'node-version',
+                level: 'error',
+                message: `firebase.json sets the functions runtime to ${firebaseRuntime}, below the supported floor of Node 22.`,
+                fix: 'Set functions.runtime to "nodejs22" (or later) in firebase.json.',
+            });
+            return;
+        }
+        if (major !== undefined)
+            return;
+    }
+    const read = (0, nodeModules_js_1.readPackageJson)(backendDir);
+    if (!read.ok) {
+        if (read.reason === 'missing') {
+            findings.push(couldNotCheck(`No package.json in ${backendDir}. Run npm install first.`, 'Run npm install in the backend directory.'));
+        }
+        else {
+            findings.push(couldNotCheck(`${path.join(backendDir, 'package.json')} could not be parsed as JSON.`, 'Fix the syntax error in the backend package.json.'));
+        }
+        return;
+    }
+    const engines = read.pkg.engines;
+    const engineNode = engines?.node;
+    if (!engineNode)
+        return;
+    const major = (0, versionRange_js_1.leadingMajorVersion)(engineNode);
+    if (major !== undefined && major < 22) {
+        findings.push({
+            id: 'node-version',
+            level: 'error',
+            message: `${path.join(backendDir, 'package.json')} sets engines.node to "${engineNode}", below the supported floor of Node 22.`,
+            fix: 'Set engines.node to ">=22" in the backend package.json.',
+        });
+    }
+}
+function checkCallable(kind, backendDir, findings) {
+    if (kind !== 'firebase' || !backendDir)
+        return false;
+    const version = (0, nodeModules_js_1.findTopLevelVersion)([backendDir], 'firebase-functions');
+    if (version)
+        return true;
+    findings.push({
+        id: 'callable-without-firebase-functions',
+        level: 'error',
+        message: `firebase.json configures functions in ${backendDir}, but firebase-functions is not installed there.`,
+        fix: `Run npm install firebase-functions in ${backendDir}.`,
+    });
+    return false;
+}
+function checkDuplicateStorage(backendDir, findings) {
+    if (!backendDir || !fs.existsSync(path.join(backendDir, 'node_modules')))
+        return;
+    const copies = (0, nodeModules_js_1.findPackageCopies)(backendDir, '@google-cloud/storage');
+    const versions = [...new Set(copies.map((c) => c.version))];
+    if (versions.length <= 1)
+        return;
+    const placed = copies.map((c) => `${c.version} ${describeOwner(ownerOf(c.dir))}`);
+    findings.push({
+        id: 'duplicate-storage',
+        level: 'warning',
+        message: `${copies.length} copies of @google-cloud/storage (${placed.join(', ')})`,
+        fix: 'npm dedupe',
+    });
+}
+function displayPath(projectRoot, dir) {
+    const relative = path.relative(projectRoot, dir);
+    if (relative === '')
+        return '.';
+    return relative.startsWith('..') || path.isAbsolute(relative) ? relative : `./${relative}`;
+}
+function ownerOf(packageDir) {
+    const parts = packageDir.split(path.sep);
+    const nodeModules = parts.lastIndexOf('node_modules');
+    const previous = parts.lastIndexOf('node_modules', nodeModules - 1);
+    if (previous === -1)
+        return null;
+    const owner = parts.slice(previous + 1, nodeModules);
+    return owner.join('/');
+}
+function describeOwner(owner) {
+    return owner === null ? 'at the top level' : `inside ${owner}`;
+}
+/**
+ * A peer whose supported range cannot be evaluated is `could-not-check`, never a pass:
+ * the ranges are read from this package's own `peerDependencies`, and a range shape
+ * `meetsMinimum` does not understand must surface rather than skip the check.
+ */
+function checkUnsupportedPeers(searchDirs, ownPeerDependencies, findings) {
+    for (const peer of PEER_PACKAGES) {
+        const range = ownPeerDependencies[peer];
+        if (!range)
+            continue;
+        const installed = (0, nodeModules_js_1.findTopLevelVersion)(searchDirs, peer);
+        if (!installed)
+            continue;
+        const meets = (0, versionRange_js_1.meetsMinimum)(installed, range);
+        if (meets === undefined) {
+            findings.push({
+                id: 'could-not-check',
+                level: 'error',
+                message: `Could not compare ${peer} ${installed} with the supported range ${range}.`,
+                fix: 'Report this at https://github.com/dasasian/firebase-structured-logger/issues — doctor needs to learn this range shape.',
+            });
+        }
+        else if (meets === false) {
+            findings.push({
+                id: 'unsupported-peer',
+                level: 'warning',
+                message: `${peer} ${installed} is installed, outside this package's supported range (${range}).`,
+                fix: `Upgrade ${peer} to satisfy ${range}.`,
+            });
+        }
+    }
+}
+function checkEmbeddedMapsWithoutRelease(backendDir, findings) {
+    if (!backendDir)
+        return;
+    const dir = (0, paths_js_1.embeddedDir)(backendDir);
+    if (!fs.existsSync(dir))
+        return;
+    const hasMaps = fs.readdirSync(dir).some((f) => f.endsWith('.map'));
+    if (!hasMaps)
+        return;
+    if (fs.existsSync((0, paths_js_1.embeddedMarkerPath)(backendDir)))
+        return;
+    findings.push({
+        id: 'embedded-maps-without-release',
+        level: 'warning',
+        message: `${dir} has embedded maps but no ${paths_js_1.RELEASE_MARKER} marker — an older release's stack can resolve against the wrong map.`,
+        fix: 'Re-run fsl upload-sourcemaps --embed-sourcemaps, which writes the marker.',
+    });
+}
+/** This package's own `package.json`, read at runtime — never copied into doctor. */
+function readOwnPackageJson() {
+    const read = (0, nodeModules_js_1.readPackageJson)(path.join(__dirname, '..', '..'));
+    if (!read.ok)
+        throw new Error('fsl doctor could not read its own package.json');
+    return read.pkg;
+}
+function resolveStorage(searchDirs) {
+    if ((0, nodeModules_js_1.findTopLevelVersion)(searchDirs, 'firebase-admin'))
+        return 'firebase-admin';
+    if ((0, nodeModules_js_1.findTopLevelVersion)(searchDirs, '@google-cloud/storage'))
+        return 'google-cloud-storage';
+    return 'none';
+}
+function runDoctor(options) {
+    const findings = [];
+    const { kind, backendDir, distDirs } = detectSetup(options, findings);
+    const firebaseJson = readFirebaseJson(options.projectRoot);
+    const firebaseRuntime = firebaseJson.ok === true ? firstOf(firebaseJson.config.functions)?.runtime : undefined;
+    checkMapsPublished(distDirs, findings);
+    checkNodeVersion(backendDir, firebaseRuntime, findings);
+    const callable = checkCallable(kind, backendDir, findings);
+    checkDuplicateStorage(backendDir, findings);
+    const searchDirs = [backendDir, options.projectRoot].filter((d) => d !== null);
+    const ownPkg = readOwnPackageJson();
+    checkUnsupportedPeers(searchDirs, ownPkg.peerDependencies ?? {}, findings);
+    checkEmbeddedMapsWithoutRelease(backendDir, findings);
+    const hasFirebaseFunctions = backendDir !== null && (0, nodeModules_js_1.findTopLevelVersion)([backendDir], 'firebase-functions') !== undefined;
+    const logging = kind === 'firebase' && hasFirebaseFunctions ? 'firebase-functions' : backendDir ? 'stdout' : 'none';
+    const trace = kind === 'firebase' && hasFirebaseFunctions ? 'trigger' : backendDir ? 'header' : 'none';
+    const storage = resolveStorage(searchDirs);
+    const setup = {
+        kind,
+        backend: backendDir ? displayPath(options.projectRoot, backendDir) : null,
+        dist: distDirs[0] ? displayPath(options.projectRoot, distDirs[0]) : null,
+        logging,
+        trace,
+        storage,
+        callable,
+    };
+    const hasError = findings.some((f) => f.level === 'error');
+    const exitCode = hasError ? 1 : 0;
+    return { setup, findings, exitCode };
+}
+/** `report.exitCode` ignores `--strict`; the CLI applies it here. */
+function exitCodeFor(report, strict) {
+    if (report.findings.some((f) => f.level === 'error'))
+        return 1;
+    if (strict && report.findings.some((f) => f.level === 'warning'))
+        return 1;
+    return 0;
+}
+const SETUP_LABEL = {
+    firebase: 'Firebase',
+    node: 'Node',
+    'browser-only': 'browser only',
+    'backend-only': 'backend only',
+};
+const LOGGING_LABEL = {
+    'firebase-functions': 'firebase-functions write()',
+    stdout: 'stdout JSON (createHttpLogHandler)',
+    none: 'not applicable — no backend given',
+};
+const TRACE_LABEL = {
+    trigger: 'from each Cloud Functions trigger',
+    header: 'from the x-cloud-trace-context header',
+    none: 'not applicable — no backend given',
+};
+const STORAGE_LABEL = {
+    'firebase-admin': 'firebase-admin, default bucket',
+    'google-cloud-storage': '@google-cloud/storage — needs a bucket named in code (not checked)',
+    none: 'not configured',
+};
+/** Renders the human-readable report `fsl doctor` prints without `--json`. */
+function formatDoctorReport(report) {
+    const { setup, findings } = report;
+    const backendNoun = setup.kind === 'firebase' ? 'functions' : 'backend';
+    const location = setup.backend && setup.dist
+        ? `${backendNoun} in ${setup.backend}, web build in ${setup.dist}`
+        : setup.backend
+            ? `backend in ${setup.backend}`
+            : setup.dist
+                ? `web build in ${setup.dist}`
+                : 'nothing to check — pass --backend and/or --dist';
+    const lines = [
+        `Setup: ${SETUP_LABEL[setup.kind]} — ${location}`,
+        '',
+        pad('Logging', LOGGING_LABEL[setup.logging]),
+        pad('Trace ids', TRACE_LABEL[setup.trace]),
+        pad('Storage', STORAGE_LABEL[setup.storage]),
+        pad('Callable', setup.callable ? 'createClientLogFunction available' : 'not available'),
+    ];
+    if (findings.length > 0) {
+        lines.push('');
+        for (const finding of findings) {
+            const icon = finding.level === 'error' ? '✗' : '⚠';
+            const indent = ' '.repeat(4);
+            lines.push(`  ${icon} ${finding.id.padEnd(20)} ${finding.message}`);
+            lines.push(`${indent}${' '.repeat(20)}Fix: ${finding.fix}`);
+        }
+    }
+    return lines.join('\n');
+}
+function pad(label, value) {
+    return `  ${label.padEnd(15)}${value}`;
+}
+//# sourceMappingURL=doctor.js.map