@dereekb/dbx-cli 13.11.18 → 13.12.1

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

@@ -0,0 +1,133 @@
+/**
+ * Arktype schemas for the dbx-docs-ui-examples manifest format.
+ *
+ * Each manifest catalogs runnable UI example components scraped from a
+ * downstream app's docs module — components that wrap a self-contained
+ * `<dbx-docs-ui-example>` template tagged with `@dbxDocsUiExample` JSDoc
+ * markers. The merged registry feeds the `dbx_ui_examples` and
+ * `dbx_ui_search` MCP tools.
+ *
+ * Entries reuse the closed UI category vocabulary so cross-cluster joins
+ * (e.g. surface examples whose `relatedSlugs` overlap a UI component's slug)
+ * stay schema-aligned.
+ */
+/**
+ * Kinds the resolver may emit for an entry in `uses[]`. Wider than
+ * `UiComponentKindValue` because supporting sources can be plain
+ * interfaces, type aliases, functions, or constants in addition to Angular
+ * constructs.
+ */
+export declare const DBX_DOCS_UI_EXAMPLE_USE_KINDS: readonly ["component", "directive", "pipe", "service", "interface", "typeAlias", "function", "const", "class"];
+/**
+ * Static type inferred from {@link DBX_DOCS_UI_EXAMPLE_USE_KINDS}.
+ */
+export type DbxDocsUiExampleUseKind = (typeof DBX_DOCS_UI_EXAMPLE_USE_KINDS)[number];
+/**
+ * One supporting source captured by a `@dbxDocsUiExampleUses` tag. The
+ * scanner resolves the named identifier through the example component
+ * file's import declarations, then captures the declaration source.
+ *
+ * For inline-template components the template body is already inlined in
+ * `classSource`, so it is not duplicated as a separate field. Source
+ * file paths are intentionally not persisted because downstream consumers
+ * never have access to the originating app's source tree.
+ */
+export declare const DbxDocsUiExampleUseEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    kind: "function" | "pipe" | "component" | "directive" | "service" | "class" | "const" | "interface" | "typeAlias";
+    className: string;
+    classSource: string;
+    role?: string | undefined;
+    selector?: string | undefined;
+    pipeName?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link DbxDocsUiExampleUseEntry}.
+ */
+export type DbxDocsUiExampleUseEntry = typeof DbxDocsUiExampleUseEntry.infer;
+/**
+ * One example entry inside a manifest. Each entry describes a single
+ * tagged Angular component whose template is anchored on a
+ * `<dbx-docs-ui-example>` wrapper.
+ *
+ * Required fields are the minimum needed for `dbx_ui_examples` to render
+ * a useful answer. `uses` is required (may be empty) so consumers can
+ * count on its shape. The wrapper component's source is intentionally
+ * not persisted: it imports `<dbx-docs-ui-example*>` scaffolding that
+ * only exists inside the originating docs app, so copy-pasting it into
+ * a downstream consumer would resolve to non-existent imports. The
+ * canonical invocation is captured in `snippet`.
+ */
+export declare const DbxDocsUiExampleEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    slug: string;
+    category: "action" | "list" | "screen" | "text" | "layout" | "button" | "card" | "feedback" | "overlay" | "navigation" | "router" | "misc";
+    summary: string;
+    header: string;
+    className: string;
+    selector: string;
+    module: string;
+    appRef: string;
+    info: string;
+    snippet: string;
+    uses: {
+        kind: "function" | "pipe" | "component" | "directive" | "service" | "class" | "const" | "interface" | "typeAlias";
+        className: string;
+        classSource: string;
+        role?: string | undefined;
+        selector?: string | undefined;
+        pipeName?: string | undefined;
+    }[];
+    hint?: string | undefined;
+    relatedSlugs?: string[] | undefined;
+    skillRefs?: string[] | undefined;
+    imports?: string | undefined;
+    notes?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link DbxDocsUiExampleEntry}.
+ */
+export type DbxDocsUiExampleEntry = typeof DbxDocsUiExampleEntry.infer;
+/**
+ * Top-level manifest envelope. One file per source. The `source` field is
+ * the workspace-unique label used to detect collisions; `module` carries
+ * the project label (e.g. `apps/demo`) 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 DbxDocsUiExampleManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: {
+        slug: string;
+        category: "action" | "list" | "screen" | "text" | "layout" | "button" | "card" | "feedback" | "overlay" | "navigation" | "router" | "misc";
+        summary: string;
+        header: string;
+        className: string;
+        selector: string;
+        module: string;
+        appRef: string;
+        info: string;
+        snippet: string;
+        uses: {
+            kind: "function" | "pipe" | "component" | "directive" | "service" | "class" | "const" | "interface" | "typeAlias";
+            className: string;
+            classSource: string;
+            role?: string | undefined;
+            selector?: string | undefined;
+            pipeName?: string | undefined;
+        }[];
+        hint?: string | undefined;
+        relatedSlugs?: string[] | undefined;
+        skillRefs?: string[] | undefined;
+        imports?: string | undefined;
+        notes?: string | undefined;
+    }[];
+}, {}>;
+/**
+ * Static type inferred from {@link DbxDocsUiExampleManifest}.
+ */
+export type DbxDocsUiExampleManifest = typeof DbxDocsUiExampleManifest.infer;

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

@@ -0,0 +1,61 @@
+/**
+ * Loader for filters 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 FilterManifest}, and merges them into a single
+ * lookup-ready registry.
+ *
+ * Failure handling mirrors the semantic-types and pipes loaders: bundled
+ * sources are strict by default, external sources are not. If no source
+ * loads successfully the loader throws — silent empty registries are the
+ * worst failure mode.
+ */
+import { type FilterEntry } from './filters-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 (the
+ * caller resolves any repo-relative `dbx-mcp.config.json` entries against
+ * the config file's directory before invoking the loader).
+ */
+export type FilterManifestSource = ManifestSource;
+/**
+ * Function shape used by the loader to read manifest contents. Defaults to
+ * `node:fs/promises.readFile(path, 'utf-8')` when not supplied.
+ */
+export type FilterManifestReadFile = ManifestReadFile;
+/**
+ * Discriminated union of all non-fatal events the loader emits. Strict
+ * sources convert these into thrown errors; non-strict sources collect
+ * them into the result's `warnings` array.
+ */
+export type FilterLoaderWarning = ManifestLoaderWarning;
+/**
+ * Input to {@link loadFilterManifests}.
+ */
+export interface LoadFilterManifestsInput {
+    readonly sources: readonly FilterManifestSource[];
+    readonly readFile?: FilterManifestReadFile;
+}
+/**
+ * Result of {@link loadFilterManifests}. `entries` is the merged lookup map
+ * keyed by `${module}::${slug}`; `kindIndex` is the inverted index from
+ * kind value to entry keys (sorted alphabetically for deterministic output).
+ * `warnings` is sorted deterministically so test assertions are stable
+ * across runs.
+ */
+export interface LoadFilterManifestsResult {
+    readonly entries: ReadonlyMap<string, FilterEntry>;
+    readonly kindIndex: ReadonlyMap<string, readonly string[]>;
+    readonly warnings: readonly FilterLoaderWarning[];
+    readonly loadedSources: readonly string[];
+}
+/**
+ * Loads, validates, and merges the supplied manifest sources into a single
+ * registry suitable for the `dbx_filter_lookup` MCP tool.
+ *
+ * @param input - Manifest sources plus an optional injected `readFile`
+ * @returns Merged entries, kind 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 loadFilterManifests(input: LoadFilterManifestsInput): Promise<LoadFilterManifestsResult>;

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

@@ -0,0 +1,190 @@
+/**
+ * Arktype schemas for the filters manifest format.
+ *
+ * Manifests are JSON files that catalog the dbx-components filter surface —
+ * the `[dbxFilter*]` directive family plus shape-only patterns such as
+ * `ClickableFilterPreset`. 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_filter_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.
+ */
+/**
+ * Discriminator between Angular directives (`[dbxFilter*]`) and shape-only
+ * patterns (`ClickableFilterPreset`). Mirrors the existing `FilterEntryKind`
+ * exposed by the legacy hand-authored module.
+ */
+export declare const FILTER_KINDS: readonly ["directive", "pattern"];
+/**
+ * Static type for the closed kind vocabulary.
+ */
+export type FilterKindValue = (typeof FILTER_KINDS)[number];
+/**
+ * One documented input on a filter directive — alias, type, description.
+ * Filter directives are read-mostly: most have zero inputs, a few accept a
+ * single map key; required flags are not tracked because every input is
+ * optional in the rendered docs.
+ */
+export declare const FilterInputEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    type: string;
+    description: string;
+}, {}>;
+/**
+ * Static type inferred from {@link FilterInputEntry}.
+ */
+export type FilterInputEntry = typeof FilterInputEntry.infer;
+/**
+ * Directive entry. Captures the `@Directive({selector})` plus any inputs and
+ * outputs declared on the class. Required fields are the minimum needed for
+ * `dbx_filter_lookup` to render a useful answer.
+ */
+export declare const FilterDirectiveEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    kind: "directive";
+    slug: string;
+    selector: string;
+    className: string;
+    module: string;
+    description: string;
+    inputs: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    example: string;
+    relatedSlugs?: string[] | undefined;
+    skillRefs?: string[] | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link FilterDirectiveEntry}.
+ */
+export type FilterDirectiveEntry = typeof FilterDirectiveEntry.infer;
+/**
+ * Pattern entry. Shape-only entries (interfaces, type aliases) without an
+ * Angular `@Directive` decorator. The `selector` field is omitted — pattern
+ * entries are referenced in TypeScript code, not the template DOM.
+ */
+export declare const FilterPatternEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    kind: "pattern";
+    slug: string;
+    className: string;
+    module: string;
+    description: string;
+    example: string;
+    relatedSlugs?: string[] | undefined;
+    skillRefs?: string[] | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link FilterPatternEntry}.
+ */
+export type FilterPatternEntry = typeof FilterPatternEntry.infer;
+/**
+ * Discriminated union of every filter entry shape. Matches the legacy
+ * `FilterEntryInfo` shape's `kind: 'directive' | 'pattern'` discriminator
+ * so the runtime registry can preserve consumer-visible field names.
+ */
+export declare const FilterEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    kind: "directive";
+    slug: string;
+    selector: string;
+    className: string;
+    module: string;
+    description: string;
+    inputs: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    example: string;
+    relatedSlugs?: string[] | undefined;
+    skillRefs?: string[] | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+} | {
+    kind: "pattern";
+    slug: string;
+    className: string;
+    module: string;
+    description: string;
+    example: string;
+    relatedSlugs?: string[] | undefined;
+    skillRefs?: string[] | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link FilterEntry}.
+ */
+export type FilterEntry = typeof FilterEntry.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 FilterManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: ({
+        kind: "directive";
+        slug: string;
+        selector: string;
+        className: string;
+        module: string;
+        description: string;
+        inputs: {
+            name: string;
+            type: string;
+            description: string;
+        }[];
+        outputs: {
+            name: string;
+            type: string;
+            description: string;
+        }[];
+        example: string;
+        relatedSlugs?: string[] | undefined;
+        skillRefs?: string[] | undefined;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    } | {
+        kind: "pattern";
+        slug: string;
+        className: string;
+        module: string;
+        description: string;
+        example: string;
+        relatedSlugs?: string[] | undefined;
+        skillRefs?: string[] | undefined;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    })[];
+}, {}>;
+/**
+ * Static type inferred from {@link FilterManifest}.
+ */
+export type FilterManifest = typeof FilterManifest.infer;

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

@@ -0,0 +1,53 @@
+/**
+ * Loader for forge-fields 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 ForgeFieldManifest}, and merges them into a single
+ * lookup-ready registry.
+ *
+ * Failure handling mirrors the semantic-types and ui-components loaders:
+ * bundled sources are strict by default, external sources are not. If no
+ * source loads successfully the loader throws.
+ */
+import { type ForgeFieldEntry } from './forge-fields-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 ForgeFieldManifestSource = ManifestSource;
+/**
+ * Function shape used by the loader to read manifest contents.
+ */
+export type ForgeFieldManifestReadFile = ManifestReadFile;
+/**
+ * Discriminated union of all non-fatal events the loader emits.
+ */
+export type ForgeFieldLoaderWarning = ManifestLoaderWarning;
+/**
+ * Input to {@link loadForgeFieldManifests}.
+ */
+export interface LoadForgeFieldManifestsInput {
+    readonly sources: readonly ForgeFieldManifestSource[];
+    readonly readFile?: ForgeFieldManifestReadFile;
+}
+/**
+ * Result of {@link loadForgeFieldManifests}. `entries` is the merged lookup
+ * map keyed by `${module}::${slug}`; `tierIndex` is the inverted index from
+ * tier value to entry keys (sorted alphabetically for deterministic output).
+ */
+export interface LoadForgeFieldManifestsResult {
+    readonly entries: ReadonlyMap<string, ForgeFieldEntry>;
+    readonly tierIndex: ReadonlyMap<string, readonly string[]>;
+    readonly warnings: readonly ForgeFieldLoaderWarning[];
+    readonly loadedSources: readonly string[];
+}
+/**
+ * Loads, validates, and merges the supplied manifest sources into a single
+ * registry suitable for the `lookup-form` / `search-form` MCP tools.
+ *
+ * @param input - Manifest sources plus an optional injected `readFile`
+ * @returns Merged entries, tier 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 loadForgeFieldManifests(input: LoadForgeFieldManifestsInput): Promise<LoadForgeFieldManifestsResult>;

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

@@ -0,0 +1,170 @@
+/**
+ * Arktype schemas for the forge-fields manifest format.
+ *
+ * Manifests are JSON files that catalog @dereekb/dbx-form factory exports —
+ * field factories (`dbxForgeTextField`), composite builders (`dbxForgeDateRangeRow`),
+ * and layout primitives (`dbxForgeRow`). 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
+ * `lookup-form` and `search-form` MCP tools.
+ *
+ * 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.
+ */
+/**
+ * Five-tier classification of forge factories — see the
+ * `dbx__ref__dbx-forge-field` skill for the canonical definitions.
+ *
+ *   - `field-factory`     dbxForgeFieldFunction / dbxForgeMaterialFormFieldWrappedFieldFunction — registers a type
+ *   - `field-derivative`  pre-configured wrapper around a single field-factory; returns one field of the same shape with presets baked in (does NOT register a type)
+ *   - `composite-builder` plain function composing other forge entries into ONE field/group — does NOT register a type
+ *   - `template-builder`  returns multiple related fields as an array/tuple — distinct from composite-builders, which compose into a single container
+ *   - `primitive`         core layout helper (row, group, array, section)
+ */
+export declare const FORGE_FIELD_TIERS: readonly ["field-factory", "field-derivative", "composite-builder", "template-builder", "primitive"];
+/**
+ * Static type for the closed tier vocabulary.
+ */
+export type ForgeFieldTierValue = (typeof FORGE_FIELD_TIERS)[number];
+/**
+ * Factory-only flag describing how a field-factory entry is built.
+ *
+ *   - `unwrapped`                    `dbxForgeFieldFunction` — the field renders its own chrome
+ *   - `material-form-field-wrapped`  `dbxForgeMaterialFormFieldWrappedFieldFunction` — wrapped in mat-form-field
+ */
+export declare const FORGE_FIELD_WRAPPER_PATTERNS: readonly ["unwrapped", "material-form-field-wrapped"];
+/**
+ * Static type for the closed wrapper-pattern vocabulary.
+ */
+export type ForgeFieldWrapperPatternValue = (typeof FORGE_FIELD_WRAPPER_PATTERNS)[number];
+/**
+ * Composite-builder-only suffix advertising the return shape of the builder.
+ *
+ *   - `Row`     `dbxForgeXRow`     → `RowField`
+ *   - `Group`   `dbxForgeXGroup`   → `GroupField`
+ *   - `Fields`  `dbxForgeXFields`  → `FieldDef[]`
+ *   - `Field`   `dbxForgeXField`   → single field (composite array fields keep `Field`)
+ *   - `Wrapper` `dbxForgeXWrapper` → WrapperConfig or composed layout
+ *   - `Layout`  `dbxForgeXLayout`  → GroupField with responsive flex configuration
+ */
+export declare const FORGE_FIELD_COMPOSITE_SUFFIXES: readonly ["Row", "Group", "Fields", "Field", "Wrapper", "Layout"];
+/**
+ * Static type for the closed composite-suffix vocabulary.
+ */
+export type ForgeFieldCompositeSuffixValue = (typeof FORGE_FIELD_COMPOSITE_SUFFIXES)[number];
+/**
+ * Whether an entry's output is an array, single value, or configurable.
+ *
+ *   - `yes`       entry always produces a collection (form value is an array, OR
+ *                 composite returns `FieldDef[]`).
+ *   - `no`        entry produces a single value / single field.
+ *   - `optional`  entry can be configured either way (e.g. searchable-chip).
+ */
+export declare const FORGE_FIELD_ARRAY_OUTPUTS: readonly ["yes", "no", "optional"];
+/**
+ * Static type for the closed array-output vocabulary.
+ */
+export type ForgeFieldArrayOutputValue = (typeof FORGE_FIELD_ARRAY_OUTPUTS)[number];
+/**
+ * One property auto-extracted from the entry's config interface. Mirrors the
+ * shape of {@link PropertyInfo} from the registry barrel — captured here for
+ * the manifest contract, with `default` stored as a string so JSON
+ * serialization is lossless.
+ */
+export declare const ForgeFieldPropertyEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    type: string;
+    description: string;
+    required: boolean;
+    default?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ForgeFieldPropertyEntry}.
+ */
+export type ForgeFieldPropertyEntry = typeof ForgeFieldPropertyEntry.infer;
+/**
+ * One forge-field entry inside a manifest. Each entry describes a single
+ * exported factory — its slug, tier classification, output type, and the
+ * config properties callers wire to.
+ *
+ * Tier-specific fields are optional at the schema level; the runtime
+ * registry asserts the right combination per tier. Required fields are the
+ * minimum needed for `lookup-form` to render a useful answer; every other
+ * field is optional so the auto-generator can populate them progressively.
+ */
+export declare const ForgeFieldEntry: import("arktype/internal/variants/object.ts").ObjectType<{
+    slug: string;
+    factoryName: string;
+    tier: "field-factory" | "field-derivative" | "composite-builder" | "template-builder" | "primitive";
+    produces: string;
+    arrayOutput: "yes" | "no" | "optional";
+    description: string;
+    example: string;
+    properties: {
+        name: string;
+        type: string;
+        description: string;
+        required: boolean;
+        default?: string | undefined;
+    }[];
+    wrapperPattern?: "unwrapped" | "material-form-field-wrapped" | undefined;
+    ngFormType?: string | undefined;
+    generic?: string | undefined;
+    suffix?: "Row" | "Group" | "Fields" | "Field" | "Wrapper" | "Layout" | undefined;
+    composesFromSlugs?: string[] | undefined;
+    returns?: string | undefined;
+    configInterface?: string | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link ForgeFieldEntry}.
+ */
+export type ForgeFieldEntry = typeof ForgeFieldEntry.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 ForgeFieldManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    module: string;
+    generatedAt: string;
+    generator: string;
+    entries: {
+        slug: string;
+        factoryName: string;
+        tier: "field-factory" | "field-derivative" | "composite-builder" | "template-builder" | "primitive";
+        produces: string;
+        arrayOutput: "yes" | "no" | "optional";
+        description: string;
+        example: string;
+        properties: {
+            name: string;
+            type: string;
+            description: string;
+            required: boolean;
+            default?: string | undefined;
+        }[];
+        wrapperPattern?: "unwrapped" | "material-form-field-wrapped" | undefined;
+        ngFormType?: string | undefined;
+        generic?: string | undefined;
+        suffix?: "Row" | "Group" | "Fields" | "Field" | "Wrapper" | "Layout" | undefined;
+        composesFromSlugs?: string[] | undefined;
+        returns?: string | undefined;
+        configInterface?: string | undefined;
+        deprecated?: string | boolean | undefined;
+        since?: string | undefined;
+    }[];
+}, {}>;
+/**
+ * Static type inferred from {@link ForgeFieldManifest}.
+ */
+export type ForgeFieldManifest = typeof ForgeFieldManifest.infer;

package/src/lib/mcp-scan/manifest/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Manifest barrel for the dbx-components MCP scan infrastructure.
+ *
+ * Exposes the loader functions and arktype schemas used by the runtime
+ * MCP tools and by build-time CLIs that consume the JSON manifests
+ * produced under `dbx-components-mcp/generated/`.
+ */
+export * from './core-topics.js';
+export * from './semantic-types-schema.js';
+export * from './loader.js';
+export * from './load-registry.js';
+export * from './load-actions-registry.js';
+export * from './load-auth-registry.js';
+export * from './load-css-utilities-registry.js';
+export * from './load-dbx-docs-ui-examples-registry.js';
+export * from './load-filters-registry.js';
+export * from './load-forge-fields-registry.js';
+export * from './load-model-firebase-index-registry.js';
+export * from './load-model-snapshot-fields-registry.js';
+export * from './load-pipes-registry.js';
+export * from './load-tokens-registry.js';
+export * from './load-ui-components-registry.js';
+export * from './load-utils-registry.js';
+export * from './actions-schema.js';
+export * from './css-utilities-schema.js';
+export * from './dbx-docs-ui-examples-schema.js';
+export * from './filters-schema.js';
+export * from './forge-fields-schema.js';
+export * from './model-snapshot-fields-schema.js';
+export * from './pipes-schema.js';
+export * from './tokens-schema.js';
+export * from './tokens-loader.js';
+export * from './ui-components-schema.js';
+export * from './ui-components-loader.js';
+export * from './utils-schema.js';
+export * from './actions-loader.js';
+export * from './model-firebase-index-loader.js';
+export * from './model-snapshot-fields-loader.js';
+export * from './pipes-loader.js';
+export * from './forge-fields-loader.js';
+export * from './dbx-docs-ui-examples-loader.js';
+export * from './filters-loader.js';
+export * from './utils-loader.js';