@dereekb/dbx-cli 13.11.18 → 13.12.1

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

@@ -0,0 +1,328 @@
+/**
+ * Arktype schemas for the actions manifest format.
+ *
+ * Manifests are JSON files that catalog the @dereekb/dbx-core action
+ * surface — the directive stack that wires a `dbxAction` context, the
+ * `ActionContextStore` ComponentStore, and the `DbxActionState` enum
+ * members. 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_action_lookup` MCP tool.
+ *
+ * Three entry shapes share a slug index but differ in payload:
+ *
+ *   - `directive` — Angular directive that contributes to a dbxAction context
+ *   - `store`     — the canonical NgRx ComponentStore
+ *   - `state`     — a single member of the `DbxActionState` enum
+ *
+ * The schemas in this module are the *contract* — once a downstream app
+ * commits a manifest file, breaking changes here mean every downstream
+ * regenerates.
+ */
+/**
+ * Three roles that share a slug index but differ in payload.
+ */
+export declare const ACTION_ENTRY_ROLES: readonly ["directive", "store", "state"];
+/**
+ * Static type for the closed role vocabulary.
+ */
+export type ActionEntryRoleValue = (typeof ACTION_ENTRY_ROLES)[number];
+/**
+ * The seven members of `DbxActionState`. Mirrors the source enum — kept as a
+ * closed vocabulary so the manifest schema can validate state-entry slugs
+ * against the canonical set.
+ */
+export declare const DBX_ACTION_STATE_VALUES: readonly ["IDLE", "DISABLED", "TRIGGERED", "VALUE_READY", "WORKING", "RESOLVED", "REJECTED"];
+/**
+ * Static type for the closed state-value vocabulary.
+ */
+export type DbxActionStateValue = (typeof DBX_ACTION_STATE_VALUES)[number];
+/**
+ * One input on a directive — alias, property, type, required flag, default,
+ * description.
+ */
+export declare const ActionInputEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    alias: string;
+    propertyName: string;
+    type: string;
+    required: boolean;
+    description: string;
+    defaultValue?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionInputEntry}.
+ */
+export type ActionInputEntry = typeof ActionInputEntry.infer;
+/**
+ * One output / event emitter on a directive.
+ */
+export declare const ActionOutputEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    type: string;
+    description: string;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionOutputEntry}.
+ */
+export type ActionOutputEntry = typeof ActionOutputEntry.infer;
+/**
+ * One method on the store. `signature` is the full method signature string
+ * (`setIsModified(value: boolean): void`) so callers can render the API
+ * surface without reassembling parameter pieces.
+ */
+export declare const ActionStoreMethodEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    signature: string;
+    description: string;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionStoreMethodEntry}.
+ */
+export type ActionStoreMethodEntry = typeof ActionStoreMethodEntry.infer;
+/**
+ * One public observable on the store.
+ */
+export declare const ActionStoreObservableEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    type: string;
+    description: string;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionStoreObservableEntry}.
+ */
+export type ActionStoreObservableEntry = typeof ActionStoreObservableEntry.infer;
+/**
+ * Directive entry. Captures selector + class + DI behavior + the action
+ * states the directive reads/writes.
+ */
+export declare const ActionDirectiveEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    role: "directive";
+    slug: string;
+    selector: string;
+    className: string;
+    module: string;
+    description: string;
+    skillRefs: string[];
+    inputs: {
+        alias: string;
+        propertyName: string;
+        type: string;
+        required: boolean;
+        description: string;
+        defaultValue?: string | undefined;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    producesContext: boolean;
+    consumesContext: boolean;
+    stateInteraction: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+    example: string;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionDirectiveEntry}.
+ */
+export type ActionDirectiveEntry = typeof ActionDirectiveEntry.infer;
+/**
+ * Store entry. Captures the class metadata plus the public API surface
+ * (methods + observables) and the standard `disabledKey` constants.
+ */
+export declare const ActionStoreEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    role: "store";
+    slug: string;
+    className: string;
+    module: string;
+    description: string;
+    skillRefs: string[];
+    methods: {
+        name: string;
+        signature: string;
+        description: string;
+    }[];
+    observables: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    disabledKeyDefaults: string[];
+    example: string;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionStoreEntry}.
+ */
+export type ActionStoreEntry = typeof ActionStoreEntry.infer;
+/**
+ * State entry. Captures one `DbxActionState` enum member with explicit
+ * transition arrows.
+ */
+export declare const ActionStateEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    role: "state";
+    slug: string;
+    enumName: string;
+    stateValue: "IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED";
+    literal: string;
+    module: string;
+    description: string;
+    skillRefs: string[];
+    transitionsFrom: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+    transitionsTo: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+    example: string;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionStateEntry}.
+ */
+export type ActionStateEntry = typeof ActionStateEntry.infer;
+/**
+ * One action manifest entry, discriminated on `role`.
+ */
+export declare const ActionEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    role: "directive";
+    slug: string;
+    selector: string;
+    className: string;
+    module: string;
+    description: string;
+    skillRefs: string[];
+    inputs: {
+        alias: string;
+        propertyName: string;
+        type: string;
+        required: boolean;
+        description: string;
+        defaultValue?: string | undefined;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    producesContext: boolean;
+    consumesContext: boolean;
+    stateInteraction: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+    example: string;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+} | {
+    role: "store";
+    slug: string;
+    className: string;
+    module: string;
+    description: string;
+    skillRefs: string[];
+    methods: {
+        name: string;
+        signature: string;
+        description: string;
+    }[];
+    observables: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    disabledKeyDefaults: string[];
+    example: string;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+} | {
+    role: "state";
+    slug: string;
+    enumName: string;
+    stateValue: "IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED";
+    literal: string;
+    module: string;
+    description: string;
+    skillRefs: string[];
+    transitionsFrom: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+    transitionsTo: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+    example: string;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ActionEntry}.
+ */
+export type ActionEntry = typeof ActionEntry.infer;
+/**
+ * Top-level manifest envelope. One file per source.
+ */
+export declare const ActionManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: ({
+        role: "directive";
+        slug: string;
+        selector: string;
+        className: string;
+        module: string;
+        description: string;
+        skillRefs: string[];
+        inputs: {
+            alias: string;
+            propertyName: string;
+            type: string;
+            required: boolean;
+            description: string;
+            defaultValue?: string | undefined;
+        }[];
+        outputs: {
+            name: string;
+            type: string;
+            description: string;
+        }[];
+        producesContext: boolean;
+        consumesContext: boolean;
+        stateInteraction: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+        example: string;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    } | {
+        role: "store";
+        slug: string;
+        className: string;
+        module: string;
+        description: string;
+        skillRefs: string[];
+        methods: {
+            name: string;
+            signature: string;
+            description: string;
+        }[];
+        observables: {
+            name: string;
+            type: string;
+            description: string;
+        }[];
+        disabledKeyDefaults: string[];
+        example: string;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    } | {
+        role: "state";
+        slug: string;
+        enumName: string;
+        stateValue: "IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED";
+        literal: string;
+        module: string;
+        description: string;
+        skillRefs: string[];
+        transitionsFrom: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+        transitionsTo: ("IDLE" | "DISABLED" | "TRIGGERED" | "VALUE_READY" | "WORKING" | "RESOLVED" | "REJECTED")[];
+        example: string;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    })[];
+}, {}>;
+/**
+ * Static type inferred from {@link ActionManifest}.
+ */
+export type ActionManifest = typeof ActionManifest.infer;

package/src/lib/mcp-scan/manifest/core-topics.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Closed core topic vocabulary for the semantic-types registry.
+ *
+ * "Topics" are how the registry indexes a semantic type for cross-package
+ * search ("give me everything tagged `date`"). The vocabulary is intentionally
+ * small and centrally controlled: bare topics on a manifest entry must be
+ * present in this list. Manifests can also declare *namespaced* topics of the
+ * form `${manifest.topicNamespace}:<rest>` for source-specific concepts —
+ * those bypass this list but are scoped to the declaring manifest.
+ *
+ * Adding a new core topic is a deliberate code change so the vocab stays
+ * consistent across `@dereekb/*` and downstream apps. The set is small on
+ * purpose; reach for namespaced topics for app-local concepts.
+ */
+/**
+ * The complete list of bare topics any manifest entry may declare.
+ *
+ * Categories are intentionally broad — narrower buckets belong in namespaced
+ * topics (e.g. `dereekb-util:duration`). Order is informational only; lookup
+ * code treats this as a Set.
+ */
+export declare const CORE_TOPICS: readonly ["identifier", "time", "duration", "date", "timezone", "numeric", "string", "contact", "geo", "url", "phone", "email", "currency", "measurement", "percent", "enum", "reference"];
+/**
+ * Union of every bare topic accepted by manifest entries.
+ */
+export type CoreTopic = (typeof CORE_TOPICS)[number];
+/**
+ * Eagerly-computed Set of {@link CORE_TOPICS} for O(1) membership checks.
+ * Exposed as `readonly` so callers can't mutate the shared instance.
+ */
+export declare const CORE_TOPICS_SET: ReadonlySet<string>;
+/**
+ * Returns whether `topic` is a recognised bare core topic.
+ *
+ * @param topic - The topic string to test.
+ * @returns `true` when `topic` is present in {@link CORE_TOPICS}
+ */
+export declare function isCoreTopic(topic: string): topic is CoreTopic;

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

@@ -0,0 +1,55 @@
+/**
+ * Loader for CSS-utility-class manifests.
+ *
+ * Reads one or more manifest files (the bundled
+ * `dereekb-dbx-web.css-utilities.mcp.generated.json` plus any downstream
+ * manifests discovered via `dbx-mcp.config.json`'s `cssUtilities` cluster
+ * block), validates them against {@link CssUtilityManifest}, and merges
+ * them into a single lookup-ready registry.
+ *
+ * The merged-map key combines the manifest's `source` label with the
+ * entry's `slug` so the same slug can appear in multiple sources without
+ * colliding. Mirrors the tokens loader.
+ */
+import { type CssUtilityEntry } from './css-utilities-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 CssUtilityManifestSource = ManifestSource;
+/**
+ * Function shape used by the loader to read manifest contents.
+ */
+export type CssUtilityManifestReadFile = ManifestReadFile;
+/**
+ * Discriminated union of all non-fatal events the loader emits.
+ */
+export type CssUtilityLoaderWarning = ManifestLoaderWarning;
+/**
+ * Input to {@link loadCssUtilityManifests}.
+ */
+export interface LoadCssUtilityManifestsInput {
+    readonly sources: readonly CssUtilityManifestSource[];
+    readonly readFile?: CssUtilityManifestReadFile;
+}
+/**
+ * Result of {@link loadCssUtilityManifests}. `entries` is the merged lookup
+ * map keyed by `${entry.source}::${entry.slug}`; `roleIndex` maps each role
+ * to the alphabetically-sorted entry keys claiming it.
+ */
+export interface LoadCssUtilityManifestsResult {
+    readonly entries: ReadonlyMap<string, CssUtilityEntry>;
+    readonly roleIndex: ReadonlyMap<string, readonly string[]>;
+    readonly warnings: readonly CssUtilityLoaderWarning[];
+    readonly loadedSources: readonly string[];
+}
+/**
+ * Loads, validates, and merges the supplied manifest sources into a single
+ * registry suitable for the `dbx_css_class_lookup` MCP tool.
+ *
+ * @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 loadCssUtilityManifests(input: LoadCssUtilityManifestsInput): Promise<LoadCssUtilityManifestsResult>;

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

@@ -0,0 +1,168 @@
+/**
+ * Arktype schemas for the CSS-utility-class manifest format.
+ *
+ * Manifests catalog the curated, opt-in utility classes shipped by
+ * `@dereekb/dbx-web` (and any downstream apps that opt into the same
+ * `cssUtilities.scan[]` pipeline). Each entry maps a single class selector
+ * (`.dbx-flex-fill-0`, `.dbx-text-truncate`, …) to its source file/line, the
+ * flat property/value declarations the rule emits, and curator-supplied
+ * metadata (intent, role, see-also, anti-use, optional parent slug, optional
+ * compound-selector context chain).
+ *
+ * Curation is opt-in: only selectors annotated with `/// @dbx-utility` in the
+ * source SCSS make it into the registry. Extension-feature classes are
+ * excluded by design so the catalog stays focused on reusable primitives.
+ *
+ * The optional `parent` slug groups helper utilities under a parent class
+ * (e.g. `dbx-list-two-line-item-icon` carries `parent: "dbx-list-two-line-item"`).
+ * The runtime registry exposes a `byParent` index and `findChildrenOf(slug)`
+ * accessor; the lookup tool hides children from bulk browse/search results
+ * by default to keep output focused on top-level primitives.
+ *
+ * The optional `selectorContext` field captures the full descendant-chain
+ * selector when a utility is defined as a compound rule (e.g.
+ * `.dbx-list-no-item-padding .dbx-list > .dbx-list-content …`). The first
+ * flat class in the chain becomes the canonical `selector` (the host class
+ * consumers add to their HTML), and the original compound text is preserved
+ * as `selectorContext` so the usage context — "apply this class within a
+ * `.dbx-list` context" — is not lost. Flat top-level utilities omit this
+ * field.
+ *
+ * The optional `component` and `scope` fields mark an entry as a
+ * component-owned class (e.g. `.dbx-icon-tile` belongs to
+ * `DbxIconTileComponent`). Setting `scope: "component-class"` tells the
+ * lookup tool to render a "use the component, not the class" hint while
+ * still surfacing the rule's CSS variables — useful for understanding
+ * how to customize the component via tokens without misapplying the
+ * class to arbitrary markup.
+ *
+ * The optional `tokensRead` / `tokensSet` arrays capture the CSS custom
+ * properties this rule reads (via `var(--name, …)`) and sets (via
+ * `--name: value` declarations). Both arrays are derived deterministically
+ * from the rule's body during extraction. They give consumers a direct
+ * "what can I override?" / "what does this override on descendants?" view
+ * without re-parsing the source SCSS.
+ *
+ * The merged registry feeds `dbx_css_class_lookup` — forward (intent →
+ * class), reverse (declarations → class), exact-name, and parent-scoped
+ * modes share one shape.
+ */
+/**
+ * High-level role for a CSS utility class — drives both filtering and the
+ * heuristic score weighting inside the equivalency search engine. Roles are
+ * intentionally coarse so the curation gate stays low-friction.
+ */
+export declare const CSS_UTILITY_ROLES: readonly ["layout", "flex", "text", "spacing", "state", "interaction", "color", "text-color", "surface", "size", "radius", "misc"];
+/**
+ * Static type for the closed CSS-utility-role vocabulary.
+ */
+export type CssUtilityRoleValue = (typeof CSS_UTILITY_ROLES)[number];
+/**
+ * Closed vocabulary for the optional `scope` field on a utility entry.
+ *
+ * - `utility` (default when omitted) — a reusable utility class consumers
+ *   can apply to any element.
+ * - `component-class` — a class that ships as part of an Angular component
+ *   template. The class is cataloged so its tokens and intent are
+ *   discoverable, but it should NOT be added to arbitrary elements; use the
+ *   owning component instead. Pair with `@component <ClassName>` so the
+ *   lookup tool can name the owner.
+ */
+export declare const CSS_UTILITY_SCOPES: readonly ["utility", "component-class"];
+/**
+ * Static type for the closed CSS-utility-scope vocabulary.
+ */
+export type CssUtilityScopeValue = (typeof CSS_UTILITY_SCOPES)[number];
+/**
+ * One flat CSS declaration captured from the source rule. Properties are
+ * lowercased; values are preserved verbatim so downstream consumers can
+ * surface the exact text (handy when the value is a CSS function, var
+ * reference, or expression).
+ */
+export declare const CssUtilityDeclaration: import("arktype/internal/variants/object.ts").ObjectType<{
+    property: string;
+    value: string;
+}, {}>;
+/**
+ * Static type inferred from {@link CssUtilityDeclaration}.
+ */
+export type CssUtilityDeclaration = typeof CssUtilityDeclaration.infer;
+/**
+ * One CSS-utility-class entry in a manifest. Captures the slug (curator
+ * choice; defaults to selector minus leading `.`), the canonical selector,
+ * file/line provenance, the flat declarations the rule emits, and any
+ * curator-supplied metadata (role, intent, see-also list, anti-use note,
+ * `@since` version tag, optional `@parent` slug grouping helper utilities
+ * under their parent class).
+ */
+export declare const CssUtilityEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    slug: string;
+    selector: string;
+    source: string;
+    module: string;
+    file: string;
+    line: number;
+    declarations: {
+        property: string;
+        value: string;
+    }[];
+    role?: "state" | "text" | "size" | "layout" | "misc" | "flex" | "spacing" | "interaction" | "color" | "text-color" | "surface" | "radius" | undefined;
+    intent?: string | undefined;
+    seeAlso?: string[] | undefined;
+    antiUse?: string | undefined;
+    since?: string | undefined;
+    parent?: string | undefined;
+    selectorContext?: string | undefined;
+    component?: string | undefined;
+    scope?: "utility" | "component-class" | undefined;
+    tokensRead?: string[] | undefined;
+    tokensSet?: string[] | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link CssUtilityEntry}.
+ */
+export type CssUtilityEntry = typeof CssUtilityEntry.infer;
+/**
+ * Top-level CSS-utility-class manifest envelope. One file per source label
+ * (`@dereekb/dbx-web`, `<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 CssUtilityManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: {
+        slug: string;
+        selector: string;
+        source: string;
+        module: string;
+        file: string;
+        line: number;
+        declarations: {
+            property: string;
+            value: string;
+        }[];
+        role?: "state" | "text" | "size" | "layout" | "misc" | "flex" | "spacing" | "interaction" | "color" | "text-color" | "surface" | "radius" | undefined;
+        intent?: string | undefined;
+        seeAlso?: string[] | undefined;
+        antiUse?: string | undefined;
+        since?: string | undefined;
+        parent?: string | undefined;
+        selectorContext?: string | undefined;
+        component?: string | undefined;
+        scope?: "utility" | "component-class" | undefined;
+        tokensRead?: string[] | undefined;
+        tokensSet?: string[] | undefined;
+    }[];
+}, {}>;
+/**
+ * Static type inferred from {@link CssUtilityManifest}.
+ */
+export type CssUtilityManifest = typeof CssUtilityManifest.infer;

package/src/lib/mcp-scan/manifest/dbx-docs-ui-examples-loader.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Loader for dbx-docs-ui-examples manifests.
+ *
+ * Reads one or more manifest files (bundled `apps/demo` registry plus any
+ * downstream-app manifests discovered via `dbx-mcp.config.json`), validates
+ * them against {@link DbxDocsUiExampleManifest}, and merges them into a
+ * single lookup-ready registry. Mirrors the `ui-components-loader`
+ * structure: keyed by `${entry.module}::${entry.slug}`, indexed by
+ * `entry.category`.
+ */
+import { type DbxDocsUiExampleEntry } from './dbx-docs-ui-examples-schema.js';
+import { type ManifestLoaderWarning, type ManifestReadFile, type ManifestSource } from './manifest-loader-base.js';
+export type DbxDocsUiExamplesManifestSource = ManifestSource;
+export type DbxDocsUiExamplesManifestReadFile = ManifestReadFile;
+export type DbxDocsUiExamplesLoaderWarning = ManifestLoaderWarning;
+export interface LoadDbxDocsUiExamplesManifestsInput {
+    readonly sources: readonly DbxDocsUiExamplesManifestSource[];
+    readonly readFile?: DbxDocsUiExamplesManifestReadFile;
+}
+export interface LoadDbxDocsUiExamplesManifestsResult {
+    readonly entries: ReadonlyMap<string, DbxDocsUiExampleEntry>;
+    readonly categoryIndex: ReadonlyMap<string, readonly string[]>;
+    readonly warnings: readonly DbxDocsUiExamplesLoaderWarning[];
+    readonly loadedSources: readonly string[];
+}
+/**
+ * Loads, validates, and merges the supplied manifest sources into a single
+ * registry suitable for the `dbx_ui_examples` / `dbx_ui_search` MCP tools.
+ *
+ * @param input - Sources to load and an optional `readFile` override for testing.
+ * @returns Merged entry map keyed by `${module}::${slug}`, a category index, any warnings, and the list of successfully loaded source labels.
+ */
+export declare function loadDbxDocsUiExamplesManifests(input: LoadDbxDocsUiExamplesManifestsInput): Promise<LoadDbxDocsUiExamplesManifestsResult>;