@dereekb/dbx-cli 13.38.0 → 13.40.0

package/model-test/src/lib/test/extract.d.ts

@@ -0,0 +1,49 @@
+/**
+ * AST extractor for the `dbx_model_test_*` tool cluster.
+ *
+ * Parses one `.spec.ts` file's structural skeleton via ts-morph and returns
+ * the {@link SpecFileTree} consumed by the tree, search, and formatter
+ * modules. The extractor is pure — disk I/O lives in `inspect.ts`.
+ *
+ * Strategy:
+ * 1. Parse the spec text into an in-memory ts-morph project.
+ * 2. Resolve the workspace `<Prefix>` plus the set of known
+ *    `<prefix><Model>Context` function names. When the caller supplied them
+ *    (from `inspectAppFixtures()`) we use those; otherwise we read the
+ *    spec's own imports off `**\/test/fixture` and derive the prefix as the
+ *    longest common camel-prefix of the `*Context` named imports.
+ * 3. Detect locally-defined helper-describe functions (any top-level
+ *    function/arrow whose body invokes `describe`/`it`).
+ * 4. Walk the file's top-level expression statements; for each call
+ *    expression, classify it (describe / it / hook / fixture / wrapper /
+ *    helperCall) and recurse into its callback body. Recursion only follows
+ *    arrow / function-expression bodies — leaf calls (`expect(...)`,
+ *    `assertSnapshotData(...)`, etc.) are not descended into.
+ */
+import type { SpecFileTree } from './types.js';
+/**
+ * Inputs accepted by {@link extractSpecTreeFromText}.
+ */
+export interface ExtractSpecTreeInput {
+    readonly text: string;
+    readonly specPath: string;
+    /**
+     * Optional explicit prefix (e.g. `Hellosubs`). When supplied alongside
+     * {@link knownFixtureNames}, no import-based detection is attempted.
+     */
+    readonly prefix?: string;
+    /**
+     * Optional explicit list of `<prefix><Model>Context` function names.
+     * Typically supplied from the result of `inspectAppFixtures()`. When
+     * non-empty, fixture-name matching is exact instead of suffix-based.
+     */
+    readonly knownFixtureNames?: readonly string[];
+}
+/**
+ * Pure entry point used by inspect.ts and tests. Parses the supplied spec
+ * text and returns the structural tree; never touches disk.
+ *
+ * @param input - The raw spec text + caller-relative path metadata.
+ * @returns The parsed tree.
+ */
+export declare function extractSpecTreeFromText(input: ExtractSpecTreeInput): SpecFileTree;

package/model-test/src/lib/test/format.hotspots.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Markdown / JSON renderers for `dbx_model_test_hotspots`.
+ *
+ * The markdown renderer leads with the actionable answer — "extend these
+ * existing crud/scenario specs" or "none exist, create these canonical files" —
+ * so the response directly counters the failure mode of concluding a model has
+ * no spec to extend from a filename search.
+ */
+import type { ModelTestHotspotsResult } from './hotspots.js';
+/**
+ * Renders the hotspots result as a JSON string (two-space indent).
+ *
+ * @param result - The hotspots result.
+ * @returns The JSON body.
+ */
+export declare function formatHotspotsAsJson(result: ModelTestHotspotsResult): string;
+/**
+ * Renders the hotspots result as markdown.
+ *
+ * @param result - The hotspots result.
+ * @returns The markdown body.
+ */
+export declare function formatHotspotsAsMarkdown(result: ModelTestHotspotsResult): string;

package/model-test/src/lib/test/format.json.d.ts

@@ -0,0 +1,25 @@
+/**
+ * JSON formatters for the `dbx_model_test_*` tool cluster.
+ *
+ * The tree formatter returns either the full parsed tree or one of the
+ * filtered views; the search formatter returns the search result verbatim.
+ * Both produce stable JSON suitable for downstream tooling.
+ */
+import type { SpecFileTree, SpecSearchResult, SpecTreeFilters, SpecTreeView } from './types.js';
+/**
+ * Renders the tree report for `dbx_model_test_tree` in JSON form.
+ *
+ * @param tree - The parsed spec tree.
+ * @param view - The requested view.
+ * @param filters - Optional model / describe-path filters.
+ * @returns The JSON body.
+ */
+export declare function formatTreeAsJson(tree: SpecFileTree, view?: SpecTreeView, filters?: SpecTreeFilters): string;
+/**
+ * Renders the search report for `dbx_model_test_search` in JSON form.
+ *
+ * @param tree - The parsed spec tree (used for the wrapper metadata)
+ * @param result - The search outcome.
+ * @returns The JSON body.
+ */
+export declare function formatSearchAsJson(tree: SpecFileTree, result: SpecSearchResult): string;

package/model-test/src/lib/test/format.list-app.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Markdown / JSON renderers for `dbx_model_test_list_app`.
+ *
+ * The renderer takes a {@link DiscoveredSpecCatalog} and produces a per-group
+ * listing plus a "Where to add a new test" guidance block and a consolidated
+ * drift report. Output is intentionally compact so the answer to "what's
+ * already here and where do I add the next one?" lives in a single response.
+ */
+import type { DiscoveredSpecCatalog } from './discover.js';
+/**
+ * Renders the list-app report as markdown.
+ *
+ * @param catalog - The discovered, classified catalog.
+ * @param filter - Optional caller-supplied filter — surfaced in the heading
+ *   so the reader knows the listing is scoped.
+ * @param filter.group - When set, the rendered heading notes that only this
+ *   model group is shown. The catalog itself is already pre-filtered.
+ * @returns The markdown body.
+ */
+export declare function formatListAppAsMarkdown(catalog: DiscoveredSpecCatalog, filter?: {
+    readonly group?: string;
+}): string;
+/**
+ * Renders the list-app report as a JSON string (one shape suitable for
+ * automation). Pretty-printed with two-space indent so diffs stay readable.
+ *
+ * @param catalog - The discovered, classified catalog.
+ * @returns The JSON body.
+ */
+export declare function formatListAppAsJson(catalog: DiscoveredSpecCatalog): string;

package/model-test/src/lib/test/format.markdown.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Markdown formatters for the `dbx_model_test_*` tool cluster.
+ *
+ * The tree formatter renders one of the requested {@link SpecTreeView}
+ * variants. The search formatter renders match lists for the four query
+ * modes. Both share a small node-line renderer so the output is consistent.
+ */
+import type { SpecFileTree, SpecSearchResult, SpecTreeFilters, SpecTreeView } from './types.js';
+/**
+ * Renders the tree report for `dbx_model_test_tree`.
+ *
+ * @param tree - The parsed spec tree.
+ * @param view - The requested view (defaults to `all`)
+ * @param filters - Optional model / describe-path filters.
+ * @returns The markdown body.
+ */
+export declare function formatTreeAsMarkdown(tree: SpecFileTree, view?: SpecTreeView, filters?: SpecTreeFilters): string;
+/**
+ * Renders the search report for `dbx_model_test_search`.
+ *
+ * @param tree - The parsed spec tree (used for the header)
+ * @param result - The search outcome.
+ * @returns The markdown body.
+ */
+export declare function formatSearchAsMarkdown(tree: SpecFileTree, result: SpecSearchResult): string;

package/model-test/src/lib/test/hotspots.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Inverse fixture→spec lookup for the `dbx_model_test_hotspots` tool.
+ *
+ * Given a model, finds the existing API integration `.spec.ts` "hotspots" that
+ * reference the model's test fixture (or its parent fixtures), classified
+ * crud-vs-scenario — and, when none exist, the canonical default spec files to
+ * create. Composes the existing scanners ({@link inspectAppFixtures},
+ * {@link discoverSpecFilesByGroup}, {@link extractSpecTreeFromText},
+ * {@link searchSpecTree}) plus the `@dereekb/util` naming-convention helpers; the
+ * only net-new logic is inverting "spec → fixtures it uses" into "fixture → specs
+ * that use it" across the whole app.
+ *
+ * Why this exists: dbx-components API integration specs are grouped by model
+ * **group** (`<group>.crud[.<sub>].spec.ts` / `<group>.scenario[.<sub>].spec.ts`),
+ * not named per-model, so a filename search for a sub-model finds nothing even
+ * though its behaviour is tested inside the parent group's specs.
+ */
+import type { SpecSearchHit } from './types.js';
+/**
+ * The crud/scenario classification of a hotspot's spec file, collapsed from the
+ * finer {@link SpecFileKind} (the `-subgroup` / `-misplaced` variants fold into
+ * their base bucket; everything else is `other`).
+ */
+export type SpecBucket = 'crud' | 'scenario' | 'other';
+/**
+ * One existing spec file that references the target model's fixture or a parent
+ * fixture, with the per-reference counts and the matched fixture nodes.
+ */
+export interface ModelTestHotspot {
+    readonly fileRel: string;
+    readonly bucket: SpecBucket;
+    /**
+     * Fixture-node matches whose model is the target itself.
+     */
+    readonly directRefs: number;
+    /**
+     * Fixture-node matches whose model is a parent fixture the target depends on.
+     */
+    readonly parentRefs: number;
+    /**
+     * The matched fixture nodes (direct then parent), each with its describe path,
+     * inherited fixture chain, and 1-based line range.
+     */
+    readonly hits: readonly SpecSearchHit[];
+}
+/**
+ * Result of {@link findModelTestHotspots}: the resolved fixture context plus the
+ * ranked hotspots, or — when none reference the model — the canonical default
+ * spec files to create.
+ */
+export interface ModelTestHotspotsResult {
+    readonly model: string;
+    readonly apiRel: string;
+    /**
+     * `true` when the model has a `<prefix><Model>TestContext` triplet in
+     * `src/test/fixture.ts`; `false` ⇒ parent inference is unavailable and the
+     * scan falls back to matching the bare model name in specs.
+     */
+    readonly fixtureFound: boolean;
+    /**
+     * Transitive parent-fixture models the target depends on (nearest first).
+     */
+    readonly parentModels: readonly string[];
+    /**
+     * The model group the hotspots / suggestions key off.
+     */
+    readonly group: string;
+    /**
+     * `true` when {@link group} matched an existing `function/<group>/` folder;
+     * `false` ⇒ it was inferred from the model/parent name.
+     */
+    readonly groupMatchedExisting: boolean;
+    /**
+     * Existing spec files referencing the fixture, ranked direct-refs-first.
+     */
+    readonly hotspots: readonly ModelTestHotspot[];
+    /**
+     * Canonical default spec files to create — populated only when
+     * {@link hotspots} is empty.
+     */
+    readonly suggestedFiles: readonly string[];
+}
+/**
+ * Inputs to {@link findModelTestHotspots}.
+ */
+export interface FindModelTestHotspotsConfig {
+    readonly apiAbs: string;
+    readonly apiRel: string;
+    readonly model: string;
+}
+/**
+ * Finds the existing spec hotspots that reference a model's fixture (or its
+ * parents), or the default files to create when there are none.
+ *
+ * @param config - The API-app paths + target model name.
+ * @returns The resolved hotspots result.
+ */
+export declare function findModelTestHotspots(config: FindModelTestHotspotsConfig): Promise<ModelTestHotspotsResult>;

package/model-test/src/lib/test/inspect.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Filesystem inspection for the `dbx_model_test_*` cluster.
+ *
+ * Reads a single `.spec.ts` file from disk and feeds its text through the
+ * pure {@link extractSpecTreeFromText} parser. When `apiDir` is supplied,
+ * the helper also reads the app's `src/test/fixture.ts` via
+ * `inspectAppFixtures()` so the parser can use the authoritative workspace
+ * prefix and the full set of `<prefix><Model>Context` function names.
+ *
+ * Centralising disk I/O here keeps the extractor and search modules pure;
+ * specs build trees from inline text without touching the filesystem.
+ */
+import type { SpecFileTree } from './types.js';
+/**
+ * Reads `<specAbs>` and returns the parsed tree. When `apiDir` is supplied,
+ * the helper additionally inspects `<apiAbs>/src/test/fixture.ts` so the
+ * parser can use the authoritative workspace prefix and the full set of
+ * fixture-context names.
+ *
+ * @param config - Inspection inputs.
+ * @param config.specAbs - Absolute path to the `.spec.ts` file.
+ * @param config.specRel - Caller-relative path metadata.
+ * @param config.apiAbs - Optional absolute path to the API app root.
+ * @param config.apiRel - Optional caller-relative path metadata for the app.
+ * @returns The parsed tree.
+ */
+export declare function inspectSpecFile(config: {
+    readonly specAbs: string;
+    readonly specRel: string;
+    readonly apiAbs?: string;
+    readonly apiRel?: string;
+}): Promise<SpecFileTree>;

package/model-test/src/lib/test/search.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Search over the parsed `SpecFileTree`.
+ *
+ * Walks the tree depth-first while maintaining two stacks:
+ * - `describePath` — the chain of `describe` titles ascending from the
+ *   spec root.
+ * - `fixtureChain` — the chain of fixture model names ascending from the
+ *   spec root.
+ *
+ * Each query mode returns a flat list of {@link SpecSearchHit}s with both
+ * stacks captured per match. Stacks describe the path *down to* the match
+ * (excluding the match itself), so callers can render a search hit with
+ * the full context that a test sitting at that node would inherit.
+ */
+import type { SpecFileTree, SpecSearchQuery, SpecSearchResult } from './types.js';
+/**
+ * Searches a parsed spec tree against a single query. Behaviour by
+ * `query.mode`:.
+ *
+ * - `'model'` — case-insensitive equality match on every `fixture` node's
+ *   {@link SpecNode.model} (e.g. `Job`).
+ * - `'chain'` — case-insensitive consecutive-subsequence match against
+ *   every fixture chain. The query value uses `>` as a separator
+ *   (e.g. `Country > CountryState`).
+ * - `'describe'` — case-insensitive substring match against every
+ *   `describe` node's title.
+ * - `'it'` — case-insensitive substring match against every `it` node's
+ *   title.
+ *
+ * @param tree - The parsed spec tree.
+ * @param query - The search criterion.
+ * @returns The search hits (possibly empty)
+ */
+export declare function searchSpecTree(tree: SpecFileTree, query: SpecSearchQuery): SpecSearchResult;

package/model-test/src/lib/test/types.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Types shared by the `dbx_model_test_*` tool cluster.
+ *
+ * The cluster reads a single `.spec.ts` file from a downstream API app and
+ * parses its structural skeleton: nested `describe`/`it` calls, the
+ * `<prefix><Model>Context(...)` fixture-context calls, locally-defined
+ * helper-describe functions, and the wrapper calls (e.g.
+ * `describeCallableRequestTest`, `<prefix>FunctionContextFactory`) that sit
+ * between them.
+ *
+ * The extractor returns the full {@link SpecFileTree}. Per-view filtering
+ * and search live in their own modules so the parser stays pure.
+ */
+/**
+ * The kind of node detected at a call site inside a spec file.
+ *
+ * - `describe` — `describe(...)` / `xdescribe(...)` / `fdescribe(...)`
+ * - `it` — `it(...)` / `xit(...)` / `fit(...)` / `test(...)`
+ * - `hook` — `beforeEach` / `beforeAll` / `afterEach` / `afterAll`
+ * - `fixture` — a `<prefix><Model>Context(...)` test-context-fixture call
+ * - `wrapper` — any other call that takes a trailing arrow / function
+ *   callback (e.g. `describeCallableRequestTest`,
+ *   `<prefix>FunctionContextFactory`); rendered as a transparent layer
+ * - `helperCall` — a call to a function declared in this same file that
+ *   itself emits `describe`/`it` calls
+ */
+export type SpecNodeKind = 'describe' | 'it' | 'hook' | 'fixture' | 'wrapper' | 'helperCall';
+/**
+ * One structural node detected in a spec file.
+ *
+ * `line`/`endLine` are 1-based line numbers from ts-morph and bracket the
+ * call expression itself (not just its callback body) — they're what callers
+ * use to navigate.
+ */
+export interface SpecNode {
+    readonly kind: SpecNodeKind;
+    /**
+     * Title for `describe`/`it`/`hook` nodes. `undefined` when the call has no
+     * string title (e.g. `beforeEach`) or when the title is a non-trivial
+     * expression — see {@link titleIsTemplate}.
+     */
+    readonly title?: string;
+    /**
+     * `true` when the title was a template literal or non-string-literal
+     * expression and the value reported in {@link title} is a textual
+     * approximation. Callers can use this flag to avoid asserting against the
+     * value.
+     */
+    readonly titleIsTemplate?: boolean;
+    /**
+     * Bare PascalCase model name for `fixture` nodes (e.g. `Country`).
+     * `undefined` when the prefix could not be resolved.
+     */
+    readonly model?: string;
+    /**
+     * The variable name bound by the fixture's callback parameter
+     * (e.g. `(rc) => ...` → `rc`). Only populated for `fixture` nodes.
+     */
+    readonly varName?: string;
+    /**
+     * Identifier names that appear as values in the fixture's first-arg object
+     * (e.g. `{ f, sg, rd, bgb }` → `['f','sg','rd','bgb']`). These map to
+     * parent-fixture variables — the dependency hint that lets callers see
+     * which contexts a fixture relies on.
+     */
+    readonly parentVars?: readonly string[];
+    /**
+     * Identifier name for `wrapper` and `helperCall` nodes (the function being
+     * called).
+     */
+    readonly callee?: string;
+    /**
+     * 1-based line number of the call expression's first character.
+     */
+    readonly line: number;
+    /**
+     * 1-based line number of the call expression's last character.
+     */
+    readonly endLine: number;
+    /**
+     * Child nodes detected inside this node's callback body. Empty for `it`
+     * and `hook` nodes (their body is leaf code).
+     */
+    readonly children: readonly SpecNode[];
+}
+/**
+ * One locally-defined helper function that emits `describe`/`it` calls when
+ * invoked. Detected by walking top-level function declarations and
+ * arrow-function constants.
+ */
+export interface HelperDescribe {
+    readonly name: string;
+    readonly line: number;
+    readonly endLine: number;
+    readonly emitsDescribe: boolean;
+    readonly emitsIt: boolean;
+}
+/**
+ * How the workspace prefix used to detect fixture functions was obtained.
+ *
+ * - `apiDir` — caller supplied an `apiDir` and the prefix came from
+ *   `inspectAppFixtures()` against `<apiDir>/src/test/fixture.ts`.
+ * - `imports` — extracted from the spec file's own import statements
+ *   (named imports off `**\/test/fixture`).
+ * - `unknown` — neither source resolved a prefix; fixture nodes are still
+ *   detected via the `*Context$` suffix heuristic but `model` may be empty.
+ */
+export type PrefixSource = 'apiDir' | 'imports' | 'unknown';
+/**
+ * Aggregate result returned by the extractor.
+ *
+ * The `root` node always has kind `wrapper` and represents the spec file
+ * itself; its children are the top-level statements of the file.
+ */
+export interface SpecFileTree {
+    readonly specPath: string;
+    readonly prefix?: string;
+    readonly prefixSource: PrefixSource;
+    readonly knownFixtureNames: readonly string[];
+    readonly root: SpecNode;
+    readonly helpers: readonly HelperDescribe[];
+    readonly fixtureCallsCount: number;
+    readonly itCount: number;
+    readonly describeCount: number;
+}
+/**
+ * View modes accepted by `dbx_model_test_tree`.
+ */
+export type SpecTreeView = 'all' | 'describes' | 'fixtures' | 'its' | 'helpers';
+/**
+ * Optional filters accepted by `dbx_model_test_tree`.
+ */
+export interface SpecTreeFilters {
+    readonly filterByModel?: string;
+    readonly filterByDescribePath?: string;
+}
+/**
+ * One mutually-exclusive query accepted by `dbx_model_test_search`.
+ */
+export type SpecSearchQuery = {
+    readonly mode: 'model';
+    readonly value: string;
+} | {
+    readonly mode: 'chain';
+    readonly value: string;
+} | {
+    readonly mode: 'describe';
+    readonly value: string;
+} | {
+    readonly mode: 'it';
+    readonly value: string;
+};
+/**
+ * One match returned by the search tool.
+ *
+ * `describePath` lists the describe titles from the spec root down to the
+ * matched node (excluding the matched describe's own title).
+ *
+ * `fixtureChain` lists the model names of every `fixture` ancestor from
+ * the spec root down to the matched node — i.e. the data-setup chain that
+ * a test sitting at this position would inherit.
+ */
+export interface SpecSearchHit {
+    readonly kind: SpecNodeKind;
+    readonly title?: string;
+    readonly model?: string;
+    readonly callee?: string;
+    readonly line: number;
+    readonly endLine: number;
+    readonly describePath: readonly string[];
+    readonly fixtureChain: readonly string[];
+}
+/**
+ * Result returned by `searchSpecTree()`.
+ */
+export interface SpecSearchResult {
+    readonly query: SpecSearchQuery;
+    readonly hits: readonly SpecSearchHit[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/dbx-cli",
-  "version": "13.38.0",
+  "version": "13.40.0",
   "type": "module",
   "sideEffects": false,
   "bin": {
@@ -13,10 +13,9 @@
   },
   "exports": {
     "./eslint": {
-      "module": "./eslint/index.esm.js",
       "types": "./eslint/index.d.ts",
-      "import": "./eslint/index.cjs.mjs",
-      "default": "./eslint/index.cjs.js"
+      "import": "./eslint/index.esm.js",
+      "default": "./eslint/index.esm.js"
     },
     "./firebase-api-manifest": {
       "default": "./firebase-api-manifest/main.js"
@@ -37,44 +36,41 @@
       "default": "./lint-cache/main.js"
     },
     "./manifest-extract": {
-      "module": "./manifest-extract/index.esm.js",
       "types": "./manifest-extract/index.d.ts",
-      "import": "./manifest-extract/index.cjs.mjs",
-      "default": "./manifest-extract/index.cjs.js"
+      "import": "./manifest-extract/index.esm.js",
+      "default": "./manifest-extract/index.esm.js"
     },
     "./model-test": {
-      "module": "./model-test/index.esm.js",
       "types": "./model-test/index.d.ts",
-      "import": "./model-test/index.cjs.mjs",
-      "default": "./model-test/index.cjs.js"
+      "import": "./model-test/index.esm.js",
+      "default": "./model-test/index.esm.js"
     },
     "./route": {
-      "module": "./route/index.esm.js",
       "types": "./route/index.d.ts",
       "import": "./route/index.esm.js",
-      "default": "./route/index.cjs.js"
+      "default": "./route/index.esm.js"
     },
     "./test": {
-      "module": "./test/index.esm.js",
       "types": "./test/index.d.ts",
-      "import": "./test/index.cjs.mjs",
-      "default": "./test/index.cjs.js"
+      "import": "./test/index.esm.js",
+      "default": "./test/index.esm.js"
     },
     "./validate": {
       "default": "./validate/index.js"
     },
     "./package.json": "./package.json",
     ".": {
+      "types": "./index.d.ts",
       "import": "./index.esm.js",
-      "types": "./index.d.ts"
+      "default": "./index.esm.js"
     }
   },
   "peerDependencies": {
-    "@dereekb/date": "13.38.0",
-    "@dereekb/firebase": "13.38.0",
-    "@dereekb/model": "13.38.0",
-    "@dereekb/nestjs": "13.38.0",
-    "@dereekb/util": "13.38.0",
+    "@dereekb/date": "13.40.0",
+    "@dereekb/firebase": "13.40.0",
+    "@dereekb/model": "13.40.0",
+    "@dereekb/nestjs": "13.40.0",
+    "@dereekb/util": "13.40.0",
     "@nestjs/common": "^11.1.19",
     "arktype": "^2.2.0",
     "firebase": "^12.12.1",
@@ -92,4 +88,4 @@
   "module": "./index.esm.js",
   "main": "./index.esm.js",
   "types": "./index.d.ts"
-}
+}

package/route/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@dereekb/dbx-cli/route",
-  "version": "13.38.0",
+  "version": "13.40.0",
+  "type": "module",
   "sideEffects": false,
   "peerDependencies": {
-    "@dereekb/date": "13.38.0",
-    "@dereekb/dbx-cli": "13.38.0",
-    "@dereekb/firebase": "13.38.0",
-    "@dereekb/model": "13.38.0",
-    "@dereekb/nestjs": "13.38.0",
-    "@dereekb/util": "13.38.0"
+    "@dereekb/date": "13.40.0",
+    "@dereekb/dbx-cli": "13.40.0",
+    "@dereekb/firebase": "13.40.0",
+    "@dereekb/model": "13.40.0",
+    "@dereekb/nestjs": "13.40.0",
+    "@dereekb/util": "13.40.0"
   },
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "module": "./index.esm.js",
       "types": "./index.d.ts",
-      "import": "./index.cjs.mjs",
-      "default": "./index.cjs.js"
+      "import": "./index.esm.js",
+      "default": "./index.esm.js"
     }
   },
   "module": "./index.esm.js",
-  "main": "./index.cjs.js",
+  "main": "./index.esm.js",
   "types": "./index.d.ts"
-}
+}