@dereekb/dbx-cli 13.11.18 → 13.12.0

package/src/lib/mcp-scan/manifest/model-snapshot-fields-schema.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Arktype schemas for the model-snapshot-fields manifest format.
+ *
+ * Manifests catalog the snapshot field factories and reusable field
+ * constants opted in via the `@dbxModelSnapshotField` JSDoc marker — the
+ * building blocks composed inside `snapshotConverterFunctions<T>({
+ * fields: { ... } })` to convert Firestore documents to/from app models.
+ * One manifest per source — bundled `@dereekb/firebase` plus any
+ * downstream-app manifests discovered via `dbx-mcp.config.json` — feeds
+ * the merged registry that powers the `dbx_model_snapshot_field_lookup`,
+ * `dbx_model_snapshot_field_search`, and `dbx_model_snapshot_field_list_app`
+ * MCP tools.
+ *
+ * Mirrors {@link UtilManifest} (`utils-schema.ts`) — both are produced by
+ * tag-driven scanners over plain TS exports, so the schema shapes line up
+ * one-to-one. The model-snapshot-field schema adds an `optional` flag for
+ * the `optionalFirestore*` variants.
+ */
+/**
+ * Closed vocabulary describing the kind of TypeScript export a snapshot
+ * field is. Only `factory` (a function returning a converter config) and
+ * `const` (a pre-built converter constant like `firestoreModelKeyString`)
+ * are supported — classes and free functions don't fit the snapshot-field
+ * shape.
+ */
+export declare const MODEL_SNAPSHOT_FIELD_KINDS: readonly ["factory", "const"];
+/**
+ * Static type for the closed kind vocabulary.
+ */
+export type ModelSnapshotFieldKindValue = (typeof MODEL_SNAPSHOT_FIELD_KINDS)[number];
+/**
+ * One documented parameter of a factory snapshot field. Mirrors
+ * {@link UtilParamEntry} so the same JSDoc-`@param` extraction logic can
+ * be reused.
+ */
+export declare const ModelSnapshotFieldParamEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    type: string;
+    description: string;
+    optional: boolean;
+}, {}>;
+/**
+ * Static type inferred from {@link ModelSnapshotFieldParamEntry}.
+ */
+export type ModelSnapshotFieldParamEntry = typeof ModelSnapshotFieldParamEntry.infer;
+/**
+ * One snapshot-field entry inside a manifest. Each entry describes a
+ * single exported symbol used inside a `snapshotConverterFunctions` field
+ * map — its slug, kind, category, signature, optional/required flag, and
+ * the documented parameters/return.
+ *
+ * Required fields are the minimum needed for `dbx_model_snapshot_field_lookup`
+ * to render a useful answer; every other field is optional so the auto-
+ * generator can populate them progressively.
+ */
+export declare const ModelSnapshotFieldEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    slug: string;
+    name: string;
+    kind: "const" | "factory";
+    category: string;
+    module: string;
+    subpath: string;
+    signature: string;
+    description: string;
+    optional: boolean;
+    params: {
+        name: string;
+        type: string;
+        description: string;
+        optional: boolean;
+    }[];
+    returns: string;
+    tags: string[];
+    example?: string | undefined;
+    relatedSlugs?: string[] | undefined;
+    skillRefs?: string[] | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ModelSnapshotFieldEntry}.
+ */
+export type ModelSnapshotFieldEntry = typeof ModelSnapshotFieldEntry.infer;
+/**
+ * Top-level manifest envelope. One file per source. The `source` field is
+ * the workspace-unique label used to detect collisions; `module` carries
+ * the npm package the entries ship in.
+ *
+ * `version` is the schema version. The loader currently accepts only
+ * `version: 1`; manifests with any other value are rejected (strict
+ * sources) or warned-and-skipped (non-strict sources).
+ */
+export declare const ModelSnapshotFieldManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: {
+        slug: string;
+        name: string;
+        kind: "const" | "factory";
+        category: string;
+        module: string;
+        subpath: string;
+        signature: string;
+        description: string;
+        optional: boolean;
+        params: {
+            name: string;
+            type: string;
+            description: string;
+            optional: boolean;
+        }[];
+        returns: string;
+        tags: string[];
+        example?: string | undefined;
+        relatedSlugs?: string[] | undefined;
+        skillRefs?: string[] | undefined;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    }[];
+}, {}>;
+/**
+ * Static type inferred from {@link ModelSnapshotFieldManifest}.
+ */
+export type ModelSnapshotFieldManifest = typeof ModelSnapshotFieldManifest.infer;

package/src/lib/mcp-scan/manifest/pipes-loader.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Loader for pipes manifests.
+ *
+ * Reads one or more manifest files (bundled `@dereekb/*` registries plus any
+ * downstream-app manifests discovered via `dbx-mcp.config.json`), validates
+ * them against {@link PipeManifest}, and merges them into a single
+ * lookup-ready registry.
+ *
+ * Failure handling mirrors the semantic-types and forge-fields loaders:
+ * bundled sources are strict by default, external sources are not. If no
+ * source loads successfully the loader throws.
+ */
+import { type PipeEntry } from './pipes-schema.js';
+import { type ManifestLoaderWarning, type ManifestReadFile, type ManifestSource } from './manifest-loader-base.js';
+/**
+ * One manifest the loader is asked to ingest. `path` must be absolute.
+ */
+export type PipeManifestSource = ManifestSource;
+/**
+ * Function shape used by the loader to read manifest contents.
+ */
+export type PipeManifestReadFile = ManifestReadFile;
+/**
+ * Discriminated union of all non-fatal events the loader emits.
+ */
+export type PipeLoaderWarning = ManifestLoaderWarning;
+/**
+ * Input to {@link loadPipeManifests}.
+ */
+export interface LoadPipeManifestsInput {
+    readonly sources: readonly PipeManifestSource[];
+    readonly readFile?: PipeManifestReadFile;
+}
+/**
+ * Result of {@link loadPipeManifests}. `entries` is the merged lookup map
+ * keyed by `${module}::${slug}`; `categoryIndex` is the inverted index from
+ * category value to entry keys (sorted alphabetically for deterministic
+ * output).
+ */
+export interface LoadPipeManifestsResult {
+    readonly entries: ReadonlyMap<string, PipeEntry>;
+    readonly categoryIndex: ReadonlyMap<string, readonly string[]>;
+    readonly warnings: readonly PipeLoaderWarning[];
+    readonly loadedSources: readonly string[];
+}
+/**
+ * Loads, validates, and merges the supplied manifest sources into a single
+ * registry suitable for the `dbx_pipe_lookup` MCP tool.
+ *
+ * @param input - Manifest sources plus an optional injected `readFile`
+ * @returns Merged entries, category index, deterministic warnings, and the list of source labels that loaded.
+ * @throws {Error} When a strict source fails or when zero manifests load successfully.
+ */
+export declare function loadPipeManifests(input: LoadPipeManifestsInput): Promise<LoadPipeManifestsResult>;

package/src/lib/mcp-scan/manifest/pipes-schema.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Arktype schemas for the pipes manifest format.
+ *
+ * Manifests are JSON files that catalog Angular pipe classes — value pipes
+ * (`dollarAmount`, `cutText`, `getValue` / `getValueOnce`), the async helper
+ * (`asObservable`), `prettyjson`, and the date pipe family. One manifest per
+ * source — bundled `@dereekb/*` packages plus any downstream-app manifests
+ * discovered via `dbx-mcp.config.json` — feeds the merged registry that
+ * powers the `dbx_pipe_lookup` MCP tool.
+ *
+ * The schemas in this module are the *contract* — once a downstream app
+ * commits a manifest file, breaking changes here mean every downstream
+ * regenerates. Optional fields can be added in v1; structural breaks must
+ * bump the manifest `version` and update the loader's accepted versions.
+ */
+/**
+ * Browse-friendly category grouping. Mirrors the on-disk folder layout of
+ * `packages/dbx-core/src/lib/pipe/` (`value/`, `date/`, `async/`, `misc/`).
+ */
+export declare const PIPE_CATEGORIES: readonly ["value", "date", "async", "misc"];
+/**
+ * Static type for the closed category vocabulary.
+ */
+export type PipeCategoryValue = (typeof PIPE_CATEGORIES)[number];
+/**
+ * Whether the pipe is `pure: true` (default — runs only when the reference
+ * to its inputs change) or `pure: false` (runs on every change detection).
+ */
+export declare const PIPE_PURITIES: readonly ["pure", "impure"];
+/**
+ * Static type for the closed purity vocabulary.
+ */
+export type PipePurityValue = (typeof PIPE_PURITIES)[number];
+/**
+ * One documented argument supplied to the pipe `transform()` method on top
+ * of the piped value (e.g. `{{ value | dollarAmount:'N/A' }}` — `'N/A'` is
+ * the `defaultIfNull` argument).
+ */
+export declare const PipeArgEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    type: string;
+    description: string;
+    required: boolean;
+}, {}>;
+/**
+ * Static type inferred from {@link PipeArgEntry}.
+ */
+export type PipeArgEntry = typeof PipeArgEntry.infer;
+/**
+ * One pipe entry inside a manifest. Each entry describes a single exported
+ * pipe class — its slug, category, Angular pipe name, transform signature,
+ * and the documented arguments.
+ *
+ * Required fields are the minimum needed for `dbx_pipe_lookup` to render a
+ * useful answer; every other field is optional so the auto-generator can
+ * populate them progressively.
+ */
+export declare const PipeEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    slug: string;
+    category: "value" | "date" | "misc" | "async";
+    pipeName: string;
+    className: string;
+    module: string;
+    inputType: string;
+    outputType: string;
+    purity: "pure" | "impure";
+    description: string;
+    args: {
+        name: string;
+        type: string;
+        description: string;
+        required: boolean;
+    }[];
+    example: string;
+    relatedSlugs?: string[] | undefined;
+    skillRefs?: string[] | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link PipeEntry}.
+ */
+export type PipeEntry = typeof PipeEntry.infer;
+/**
+ * Top-level manifest envelope. One file per source. The `source` field is
+ * the workspace-unique label used to detect collisions; `module` carries
+ * the npm package the entries ship in.
+ *
+ * `version` is the schema version. The loader currently accepts only
+ * `version: 1`; manifests with any other value are rejected (strict
+ * sources) or warned-and-skipped (non-strict sources).
+ */
+export declare const PipeManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: {
+        slug: string;
+        category: "value" | "date" | "misc" | "async";
+        pipeName: string;
+        className: string;
+        module: string;
+        inputType: string;
+        outputType: string;
+        purity: "pure" | "impure";
+        description: string;
+        args: {
+            name: string;
+            type: string;
+            description: string;
+            required: boolean;
+        }[];
+        example: string;
+        relatedSlugs?: string[] | undefined;
+        skillRefs?: string[] | undefined;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    }[];
+}, {}>;
+/**
+ * Static type inferred from {@link PipeManifest}.
+ */
+export type PipeManifest = typeof PipeManifest.infer;

package/src/lib/mcp-scan/manifest/semantic-types-schema.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Arktype schemas for the semantic-types manifest format.
+ *
+ * Manifests are JSON files that catalog semantic types (`EmailAddress`,
+ * `Milliseconds`, `LatLngPoint`, …) from one source — either a `@dereekb/*`
+ * package bundled with this MCP, or a downstream-app manifest discovered via
+ * `dbx-mcp.config.json`. Each manifest contributes its entries to a merged,
+ * cross-package index that the (future) `lookup-semantic-type` and
+ * `search-semantic-type` MCP tools query.
+ *
+ * The schemas in this module are the *contract* — once a downstream app
+ * commits a manifest file, breaking changes here mean every downstream
+ * regenerates. Optional fields can be added in v1; structural breaks must
+ * bump the manifest `version` and update the loader's accepted versions.
+ */
+/**
+ * One semantic-type entry inside a manifest. Each entry describes a single
+ * exported TypeScript type — its definition, where it lives, what topics it
+ * indexes under, and the companion functions (guards, factories, converters)
+ * that travel with it.
+ *
+ * Required fields are the minimum needed for lookup to render a useful
+ * answer. Every other field is optional so the auto-generator can populate
+ * them progressively (e.g. fill `examples` from JSDoc `@example` blocks when
+ * present and skip them otherwise).
+ */
+export declare const SemanticTypeEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    package: string;
+    module: string;
+    kind: "semantic-type" | "type-alias";
+    definition: string;
+    baseType: "string" | "number" | "boolean" | "object" | "branded" | "union-literal" | "template-literal" | "other";
+    topics: string[];
+    unionValues?: string[] | undefined;
+    typeParameters?: string[] | undefined;
+    aliases?: string[] | undefined;
+    related?: string[] | undefined;
+    reExportedFrom?: {
+        package: string;
+        module: string;
+    }[] | undefined;
+    guards?: string[] | undefined;
+    factories?: string[] | undefined;
+    converters?: string[] | undefined;
+    examples?: {
+        code: string;
+        caption?: string | undefined;
+    }[] | undefined;
+    notes?: string | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link SemanticTypeEntry}. Co-named with the const
+ * so callers can write `import { SemanticTypeEntry }` and use it in both
+ * value and type positions.
+ */
+export type SemanticTypeEntry = typeof SemanticTypeEntry.infer;
+/**
+ * Top-level manifest envelope. One file per source. The `source` field is
+ * the workspace-unique label used to detect collisions and to scope
+ * namespaced topics; `topicNamespace` is the prefix attached to those
+ * topics (e.g. `dereekb-util:duration`).
+ *
+ * `version` is the schema version. The loader currently accepts only
+ * `version: 1`; manifests with any other value are rejected (strict
+ * sources) or warned-and-skipped (non-strict sources).
+ */
+export declare const SemanticTypeManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    topicNamespace: string;
+    generatedAt: string;
+    generator: string;
+    topics: string[];
+    entries: {
+        name: string;
+        package: string;
+        module: string;
+        kind: "semantic-type" | "type-alias";
+        definition: string;
+        baseType: "string" | "number" | "boolean" | "object" | "branded" | "union-literal" | "template-literal" | "other";
+        topics: string[];
+        unionValues?: string[] | undefined;
+        typeParameters?: string[] | undefined;
+        aliases?: string[] | undefined;
+        related?: string[] | undefined;
+        reExportedFrom?: {
+            package: string;
+            module: string;
+        }[] | undefined;
+        guards?: string[] | undefined;
+        factories?: string[] | undefined;
+        converters?: string[] | undefined;
+        examples?: {
+            code: string;
+            caption?: string | undefined;
+        }[] | undefined;
+        notes?: string | undefined;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    }[];
+}, {}>;
+/**
+ * Static type inferred from {@link SemanticTypeManifest}.
+ */
+export type SemanticTypeManifest = typeof SemanticTypeManifest.infer;

package/src/lib/mcp-scan/manifest/tokens-loader.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Loader for design-token manifests.
+ *
+ * Reads one or more manifest files (bundled `dereekb-dbx-web`,
+ * `angular-material-m3`, `angular-material-mdc` registries plus any
+ * downstream-app manifests discovered via `dbx-mcp.config.json`),
+ * validates them against {@link TokenManifest}, and merges them into a
+ * single lookup-ready registry.
+ *
+ * Like the ui-components loader, the merged-map key is built from the
+ * entry's own `source` field combined with `cssVariable` so the same
+ * variable name can appear in multiple sources without colliding.
+ */
+import { type TokenEntry } from './tokens-schema.js';
+import { type ManifestLoaderWarning, type ManifestReadFile, type ManifestSource } from './manifest-loader-base.js';
+/**
+ * One manifest the loader is asked to ingest. `path` must be absolute.
+ */
+export type TokenManifestSource = ManifestSource;
+/**
+ * Function shape used by the loader to read manifest contents.
+ */
+export type TokenManifestReadFile = ManifestReadFile;
+/**
+ * Discriminated union of all non-fatal events the loader emits.
+ */
+export type TokenLoaderWarning = ManifestLoaderWarning;
+/**
+ * Input to {@link loadTokenManifests}.
+ */
+export interface LoadTokenManifestsInput {
+    readonly sources: readonly TokenManifestSource[];
+    readonly readFile?: TokenManifestReadFile;
+}
+/**
+ * Result of {@link loadTokenManifests}. `entries` is the merged lookup
+ * map keyed by `${entry.source}::${entry.cssVariable}`; `roleIndex` is
+ * the inverted index from role to entry keys (sorted alphabetically).
+ */
+export interface LoadTokenManifestsResult {
+    readonly entries: ReadonlyMap<string, TokenEntry>;
+    readonly roleIndex: ReadonlyMap<string, readonly string[]>;
+    readonly warnings: readonly TokenLoaderWarning[];
+    readonly loadedSources: readonly string[];
+}
+/**
+ * Loads, validates, and merges the supplied manifest sources into a single
+ * registry suitable for the `dbx_css_token_lookup` and `dbx_ui_smell_check`
+ * MCP tools.
+ *
+ * @param input - Manifest sources plus an optional injected `readFile`
+ * @returns Merged entries, role index, deterministic warnings, and the list of source labels that loaded.
+ * @throws {Error} When a strict source fails or when zero manifests load successfully.
+ */
+export declare function loadTokenManifests(input: LoadTokenManifestsInput): Promise<LoadTokenManifestsResult>;

package/src/lib/mcp-scan/manifest/tokens-schema.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Arktype schemas for the design-token manifest format.
+ *
+ * Manifests catalog CSS custom properties (and their SCSS-side wrappers)
+ * exposed by `@dereekb/dbx-web`, Angular Material's `--mat-sys-*` system, the
+ * underlying `--mdc-*` component tokens, and any downstream-app tokens
+ * declared via `dbx-mcp.config.json`. Each entry advertises the canonical
+ * `var(--…)` reference, intent/role metadata, light/dark defaults, and (when
+ * relevant) the `@dereekb/dbx-web` UI primitive that already wraps the
+ * underlying CSS value.
+ *
+ * The merged registry feeds both `dbx_css_token_lookup` (forward — intent →
+ * token) and `dbx_ui_smell_check` (reverse — paste raw values → flag the
+ * canonical replacement).
+ */
+/**
+ * High-level role for a token — drives both filtering and the heuristic
+ * fallback applied when the SCSS extractor finds no `///` sassdoc block.
+ */
+export declare const TOKEN_ROLES: readonly ["color", "text-color", "surface", "spacing", "radius", "elevation", "shadow", "typography", "motion", "state-layer", "size", "breakpoint", "misc"];
+/**
+ * Static type for the closed token-role vocabulary.
+ */
+export type TokenRoleValue = (typeof TOKEN_ROLES)[number];
+/**
+ * Origin of a token — used for filtering (`category=mat-sys`) and to indicate
+ * authoritative source. `dbx-web` aliases live alongside `mat-sys` system
+ * values; downstream apps surface as `app`.
+ */
+export declare const TOKEN_SOURCES: readonly ["dbx-web", "mat-sys", "mdc", "app"];
+/**
+ * Static type for the closed token-source vocabulary.
+ */
+export type TokenSourceValue = (typeof TOKEN_SOURCES)[number];
+/**
+ * Default values resolved from the source SCSS / theme partials. `light`
+ * and `dark` are both optional — a token might only have one mode, or the
+ * value might be a CSS function reference (`var(--mat-sys-…)`) that gets
+ * captured verbatim.
+ */
+export declare const TokenDefaults: import("arktype/internal/variants/object.ts").ObjectType<{
+    light?: string | undefined;
+    dark?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link TokenDefaults}.
+ */
+export type TokenDefaults = typeof TokenDefaults.infer;
+/**
+ * One token entry in a manifest. Captures everything `dbx_css_token_lookup` and
+ * `dbx_ui_smell_check` need to render an answer — the CSS variable, optional
+ * SCSS-side wrapper, role bucket, intent strings (used for fuzzy intent
+ * matching), light/dark defaults (used for value-distance scoring), utility
+ * classes, and a recommended dbx-web primitive when one wraps the underlying
+ * value.
+ */
+export declare const TokenEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    cssVariable: string;
+    source: "app" | "dbx-web" | "mat-sys" | "mdc";
+    role: "breakpoint" | "size" | "misc" | "spacing" | "color" | "text-color" | "surface" | "radius" | "elevation" | "shadow" | "typography" | "motion" | "state-layer";
+    intents: string[];
+    description: string;
+    defaults: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    };
+    scssVariable?: string | undefined;
+    antiUseNotes?: string | undefined;
+    utilityClasses?: string[] | undefined;
+    componentScope?: string | undefined;
+    recommendedPrimitive?: string | undefined;
+    seeAlso?: string[] | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link TokenEntry}.
+ */
+export type TokenEntry = typeof TokenEntry.infer;
+/**
+ * Top-level token manifest envelope. One file per source label
+ * (`dereekb-dbx-web`, `angular-material-m3`, `angular-material-mdc`,
+ * `<app-name>`). The loader merges these into a single registry,
+ * detecting source-label collisions and entry-key collisions per the
+ * existing `loadManifestsBase` pattern.
+ *
+ * `version` is the schema version. The loader currently accepts only
+ * `version: 1`; any other value is rejected (strict) or warn-and-skip
+ * (non-strict) per `loadManifestsBase`.
+ */
+export declare const TokenManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: {
+        cssVariable: string;
+        source: "app" | "dbx-web" | "mat-sys" | "mdc";
+        role: "breakpoint" | "size" | "misc" | "spacing" | "color" | "text-color" | "surface" | "radius" | "elevation" | "shadow" | "typography" | "motion" | "state-layer";
+        intents: string[];
+        description: string;
+        defaults: {
+            light?: string | undefined;
+            dark?: string | undefined;
+        };
+        scssVariable?: string | undefined;
+        antiUseNotes?: string | undefined;
+        utilityClasses?: string[] | undefined;
+        componentScope?: string | undefined;
+        recommendedPrimitive?: string | undefined;
+        seeAlso?: string[] | undefined;
+    }[];
+}, {}>;
+/**
+ * Static type inferred from {@link TokenManifest}.
+ */
+export type TokenManifest = typeof TokenManifest.infer;

package/src/lib/mcp-scan/manifest/ui-components-loader.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Loader for ui-components manifests.
+ *
+ * Reads one or more manifest files (bundled `@dereekb/*` registries plus any
+ * downstream-app manifests discovered via `dbx-mcp.config.json`), validates
+ * them against {@link UiComponentManifest}, and merges them into a single
+ * lookup-ready registry.
+ *
+ * Unlike the other domain loaders, ui-components builds its merged-map key
+ * from `entry.module` rather than `manifest.module` — entries can carry a
+ * package label that differs from the manifest envelope's module field
+ * (e.g. components re-exported from sibling packages).
+ */
+import { type UiComponentEntry } from './ui-components-schema.js';
+import { type ManifestLoaderWarning, type ManifestReadFile, type ManifestSource } from './manifest-loader-base.js';
+/**
+ * One manifest the loader is asked to ingest. `path` must be absolute.
+ */
+export type UiComponentManifestSource = ManifestSource;
+/**
+ * Function shape used by the loader to read manifest contents.
+ */
+export type UiComponentManifestReadFile = ManifestReadFile;
+/**
+ * Discriminated union of all non-fatal events the loader emits.
+ */
+export type UiComponentLoaderWarning = ManifestLoaderWarning;
+/**
+ * Input to {@link loadUiComponentManifests}.
+ */
+export interface LoadUiComponentManifestsInput {
+    readonly sources: readonly UiComponentManifestSource[];
+    readonly readFile?: UiComponentManifestReadFile;
+}
+/**
+ * Result of {@link loadUiComponentManifests}. `entries` is the merged lookup
+ * map keyed by `${entry.module}::${entry.slug}`; `categoryIndex` is the
+ * inverted index from category to entry keys (sorted alphabetically).
+ */
+export interface LoadUiComponentManifestsResult {
+    readonly entries: ReadonlyMap<string, UiComponentEntry>;
+    readonly categoryIndex: ReadonlyMap<string, readonly string[]>;
+    readonly warnings: readonly UiComponentLoaderWarning[];
+    readonly loadedSources: readonly string[];
+}
+/**
+ * Loads, validates, and merges the supplied manifest sources into a single
+ * registry suitable for the `lookup-ui` / `search-ui` MCP tools.
+ *
+ * @param input - Manifest sources plus an optional injected `readFile`
+ * @returns Merged entries, category index, deterministic warnings, and the list of source labels that loaded.
+ * @throws {Error} When a strict source fails or when zero manifests load successfully.
+ */
+export declare function loadUiComponentManifests(input: LoadUiComponentManifestsInput): Promise<LoadUiComponentManifestsResult>;