@dereekb/dbx-cli 13.11.18 → 13.12.0

package/src/lib/mcp-scan/registry/form-fields.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Form Field Registry.
+ *
+ * Canonical metadata for @dereekb/dbx-form helpers — field factories
+ * (e.g. `dbxForgeTextField`), composite builders (e.g. `dbxForgeDateRangeRow`),
+ * and layout primitives (e.g. `dbxForgeRow`). The three-tier taxonomy is
+ * documented in the `dbx__ref__dbx-forge-field` skill.
+ *
+ * The PRIMARY search index is `produces` — the output primitive each entry
+ * yields. "I need a Date", "I need a RowField" is the most common AI query
+ * shape, and the registry is small enough (<40 entries) that filtering further
+ * by tier or inspecting config properties is cheap after the primitive match.
+ *
+ * Entries are slug-keyed (`'text'`, `'date-range-row'`, `'row'`). Slugs are
+ * kebab-case and unique across all three tiers.
+ */
+import type { PropertyInfo } from './index.js';
+/**
+ * Builder tier from the form-field skill.
+ *
+ *   - `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 form 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 type FormTier = 'field-factory' | 'field-derivative' | 'composite-builder' | 'template-builder' | 'primitive';
+/**
+ * Which form factory helper a field-factory entry is built with.
+ *
+ *   - `unwrapped`                    `dbxForgeFieldFunction` (field renders its own chrome)
+ *   - `material-form-field-wrapped`  `dbxForgeMaterialFormFieldWrappedFieldFunction` (wrapped in mat-form-field)
+ */
+export type FormFieldWrapperPattern = 'unwrapped' | 'material-form-field-wrapped';
+/**
+ * What a composite builder's naming suffix advertises it returns.
+ *
+ *   - `Row`     `dbxForgeXRow`     → `RowField`
+ *   - `Group`   `dbxForgeXGroup`   → `GroupField`
+ *   - `Fields`  `dbxForgeXFields`  → `FieldDef[]`
+ *   - `Field`   `dbxForgeXField`   → single field (composite array fields keep `Field`)
+ *   - `Wrapper` `dbxForgeXWrapper` → WrapperConfig or composed layout wrapped in a toggle/expand
+ *   - `Layout`  `dbxForgeXLayout`  → GroupField with responsive flex configuration
+ */
+export type FormCompositeSuffix = 'Row' | 'Group' | 'Fields' | 'Field' | 'Wrapper' | 'Layout';
+/**
+ * Documentation of the common output primitives. `produces` on an entry is a
+ * raw `string` (entries can produce arbitrary form-model types like `'string'`,
+ * `'number'`, `'Date'`, `'T'`, `'T[]'`, `'AddressValue'`, ...). These are the
+ * canonical layout outputs that commonly show up in the catalog.
+ */
+export type FormLayoutPrimitive = 'RowField' | 'GroupField' | 'ArrayField' | 'SectionField' | 'FieldDef[]' | 'WrapperConfig';
+/**
+ * Whether an entry's output is an array / collection.
+ *
+ *   - `yes`       entry always produces a collection (field's 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 in
+ *                 single-select vs multi-select mode).
+ */
+export type FormArrayOutput = 'yes' | 'no' | 'optional';
+interface FormEntryBase {
+    /**
+     * Unique registry slug (kebab-case). Used for lookup.
+     */
+    readonly slug: string;
+    /**
+     * Exported factory/builder function name (e.g. `'dbxForgeTextField'`).
+     */
+    readonly factoryName: string;
+    /**
+     * PRIMARY INDEX. The output primitive this entry produces.
+     *
+     * Field factories: the form-model value type (e.g. `'string'`, `'number'`,
+     * `'boolean'`, `'Date'`, `'T'`, `'T[]'`).
+     * Composite builders: the composed return type (e.g. `'RowField'`,
+     * `'GroupField'`, `'FieldDef[]'`, `'ArrayField'`).
+     * Primitives: the layout field / wrapper type returned (`'RowField'`,
+     * `'GroupField'`, `'ArrayField'`, `'WrapperConfig'`, ...).
+     */
+    readonly produces: string;
+    /**
+     * Whether this entry's output is an array. Complements `produces` — lets
+     * callers ask "I need a single X" vs "I need a list of X" without parsing
+     * the type string.
+     */
+    readonly arrayOutput: FormArrayOutput;
+    /**
+     * Prose description of what the entry builds and when to reach for it.
+     */
+    readonly description: string;
+    /**
+     * Full copy-paste-ready usage example.
+     */
+    readonly example: string;
+    /**
+     * Smallest valid invocation.
+     */
+    readonly minimalExample: string;
+    /**
+     * Noteworthy config properties beyond `key` / `label` / `required` (which are assumed).
+     */
+    readonly config: Record<string, PropertyInfo>;
+}
+/**
+ * A field factory: registers an ng-forge field type via
+ * `dbxForgeFieldFunction` or `dbxForgeMaterialFormFieldWrappedFieldFunction`.
+ */
+export interface FormFieldFactoryInfo extends FormEntryBase {
+    readonly tier: 'field-factory';
+    readonly wrapperPattern: FormFieldWrapperPattern;
+    /**
+     * Underlying ng-forge dynamic-forms type string (e.g. `'input'`, `'textarea'`, `'datepicker'`, `'toggle'`, `'slider'`).
+     */
+    readonly ngFormType: string;
+    /**
+     * TypeScript config interface name (e.g. `'DbxForgeTextFieldConfig'`).
+     */
+    readonly configInterface: string;
+    /**
+     * Generic signature if the factory accepts type parameters (e.g. `'<T = unknown>'`).
+     */
+    readonly generic?: string;
+}
+/**
+ * A field-derivative: pre-configured wrapper around a single field-factory.
+ * Returns one field of the same shape as its base factory, with presets baked in.
+ * Does not register a new ng-forge type.
+ */
+export interface FormFieldDerivativeInfo extends FormEntryBase {
+    readonly tier: 'field-derivative';
+    /**
+     * TypeScript config interface name (e.g. `'DbxForgeEmailFieldConfig'`).
+     */
+    readonly configInterface: string;
+    /**
+     * Generic signature if the derivative accepts type parameters.
+     */
+    readonly generic?: string;
+    /**
+     * Slug of the base field-factory (or other registered entry) this derivative wraps.
+     */
+    readonly derivedFromSlug: string;
+}
+/**
+ * A composite builder: composes other form entries into a layout. Does not
+ * register a new ng-forge type.
+ */
+export interface FormCompositeBuilderInfo extends FormEntryBase {
+    readonly tier: 'composite-builder';
+    /**
+     * Which suffix the builder uses — mirrors its return shape.
+     */
+    readonly suffix: FormCompositeSuffix;
+    /**
+     * TypeScript config interface name (descriptive, not `DbxForgeFieldFunctionDef`-based).
+     */
+    readonly configInterface: string;
+    /**
+     * Slugs of other form entries this composite composes from.
+     */
+    readonly composesFromSlugs: readonly string[];
+}
+/**
+ * A template-builder: returns multiple related fields as an array or tuple.
+ * Distinct from composite-builders, which return one composed field/group.
+ */
+export interface FormFieldTemplateInfo extends FormEntryBase {
+    readonly tier: 'template-builder';
+    /**
+     * TypeScript config interface name.
+     */
+    readonly configInterface: string;
+    /**
+     * Slugs of the fields this template returns, in declaration order.
+     */
+    readonly returnsSlugs: readonly string[];
+}
+/**
+ * A layout primitive: core library helper that composites wrap (e.g. `dbxForgeRow`).
+ */
+export interface FormPrimitiveInfo extends FormEntryBase {
+    readonly tier: 'primitive';
+    /**
+     * Layout field type this primitive returns. Accepts any string for flexibility; common values enumerated in {@link FormLayoutPrimitive}.
+     */
+    readonly returns: string;
+    /**
+     * TypeScript config interface name if the primitive accepts a config object.
+     */
+    readonly configInterface?: string;
+}
+/**
+ * Any entry in the form registry.
+ */
+export type FormFieldInfo = FormFieldFactoryInfo | FormFieldDerivativeInfo | FormCompositeBuilderInfo | FormFieldTemplateInfo | FormPrimitiveInfo;
+/**
+ * Presentation order for tiers in listings.
+ */
+export declare const FORM_TIER_ORDER: readonly FormTier[];
+export declare const FORM_FIELDS: readonly FormFieldInfo[];
+export {};

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

@@ -0,0 +1,165 @@
+/**
+ * Registry barrel for dbx-components domains.
+ *
+ * Each domain exports typed metadata constants (plain TypeScript, no state)
+ * plus pure getter functions. Domains are populated incrementally — see the
+ * implementation plan in the feat/dbx-components-mcp branch.
+ *
+ * Planned domains:
+ *   - form-fields       field factories, composite builders, and layout primitives
+ *   - firebase-models    model identity, data interfaces, converters, collection patterns
+ *   - semantic-types     domain-meaningful type aliases tagged with @semanticType (loaded at runtime)
+ *   - model-pointers     lightweight source-file pointers used by the decode tool
+ *   - server-actions     callable / on-call / scheduled / event pipeline patterns
+ *   - component-patterns action, list, and store patterns
+ *   - conventions        TypeScript coding standards and semantic type catalog
+ */
+export { createSemanticTypeRegistry, createSemanticTypeRegistryFromEntries, EMPTY_SEMANTIC_TYPE_REGISTRY } from './semantic-types.js';
+export type { SemanticTypeRegistry } from './semantic-types.js';
+export interface PropertyInfo {
+    readonly name: string;
+    readonly type: string;
+    readonly description: string;
+    readonly required: boolean;
+    readonly default?: unknown;
+}
+export { FORM_FIELDS, FORM_TIER_ORDER } from './form-fields.js';
+export type { FormFieldInfo, FormFieldFactoryInfo, FormFieldDerivativeInfo, FormCompositeBuilderInfo, FormFieldTemplateInfo, FormPrimitiveInfo, FormTier, FormFieldWrapperPattern, FormCompositeSuffix, FormLayoutPrimitive, FormArrayOutput } from './form-fields.js';
+export { ACTION_ROLE_ORDER, createActionRegistry, createActionRegistryFromEntries, EMPTY_ACTION_REGISTRY, toActionEntryInfo } from './actions-runtime.js';
+export type { ActionRegistry, ActionEntryInfo, ActionDirectiveInfo, ActionStoreInfo, ActionStateInfo, ActionEntryRole, ActionInputInfo, ActionOutputInfo, ActionMethodInfo, ActionObservableInfo } from './actions-runtime.js';
+export { createUiComponentRegistry, createUiComponentRegistryFromEntries, EMPTY_UI_COMPONENT_REGISTRY } from './ui-components-runtime.js';
+export type { UiComponentRegistry } from './ui-components-runtime.js';
+export { createCssUtilityRegistry, createCssUtilityRegistryFromEntries, EMPTY_CSS_UTILITY_REGISTRY, parseDeclarations } from './css-utilities-runtime.js';
+export type { CssUtilityRegistry, ScoredCssUtilityMatch, SearchByDeclarationsOptions, FindByIntentOptions } from './css-utilities-runtime.js';
+export { createForgeFieldRegistry, createForgeFieldRegistryFromEntries, EMPTY_FORGE_FIELD_REGISTRY, toFormFieldInfo } from './forge-fields.js';
+export type { ForgeFieldRegistry } from './forge-fields.js';
+export { createPipeRegistry, createPipeRegistryFromEntries, EMPTY_PIPE_REGISTRY, PIPE_CATEGORY_ORDER } from './pipes-runtime.js';
+export type { PipeRegistry, PipeEntryInfo, PipeCategory } from './pipes-runtime.js';
+export { createUtilRegistry, createUtilRegistryFromEntries, EMPTY_UTIL_REGISTRY } from './utils-runtime.js';
+export type { UtilRegistry, UtilEntryInfo } from './utils-runtime.js';
+export { createTokenRegistry, createTokenRegistryFromEntries, EMPTY_TOKEN_REGISTRY } from './tokens-runtime.js';
+export type { TokenRegistry } from './tokens-runtime.js';
+export { createModelSnapshotFieldRegistry, createModelSnapshotFieldRegistryFromEntries, EMPTY_MODEL_SNAPSHOT_FIELD_REGISTRY } from './model-snapshot-fields-runtime.js';
+export type { ModelSnapshotFieldRegistry, ModelSnapshotFieldEntryInfo } from './model-snapshot-fields-runtime.js';
+export { createDbxDocsUiExamplesRegistry, createDbxDocsUiExamplesRegistryFromEntries, EMPTY_DBX_DOCS_UI_EXAMPLES_REGISTRY } from './dbx-docs-ui-examples-runtime.js';
+export type { DbxDocsUiExamplesRegistry } from './dbx-docs-ui-examples-runtime.js';
+export { FILTER_KIND_ORDER, createFilterRegistry, createFilterRegistryFromEntries, EMPTY_FILTER_REGISTRY, toFilterEntryInfo } from './filters-runtime.js';
+export type { FilterRegistry, FilterEntryInfo, FilterEntryInputInfo, FilterKind } from './filters-runtime.js';
+export { createAuthRegistryFromEntries, EMPTY_AUTH_REGISTRY } from './auth-runtime.js';
+export type { AuthRegistry, AuthRoleInfo, AuthClaimInfo, AuthClaimRoleMappingInfo, AuthScopeInfo, AuthScopeEnforcementInfo, AuthAppInfo, AuthEntrySource, CreateAuthRegistryFromEntriesInput } from './auth-runtime.js';
+export { BUILTIN_AUTH_ROLES, BUILTIN_AUTH_CLAIMS, BUILTIN_AUTH_SCOPES, WORKSPACE_AUTH_CLAIMS, WORKSPACE_AUTH_APPS } from './auth-builtin.js';
+import { type FirebaseModel, type FirebaseModelGroup } from './firebase-models.js';
+export { FIREBASE_MODELS, FIREBASE_MODEL_GROUPS } from './firebase-models.js';
+export type { FirebaseModel, FirebaseModelGroup, FirebaseEnum, FirebaseEnumValue, FirebaseField, FirebaseSubObject, FirestoreCollectionKind } from './firebase-models.js';
+export { RESERVED_MODEL_FOLDERS } from './reserved-model-folders.js';
+export type { ReservedModelFolder } from './reserved-model-folders.js';
+export { MODEL_ARCHETYPES, MODEL_ARCHETYPE_SYNC_MODES, MODEL_ARCHETYPE_ADDON_SLUGS, getModelArchetypeBySlug, resolveModelArchetype, getModelArchetypesBySyncMode, getModelArchetypesByCollectionKind, getModelArchetypesByAxisValue } from './archetypes.js';
+export type { ModelArchetypeInfo, ModelArchetypeSlug, ModelArchetypeSyncMode, ModelArchetypeDocIdSource, ModelArchetypeParentRelation, ModelArchetypeUserRelation, ModelArchetypeMutability, ModelArchetypeSingleItemSubPurpose, ModelArchetypeDenormalisedAggregateKeying, ModelArchetypeExpectedAnswers } from './archetypes.js';
+export { getDownstreamCatalog, clearDownstreamCatalogCache } from './downstream-models-runtime.js';
+export type { DownstreamCatalog, DownstreamCatalogError, GetDownstreamCatalogInput } from './downstream-models-runtime.js';
+/**
+ * Returns every registered Firebase model entry.
+ *
+ * @returns The full Firebase model registry list in declaration order.
+ */
+export declare function getFirebaseModels(): readonly FirebaseModel[];
+/**
+ * Looks up a model by its interface name (`'StorageFile'`) or identity const
+ * (`'storageFileIdentity'`). Case-insensitive.
+ *
+ * @param key - The interface name, identity const, or model type to resolve.
+ * @returns The matching model entry, or `undefined` when no candidate matches.
+ */
+export declare function getFirebaseModel(key: string): FirebaseModel | undefined;
+/**
+ * PRIMARY INDEX. Returns the model with the given collection prefix
+ * (`'sf'` → StorageFile). Case-insensitive exact match.
+ *
+ * @param prefix - The short collection prefix used by the model.
+ * @returns The matching model entry, or `undefined` when no model uses the prefix.
+ */
+export declare function getFirebaseModelByPrefix(prefix: string): FirebaseModel | undefined;
+/**
+ * Returns every subcollection model whose parent identity matches
+ * `parentIdentityConst` (e.g. `'notificationBoxIdentity'`).
+ *
+ * @param parentIdentityConst - Identity const of the parent collection to scan beneath.
+ * @returns Each subcollection model nested under the given parent, in registry order.
+ */
+export declare function getFirebaseSubcollectionsOf(parentIdentityConst: string): readonly FirebaseModel[];
+/**
+ * Returns every model whose Firestore document id IS a Firebase Auth user uid
+ * — i.e. the interface (or one of its same-file ancestors) extends
+ * `UserRelatedById`. Useful for enumerating the per-user document set when
+ * reasoning about ownership and permissions.
+ *
+ * @returns Each user-keyed model in registry order.
+ */
+export declare function getFirebaseUserKeyedByIdModels(): readonly FirebaseModel[];
+/**
+ * Returns every model that carries an explicit `uid` field referencing a
+ * Firebase Auth user — i.e. the interface (or one of its same-file
+ * ancestors) extends `UserRelated`. Independent of
+ * {@link getFirebaseUserKeyedByIdModels}: a model can appear in either,
+ * both, or neither list.
+ *
+ * @returns Each user-related model in registry order.
+ */
+export declare function getFirebaseUserRelatedModels(): readonly FirebaseModel[];
+/**
+ * Returns every model whose Firestore document id IS a region key (interface
+ * extends `RegionRelatedById`).
+ *
+ * @returns Each region-keyed model in registry order.
+ */
+export declare function getFirebaseRegionKeyedByIdModels(): readonly FirebaseModel[];
+/**
+ * Returns every model whose Firestore document id IS a district key (interface
+ * extends `DistrictRelatedById`).
+ *
+ * @returns Each district-keyed model in registry order.
+ */
+export declare function getFirebaseDistrictKeyedByIdModels(): readonly FirebaseModel[];
+/**
+ * Returns every model whose Firestore document id IS an external vendor id
+ * (interface extends `ExternalRelatedById`).
+ *
+ * @returns Each external-id-keyed model in registry order.
+ */
+export declare function getFirebaseExternalIdKeyedByIdModels(): readonly FirebaseModel[];
+/**
+ * Returns every model whose Firestore document id IS a temporal bucket code
+ * (year-week / year-month / …).
+ *
+ * @returns Each bucket-keyed model in registry order.
+ */
+export declare function getFirebaseBucketKeyedByIdModels(): readonly FirebaseModel[];
+/**
+ * Returns every model whose `archetype` matches the given slug. Used by
+ * `dbx_model_archetype_search` peer search.
+ *
+ * @param archetype - The archetype slug to filter by.
+ * @returns Each matching model in registry order.
+ */
+export declare function getFirebaseModelsByArchetype(archetype: string): readonly FirebaseModel[];
+/**
+ * Returns the catalog of distinct collection prefixes in the registry.
+ *
+ * @returns The unique set of collection prefixes, sorted alphabetically.
+ */
+export declare function getFirebasePrefixCatalog(): readonly string[];
+/**
+ * Returns every registered Firebase model-group container (e.g.
+ * `NotificationFirestoreCollections`).
+ *
+ * @returns The full model-group registry list in declaration order.
+ */
+export declare function getFirebaseModelGroups(): readonly FirebaseModelGroup[];
+/**
+ * Looks up a model group by its `<Name>FirestoreCollections` class/interface
+ * name (e.g. `'NotificationFirestoreCollections'`). Case-insensitive.
+ *
+ * @param name - The group container name to resolve.
+ * @returns The matching group entry, or `undefined` when no group matches.
+ */
+export declare function getFirebaseModelGroup(name: string): FirebaseModelGroup | undefined;

package/src/lib/mcp-scan/registry/model-snapshot-fields-runtime.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Model-snapshot-fields runtime registry wrapper.
+ *
+ * Wraps the raw {@link LoadModelSnapshotFieldManifestsResult} produced by
+ * the loader with domain-friendly accessors so the lookup/search tools and
+ * the registry resource don't have to walk Maps directly.
+ *
+ * The registry is loaded once at server startup and passed into the tool
+ * factories. Tests can construct a registry from any entry array via
+ * {@link createModelSnapshotFieldRegistryFromEntries} to drive the tools
+ * without touching disk.
+ */
+import type { LoadModelSnapshotFieldManifestsResult } from '../manifest/model-snapshot-fields-loader.js';
+import type { ModelSnapshotFieldEntry } from '../manifest/model-snapshot-fields-schema.js';
+/**
+ * Closed kind vocabulary describing the shape of one snapshot-field entry.
+ */
+export type ModelSnapshotFieldKind = 'factory' | 'const';
+/**
+ * One documented parameter of a factory snapshot field.
+ */
+export interface ModelSnapshotFieldParamInfo {
+    readonly name: string;
+    readonly type: string;
+    readonly description: string;
+    readonly optional: boolean;
+}
+/**
+ * One curated snapshot-field entry surfaced through the
+ * `dbx_model_snapshot_field_*` tools.
+ *
+ * Mirrors {@link ModelSnapshotFieldEntry} but normalises optional manifest
+ * fields to empty arrays / safe defaults so callers (lookup, search,
+ * resources) don't have to defensively branch.
+ */
+export interface ModelSnapshotFieldEntryInfo {
+    readonly slug: string;
+    readonly name: string;
+    readonly kind: ModelSnapshotFieldKind;
+    readonly category: string;
+    readonly module: string;
+    readonly subpath: string;
+    readonly signature: string;
+    readonly description: string;
+    readonly optional: boolean;
+    readonly params: readonly ModelSnapshotFieldParamInfo[];
+    readonly returns: string;
+    readonly tags: readonly string[];
+    readonly example: string;
+    readonly relatedSlugs: readonly string[];
+    readonly skillRefs: readonly string[];
+    readonly deprecated: boolean | string;
+    readonly since: string;
+}
+/**
+ * Domain-friendly read API over a merged model-snapshot-fields manifest set.
+ * All accessors return readonly arrays preserving the order the manifests
+ * declared their entries (manifests are walked in source order).
+ */
+export interface ModelSnapshotFieldRegistry {
+    readonly all: readonly ModelSnapshotFieldEntryInfo[];
+    readonly loadedSources: readonly string[];
+    readonly categories: readonly string[];
+    readonly modules: readonly string[];
+    /**
+     * Returns the entry whose slug matches `slug` exactly. Slugs are unique
+     * across manifests (collisions emit a loader warning and the
+     * second-loaded entry wins).
+     */
+    findBySlug(slug: string): ModelSnapshotFieldEntryInfo | undefined;
+    /**
+     * Returns the entry whose exported identifier matches `name`. Lookup is
+     * case-sensitive — most snapshot-field names are camelCase.
+     */
+    findByName(name: string): ModelSnapshotFieldEntryInfo | undefined;
+    /**
+     * Returns the entry whose exported identifier matches `name`
+     * case-insensitively. Falls back to the case-sensitive path first to
+     * keep camelCase hits prioritised.
+     */
+    findByNameInsensitive(name: string): ModelSnapshotFieldEntryInfo | undefined;
+    /**
+     * Returns every entry whose `category` field matches `category` exactly,
+     * in registry order.
+     */
+    findByCategory(category: string): readonly ModelSnapshotFieldEntryInfo[];
+    /**
+     * Returns every entry whose `module` field matches `module` exactly, in
+     * registry order.
+     */
+    findByModule(module: string): readonly ModelSnapshotFieldEntryInfo[];
+    /**
+     * Returns every entry whose `tags` array includes `tag` (case-sensitive,
+     * tags are stored lowercased), in registry order.
+     */
+    findByTag(tag: string): readonly ModelSnapshotFieldEntryInfo[];
+}
+/**
+ * Builds a {@link ModelSnapshotFieldRegistry} from a loader result.
+ *
+ * @param loaded - The merged registry returned by `loadModelSnapshotFieldManifests`
+ * @returns A domain-friendly read API over the merged entries.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createModelSnapshotFieldRegistry(loaded: LoadModelSnapshotFieldManifestsResult): ModelSnapshotFieldRegistry;
+/**
+ * Builds a {@link ModelSnapshotFieldRegistry} from a raw
+ * {@link ModelSnapshotFieldEntryInfo} array. Used by tests that need to
+ * drive the tools without going through the loader pipeline.
+ *
+ * @param input - The entries plus the source labels to advertise.
+ * @param input.entries - The full entry list.
+ * @param input.loadedSources - Source labels reported via `registry.loadedSources`
+ * @returns A domain-friendly read API over the supplied entries.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createModelSnapshotFieldRegistryFromEntries(input: {
+    readonly entries: readonly ModelSnapshotFieldEntryInfo[];
+    readonly loadedSources: readonly string[];
+}): ModelSnapshotFieldRegistry;
+/**
+ * Empty registry suitable as a default when the server has no
+ * model-snapshot-fields manifest sources to load. Tools wired against this
+ * registry behave like a registry that loaded successfully with zero
+ * entries.
+ */
+export declare const EMPTY_MODEL_SNAPSHOT_FIELD_REGISTRY: ModelSnapshotFieldRegistry;
+/**
+ * Converts a manifest entry into the {@link ModelSnapshotFieldEntryInfo}
+ * shape the lookup/search tools consume. Optional manifest fields fall
+ * back to safe defaults so a partially-populated entry still renders cleanly.
+ *
+ * @param entry - The manifest entry to convert.
+ * @returns The matching ModelSnapshotFieldEntryInfo.
+ */
+export declare function toModelSnapshotFieldEntryInfo(entry: ModelSnapshotFieldEntry): ModelSnapshotFieldEntryInfo;

package/src/lib/mcp-scan/registry/pipes-runtime.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Pipes runtime registry wrapper.
+ *
+ * Wraps the raw {@link LoadPipeManifestsResult} produced by the loader with
+ * domain-friendly accessors so the lookup tool and the registry resource
+ * don't have to walk Maps directly.
+ *
+ * The registry is loaded once at server startup and passed into the tool
+ * factories. Tests can construct a registry from any entry array via
+ * {@link createPipeRegistryFromEntries} to drive the tool without touching
+ * disk.
+ *
+ * Manifest entries (flat, JSON-friendly shape) are converted into the
+ * `PipeEntryInfo` shape historically exposed by `tools/data/pipe-entries.ts`.
+ * The lookup tool keeps consuming that shape so this module is the only seam
+ * that changed when the hand-written entries were deleted.
+ */
+import type { LoadPipeManifestsResult } from '../manifest/pipes-loader.js';
+import type { PipeEntry } from '../manifest/pipes-schema.js';
+/**
+ * Browse-friendly category grouping. Mirrors the on-disk folder layout of
+ * `packages/dbx-core/src/lib/pipe/` and the `category` field on every
+ * manifest entry.
+ */
+export type PipeCategory = 'value' | 'date' | 'async' | 'misc';
+/**
+ * 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 type PipePurity = 'pure' | 'impure';
+/**
+ * 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 interface PipeEntryArgInfo {
+    readonly name: string;
+    readonly type: string;
+    readonly description: string;
+    readonly required: boolean;
+}
+/**
+ * One curated pipe entry surfaced through `dbx_pipe_lookup`. Mirrors the
+ * legacy hand-written shape so the lookup tool didn't have to be rewritten
+ * when the manifest pipeline replaced the inline data table.
+ */
+export interface PipeEntryInfo {
+    readonly slug: string;
+    readonly category: PipeCategory;
+    readonly pipeName: string;
+    readonly className: string;
+    readonly module: string;
+    readonly inputType: string;
+    readonly outputType: string;
+    readonly purity: PipePurity;
+    readonly description: string;
+    readonly args: readonly PipeEntryArgInfo[];
+    readonly relatedSlugs: readonly string[];
+    readonly skillRefs: readonly string[];
+    readonly example: string;
+}
+/**
+ * Domain-friendly read API over a merged pipes manifest set. All accessors
+ * return readonly arrays preserving the order the manifests declared their
+ * entries (manifests are walked in source order).
+ */
+export interface PipeRegistry {
+    readonly all: readonly PipeEntryInfo[];
+    readonly loadedSources: readonly string[];
+    readonly categories: readonly PipeCategory[];
+    /**
+     * Returns the entry whose slug matches `slug` exactly. Slugs are unique
+     * across manifests (collisions emit a loader warning and the second-loaded
+     * entry wins).
+     */
+    findBySlug(slug: string): PipeEntryInfo | undefined;
+    /**
+     * Returns the entry whose Angular pipe name matches `pipeName` (case
+     * sensitive — Angular pipe names are camelCase).
+     */
+    findByPipeName(pipeName: string): PipeEntryInfo | undefined;
+    /**
+     * Returns the entry whose TypeScript class name matches `className`
+     * (case-insensitive).
+     */
+    findByClassName(className: string): PipeEntryInfo | undefined;
+    /**
+     * Returns every entry whose `category` field matches `category` exactly,
+     * in registry order.
+     */
+    findByCategory(category: PipeCategory): readonly PipeEntryInfo[];
+}
+/**
+ * Stable rendering order for category buckets in the catalog view.
+ */
+export declare const PIPE_CATEGORY_ORDER: readonly PipeCategory[];
+/**
+ * Builds a {@link PipeRegistry} from a loader result.
+ *
+ * @param loaded - The merged registry returned by `loadPipeManifests`
+ * @returns A domain-friendly read API over the merged entries.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createPipeRegistry(loaded: LoadPipeManifestsResult): PipeRegistry;
+/**
+ * Builds a {@link PipeRegistry} from a raw {@link PipeEntryInfo} array. Used
+ * by tests that need to drive the tool without going through the loader
+ * pipeline.
+ *
+ * @param input - The entries plus the source labels to advertise.
+ * @param input.entries - The full entry list.
+ * @param input.loadedSources - Source labels reported via `registry.loadedSources`
+ * @returns A domain-friendly read API over the supplied entries.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createPipeRegistryFromEntries(input: {
+    readonly entries: readonly PipeEntryInfo[];
+    readonly loadedSources: readonly string[];
+}): PipeRegistry;
+/**
+ * Empty registry suitable as a default when the server has no pipes manifest
+ * sources to load. Tools wired against this registry behave like a registry
+ * that loaded successfully with zero entries.
+ */
+export declare const EMPTY_PIPE_REGISTRY: PipeRegistry;
+/**
+ * Converts a manifest entry into the {@link PipeEntryInfo} shape the lookup
+ * tool consumes. Optional manifest fields fall back to safe defaults so a
+ * partially-populated entry still renders cleanly.
+ *
+ * @param entry - The manifest entry to convert.
+ * @returns The matching PipeEntryInfo.
+ */
+export declare function toPipeEntryInfo(entry: PipeEntry): PipeEntryInfo;

package/src/lib/mcp-scan/registry/reserved-model-folders.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Reserved model-folder names used by both scanners (skip these folders
+ * during canonical extraction) and the `dbx_validate_model_folder` validator
+ * (emit a warning naming the dedicated validator instead of running the
+ * 5-file structural rules).
+ *
+ * Canonical home so the scan side does not need to reach back into the
+ * dbx-components-mcp `tools/` tree.
+ */
+/**
+ * Descriptor for a reserved model-folder name — one that the validator
+ * recognizes but deliberately skips because the folder either follows a
+ * distinct layout (e.g. `system/`) or is an extension of an upstream
+ * group imported from `@dereekb/firebase` (e.g. `notification/`,
+ * `storagefile/`). The emitted warning points the caller at the
+ * dedicated validator for that group.
+ */
+export interface ReservedModelFolder {
+    readonly name: string;
+    readonly reason: string;
+    readonly recommendedTool: string;
+}
+/**
+ * Folder names reserved from the canonical 5-file check. The validator
+ * emits a `RESERVED_MODEL_FOLDER` warning naming the
+ * {@link ReservedModelFolder.recommendedTool} instead of running
+ * structural rules.
+ */
+export declare const RESERVED_MODEL_FOLDERS: readonly ReservedModelFolder[];