@dereekb/dbx-cli 13.11.18 → 13.12.0

package/src/lib/mcp-scan/scan/extract.d.ts

@@ -0,0 +1,82 @@
+/**
+ * AST extraction for the `scan-semantic-types` generator.
+ *
+ * Walks every source file in the supplied ts-morph `Project` looking for
+ * top-level exported type aliases and interfaces tagged with the
+ * `@semanticType` JSDoc marker. Each match is normalised into an
+ * {@link ExtractedEntry} that {@link buildManifest} will assemble into a
+ * `SemanticTypeManifest` entry.
+ *
+ * Topic validation is **not** performed here. The generator emits whatever
+ * the source code declares; the loader (Step 1) handles core/namespaced
+ * topic enforcement at consumption time. That separation keeps this
+ * module purely syntactic.
+ */
+import { type Project } from 'ts-morph';
+import { type SemanticTypeEntry } from '../manifest/semantic-types-schema.js';
+/**
+ * One semantic-type extracted from a source file. Mirrors the
+ * {@link SemanticTypeEntry} shape minus `package` and `module` (which are
+ * derived in {@link buildManifest}). Topic strings are passed through
+ * verbatim — the loader applies vocabulary rules at consumption time.
+ */
+export interface ExtractedEntry {
+    readonly name: string;
+    readonly kind: 'semantic-type' | 'type-alias';
+    readonly definition: string;
+    readonly baseType: SemanticTypeEntry['baseType'];
+    readonly topics: readonly string[];
+    readonly unionValues?: readonly string[];
+    readonly typeParameters?: readonly string[];
+    readonly guards: readonly string[];
+    readonly factories: readonly string[];
+    readonly examples: readonly {
+        readonly caption?: string;
+        readonly code: string;
+    }[];
+    readonly notes?: string;
+    readonly deprecated?: boolean | string;
+    readonly since?: string;
+    readonly filePath: string;
+    readonly line: number;
+}
+/**
+ * Input to {@link extractEntries}. The caller is responsible for adding
+ * source files to `project` (either from disk, in-memory fixtures, or
+ * a tsconfig).
+ */
+export interface ExtractEntriesInput {
+    readonly project: Project;
+}
+/**
+ * Walks the supplied ts-morph project and returns every type/interface entry tagged with the dbx semantic-type marker.
+ *
+ * @param input - The extraction context.
+ * @param input.project - The ts-morph project containing source files to scan.
+ * @returns The extracted entries in source-file order.
+ */
+export declare function extractEntries(input: ExtractEntriesInput): readonly ExtractedEntry[];
+/**
+ * Arktype validator that mirrors {@link ExtractedEntry}. Useful for
+ * tests and for runtime-validating fixture entries crafted by hand.
+ */
+export declare const ExtractedEntrySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    kind: "semantic-type" | "type-alias";
+    definition: string;
+    baseType: "string" | "number" | "boolean" | "object" | "branded" | "union-literal" | "template-literal" | "other";
+    topics: string[];
+    guards: string[];
+    factories: string[];
+    examples: {
+        code: string;
+        caption?: string | undefined;
+    }[];
+    filePath: string;
+    line: number;
+    unionValues?: string[] | undefined;
+    typeParameters?: string[] | undefined;
+    notes?: string | undefined;
+    deprecated?: string | boolean | undefined;
+    since?: string | undefined;
+}, {}>;

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

@@ -0,0 +1,78 @@
+/**
+ * Orchestrator for the `scan-filters` generator.
+ *
+ * Composes a complete {@link FilterManifest} from a project root by
+ *
+ *   1. reading `dbx-mcp.scan.json` against {@link FiltersScanConfig}
+ *   2. reading `package.json` to derive the entry-level `module` field
+ *   3. resolving include/exclude globs against the project root
+ *   4. feeding matched files into a ts-morph project
+ *   5. extracting entries via {@link extractFilterEntries}
+ *   6. assembling the manifest envelope and validating it against
+ *      {@link FilterManifest}
+ *
+ * I/O is fully injectable so tests drive every code path without touching
+ * the real filesystem.
+ */
+import { FilterManifest } from '../manifest/filters-schema.js';
+import { type FilterExtractWarning } from './filters-extract.js';
+import { type ScanGlobber, type ScanReadFile } from '../../scan-helpers/scan-io.js';
+export type BuildFiltersReadFile = ScanReadFile;
+export type BuildFiltersGlobber = ScanGlobber;
+/**
+ * Input to {@link buildFiltersManifest}.
+ */
+export interface BuildFiltersManifestInput {
+    readonly projectRoot: string;
+    readonly generator: string;
+    readonly now?: () => Date;
+    readonly readFile?: BuildFiltersReadFile;
+    readonly globber?: BuildFiltersGlobber;
+}
+/**
+ * Outcome of one generator run. The success payload carries everything the
+ * caller needs to write the manifest to disk or run a freshness diff against
+ * an existing on-disk version.
+ */
+export type BuildFiltersManifestOutcome = {
+    readonly kind: 'success';
+    readonly manifest: FilterManifest;
+    readonly outPath: string;
+    readonly scannedFileCount: number;
+    readonly extractWarnings: readonly FilterExtractWarning[];
+} | {
+    readonly kind: 'no-config';
+    readonly configPath: string;
+} | {
+    readonly kind: 'invalid-scan-config';
+    readonly configPath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'no-package';
+    readonly packagePath: string;
+} | {
+    readonly kind: 'invalid-package';
+    readonly packagePath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'invalid-manifest';
+    readonly error: string;
+};
+/**
+ * Builds a {@link FilterManifest} from the supplied project root. The function
+ * is pure with respect to the injected I/O hooks, so unit tests can drive
+ * every branch without disk access.
+ *
+ * @param input - The project root + injection hooks for testing.
+ * @returns A discriminated outcome describing the result.
+ */
+export declare function buildFiltersManifest(input: BuildFiltersManifestInput): Promise<BuildFiltersManifestOutcome>;
+/**
+ * JSON-stringifies a manifest with stable key ordering and trailing newline so
+ * `--check` mode can byte-compare against a committed file without
+ * false-positive diffs from key reordering.
+ *
+ * @param manifest - The manifest to serialise.
+ * @returns The canonical string form.
+ */
+export declare function serializeFilterManifest(manifest: FilterManifest): string;

package/src/lib/mcp-scan/scan/filters-cli.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `scan-filters` subcommand entry point.
+ *
+ * Thin wrapper around {@link runScanCliBase} that supplies the filters
+ * domain config.
+ */
+import { type BuildFiltersGlobber } from './filters-build-manifest.js';
+import { type RunScanCliBaseInput, type RunScanCliResult, type ScanCliBaseLogger, type ScanCliBaseReadFile, type ScanCliBaseWriteFile } from './scan-cli-base.js';
+/**
+ * Function shape used to read text files during `--check`.
+ */
+export type FiltersScanCliReadFile = ScanCliBaseReadFile;
+/**
+ * Function shape used to write the produced manifest in write mode.
+ */
+export type FiltersScanCliWriteFile = ScanCliBaseWriteFile;
+/**
+ * Console-shaped sink for stdout and stderr lines.
+ */
+export type FiltersScanCliLogger = ScanCliBaseLogger;
+/**
+ * Input to {@link runFiltersScanCli}.
+ */
+export type RunFiltersScanCliInput = RunScanCliBaseInput<BuildFiltersGlobber>;
+/**
+ * Result of one CLI invocation.
+ */
+export type RunFiltersScanCliResult = RunScanCliResult;
+/**
+ * Runs one invocation of `scan-filters`. Never throws on user errors —
+ * every failure path returns a structured exit code so callers can wire
+ * this into `process.exit` without try/catch.
+ *
+ * @param input - Argv plus injectable I/O hooks.
+ * @returns The CLI's exit code (0 on success, 1 on drift / build failure, 2 on usage error)
+ */
+export declare function runFiltersScanCli(input: RunFiltersScanCliInput): Promise<RunFiltersScanCliResult>;

package/src/lib/mcp-scan/scan/filters-extract.d.ts

@@ -0,0 +1,101 @@
+/**
+ * AST extraction for the `scan-filters` generator.
+ *
+ * Walks every source file in the supplied ts-morph `Project` looking for
+ * two entry shapes:
+ *
+ *   - Classes with `@Directive()` decorator and `@dbxFilter` JSDoc marker → directive entries
+ *   - Interfaces with `@dbxFilter` JSDoc marker → pattern entries
+ *
+ * The kind discriminator is inferred from the AST shape — classes produce
+ * `directive` entries, interfaces produce `pattern` entries — so callers
+ * don't need to repeat that fact in JSDoc. JSDoc tags only supply registry
+ * metadata that can't be derived from source (slug, related slugs, skill
+ * refs).
+ */
+import { type Project } from 'ts-morph';
+import type { FilterInputEntry } from '../manifest/filters-schema.js';
+/**
+ * One directive entry extracted from a source file. `module` is supplied by
+ * the build phase. `filePath` and `line` are kept for in-process warnings
+ * and never persisted.
+ */
+export interface ExtractedFilterDirective {
+    readonly kind: 'directive';
+    readonly slug: string;
+    readonly selector: string;
+    readonly className: string;
+    readonly description: string;
+    readonly inputs: readonly FilterInputEntry[];
+    readonly outputs: readonly FilterInputEntry[];
+    readonly relatedSlugs?: readonly string[];
+    readonly skillRefs?: readonly string[];
+    readonly example: string;
+    readonly deprecated?: boolean | string;
+    readonly since?: string;
+    readonly filePath: string;
+    readonly line: number;
+}
+/**
+ * One pattern entry extracted from a source file (interface declaration).
+ */
+export interface ExtractedFilterPattern {
+    readonly kind: 'pattern';
+    readonly slug: string;
+    readonly className: string;
+    readonly description: string;
+    readonly relatedSlugs?: readonly string[];
+    readonly skillRefs?: readonly string[];
+    readonly example: string;
+    readonly deprecated?: boolean | string;
+    readonly since?: string;
+    readonly filePath: string;
+    readonly line: number;
+}
+/**
+ * Discriminated union of every filter entry shape.
+ */
+export type ExtractedFilterEntry = ExtractedFilterDirective | ExtractedFilterPattern;
+/**
+ * Discriminated union of the non-fatal events the extractor emits when an
+ * entry can't be assembled. Build-manifest collates these into a structured
+ * warning array so missing/invalid tag combinations surface during
+ * generation rather than silently dropping entries.
+ */
+export type FilterExtractWarning = {
+    readonly kind: 'missing-required-tag';
+    readonly className: string;
+    readonly tag: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'directive-missing-decorator';
+    readonly className: string;
+    readonly filePath: string;
+    readonly line: number;
+};
+/**
+ * Input to {@link extractFilterEntries}. The caller is responsible for adding
+ * source files to `project`.
+ */
+export interface ExtractFilterEntriesInput {
+    readonly project: Project;
+}
+/**
+ * Result of {@link extractFilterEntries}.
+ */
+export interface ExtractFilterEntriesResult {
+    readonly entries: readonly ExtractedFilterEntry[];
+    readonly warnings: readonly FilterExtractWarning[];
+}
+/**
+ * Walks the supplied project and returns every entry tagged with the
+ * `@dbxFilter` JSDoc marker. Order is stable: source files in the order
+ * ts-morph reports them, declarations within a file in source order
+ * (classes before interfaces is not guaranteed — both share the file's
+ * declaration order through ts-morph's class/interface accessors).
+ *
+ * @param input - The ts-morph project to scan.
+ * @returns The extracted entries plus any non-fatal warnings.
+ */
+export declare function extractFilterEntries(input: ExtractFilterEntriesInput): ExtractFilterEntriesResult;

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

@@ -0,0 +1,56 @@
+/**
+ * Arktype schema for the `filters` section of `dbx-mcp.scan.json`.
+ *
+ * Filters scanning lives next to the existing semantic-types, ui-components,
+ * forge-fields, pipes, and actions sections — all use the same
+ * `dbx-mcp.scan.json` filename so a project that opts into multiple pipelines
+ * keeps a single config file. The CLI subcommand `scan-filters` reads only
+ * the `filters` field; sibling subcommands continue to read their own
+ * top-level fields unchanged.
+ */
+/**
+ * Inner config that drives one filters scan run. `source` becomes the
+ * manifest's `source` label (used for collision detection across loaded
+ * sources); `module` becomes the npm package name attached to every produced
+ * entry. Both default to the project's `package.json#name` when omitted.
+ */
+export declare const FiltersScanSection: import("arktype/internal/variants/object.ts").ObjectType<{
+    include: string[];
+    source?: string | undefined;
+    module?: string | undefined;
+    exclude?: string[] | undefined;
+    out?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link FiltersScanSection}.
+ */
+export type FiltersScanSection = typeof FiltersScanSection.infer;
+/**
+ * Top-level shape used by the filters builder. Only the `filters` key is
+ * consumed; the rest of the document is ignored so a single
+ * `dbx-mcp.scan.json` can house all the scan sections side-by-side.
+ */
+export declare const FiltersScanConfig: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    filters: {
+        include: string[];
+        source?: string | undefined;
+        module?: string | undefined;
+        exclude?: string[] | undefined;
+        out?: string | undefined;
+    };
+}, {}>;
+/**
+ * Static type inferred from {@link FiltersScanConfig}.
+ */
+export type FiltersScanConfig = typeof FiltersScanConfig.infer;
+/**
+ * Default value used when the scan config does not specify `out`.
+ * Lives next to the scan config in the project root.
+ */
+export declare const DEFAULT_FILTERS_SCAN_OUT_PATH = "filters.mcp.generated.json";
+/**
+ * Filename the loader looks for at `${projectRoot}/`. Re-exported here so
+ * the filters CLI does not have to import from a sibling scan config module.
+ */
+export declare const FILTERS_SCAN_CONFIG_FILENAME = "dbx-mcp.scan.json";

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

@@ -0,0 +1,78 @@
+/**
+ * Orchestrator for the `scan-forge-fields` generator.
+ *
+ * Composes a complete {@link ForgeFieldManifest} from a project root by
+ *
+ *   1. reading `dbx-mcp.scan.json` against {@link ForgeFieldsScanConfig}
+ *   2. reading `package.json` to derive the entry-level `module` field
+ *   3. resolving include/exclude globs against the project root
+ *   4. feeding matched files into a ts-morph project
+ *   5. extracting entries via {@link extractForgeFieldEntries}
+ *   6. assembling the manifest envelope and validating it against
+ *      {@link ForgeFieldManifest}
+ *
+ * I/O is fully injectable so tests drive every code path without
+ * touching the real filesystem.
+ */
+import { ForgeFieldManifest } from '../manifest/forge-fields-schema.js';
+import { type ForgeExtractWarning } from './forge-fields-extract.js';
+import { type ScanGlobber, type ScanReadFile } from '../../scan-helpers/scan-io.js';
+export type BuildForgeFieldsReadFile = ScanReadFile;
+export type BuildForgeFieldsGlobber = ScanGlobber;
+/**
+ * Input to {@link buildForgeFieldsManifest}.
+ */
+export interface BuildForgeFieldsManifestInput {
+    readonly projectRoot: string;
+    readonly generator: string;
+    readonly now?: () => Date;
+    readonly readFile?: BuildForgeFieldsReadFile;
+    readonly globber?: BuildForgeFieldsGlobber;
+}
+/**
+ * Outcome of one generator run. The success payload carries everything the
+ * caller needs to write the manifest to disk or run a freshness diff against
+ * an existing on-disk version.
+ */
+export type BuildForgeFieldsManifestOutcome = {
+    readonly kind: 'success';
+    readonly manifest: ForgeFieldManifest;
+    readonly outPath: string;
+    readonly scannedFileCount: number;
+    readonly extractWarnings: readonly ForgeExtractWarning[];
+} | {
+    readonly kind: 'no-config';
+    readonly configPath: string;
+} | {
+    readonly kind: 'invalid-scan-config';
+    readonly configPath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'no-package';
+    readonly packagePath: string;
+} | {
+    readonly kind: 'invalid-package';
+    readonly packagePath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'invalid-manifest';
+    readonly error: string;
+};
+/**
+ * Builds a {@link ForgeFieldManifest} from the supplied project root. The
+ * function is pure with respect to the injected I/O hooks, so unit tests can
+ * drive every branch without disk access.
+ *
+ * @param input - The project root + injection hooks for testing.
+ * @returns A discriminated outcome describing the result.
+ */
+export declare function buildForgeFieldsManifest(input: BuildForgeFieldsManifestInput): Promise<BuildForgeFieldsManifestOutcome>;
+/**
+ * JSON-stringifies a manifest with stable key ordering and trailing newline so
+ * `--check` mode can byte-compare against a committed file without
+ * false-positive diffs from key reordering.
+ *
+ * @param manifest - The manifest to serialise.
+ * @returns The canonical string form.
+ */
+export declare function serializeForgeFieldManifest(manifest: ForgeFieldManifest): string;

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

@@ -0,0 +1,37 @@
+/**
+ * `scan-forge-fields` subcommand entry point.
+ *
+ * Thin wrapper around {@link runScanCliBase} that supplies the forge-fields
+ * domain config.
+ */
+import { type BuildForgeFieldsGlobber } from './forge-fields-build-manifest.js';
+import { type RunScanCliBaseInput, type RunScanCliResult, type ScanCliBaseLogger, type ScanCliBaseReadFile, type ScanCliBaseWriteFile } from './scan-cli-base.js';
+/**
+ * Function shape used to read text files during `--check`.
+ */
+export type ForgeFieldsScanCliReadFile = ScanCliBaseReadFile;
+/**
+ * Function shape used to write the produced manifest in write mode.
+ */
+export type ForgeFieldsScanCliWriteFile = ScanCliBaseWriteFile;
+/**
+ * Console-shaped sink for stdout and stderr lines.
+ */
+export type ForgeFieldsScanCliLogger = ScanCliBaseLogger;
+/**
+ * Input to {@link runForgeFieldsScanCli}.
+ */
+export type RunForgeFieldsScanCliInput = RunScanCliBaseInput<BuildForgeFieldsGlobber>;
+/**
+ * Result of one CLI invocation.
+ */
+export type RunForgeFieldsScanCliResult = RunScanCliResult;
+/**
+ * Runs one invocation of `scan-forge-fields`. Never throws on user errors —
+ * every failure path returns a structured exit code so callers can wire
+ * this into `process.exit` without try/catch.
+ *
+ * @param input - Argv plus injectable I/O hooks.
+ * @returns The CLI's exit code (0 on success, 1 on drift / build failure, 2 on usage error)
+ */
+export declare function runForgeFieldsScanCli(input: RunForgeFieldsScanCliInput): Promise<RunForgeFieldsScanCliResult>;

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

@@ -0,0 +1,165 @@
+/**
+ * AST extraction for the `scan-forge-fields` generator.
+ *
+ * Walks every source file in the supplied ts-morph `Project` looking for
+ * top-level exported declarations (function or `const` arrow function) tagged
+ * with the `@dbxFormField` JSDoc marker. Each match is normalised into an
+ * {@link ExtractedForgeFieldEntry} that {@link buildForgeFieldsManifest}
+ * assembles into a `ForgeFieldManifest` entry.
+ *
+ * Config-interface property auto-extraction lives in this module too — given
+ * a tagged factory, the scanner walks the related config interface
+ * (`<FactoryName>Config` by convention or `@dbxFormConfigInterface` override)
+ * and emits one {@link UiPropertyEntry}-style record per `PropertySignature`.
+ * The extractor is intentionally syntactic — no type checker calls — so it
+ * runs cheaply on in-memory fixtures.
+ */
+import { type Project } from 'ts-morph';
+import { type ForgeFieldEntry, type ForgeFieldPropertyEntry } from '../manifest/forge-fields-schema.js';
+/**
+ * One forge entry extracted from a source file. Mirrors {@link ForgeFieldEntry}
+ * for the persisted fields. `filePath` and `line` are kept for in-process
+ * warnings and never persisted to the manifest.
+ */
+export interface ExtractedForgeFieldEntry {
+    readonly slug: string;
+    readonly factoryName: string;
+    readonly tier: ForgeFieldEntry['tier'];
+    readonly produces: string;
+    readonly arrayOutput: ForgeFieldEntry['arrayOutput'];
+    readonly description: string;
+    readonly example: string;
+    readonly properties: readonly ForgeFieldPropertyEntry[];
+    readonly wrapperPattern?: ForgeFieldEntry['wrapperPattern'];
+    readonly ngFormType?: string;
+    readonly generic?: string;
+    readonly suffix?: ForgeFieldEntry['suffix'];
+    readonly composesFromSlugs?: readonly string[];
+    readonly returns?: string;
+    readonly configInterface?: string;
+    readonly propsInterface?: string;
+    readonly deprecated?: boolean | string;
+    readonly since?: string;
+    readonly filePath: string;
+    readonly line: number;
+}
+/**
+ * Discriminated union of the non-fatal events the extractor emits when an
+ * entry can't be assembled. Build-manifest collates these into a structured
+ * warning array so missing/invalid tag combinations surface during generation
+ * rather than silently dropping entries.
+ */
+export type ForgeExtractWarning = {
+    readonly kind: 'missing-required-tag';
+    readonly factoryName: string;
+    readonly tag: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'unknown-tier';
+    readonly factoryName: string;
+    readonly tier: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'unknown-array-output';
+    readonly factoryName: string;
+    readonly arrayOutput: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'unknown-wrapper-pattern';
+    readonly factoryName: string;
+    readonly wrapperPattern: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'unknown-suffix';
+    readonly factoryName: string;
+    readonly suffix: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'config-interface-not-found';
+    readonly factoryName: string;
+    readonly configInterfaceName: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'derivative-missing-base';
+    readonly factoryName: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'derivative-multiple-bases';
+    readonly factoryName: string;
+    readonly providedCount: number;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'template-missing-slugs';
+    readonly factoryName: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'union-config-not-walked';
+    readonly factoryName: string;
+    readonly configInterfaceName: string;
+    readonly filePath: string;
+    readonly line: number;
+};
+/**
+ * Input to {@link extractForgeFieldEntries}. The caller is responsible for
+ * adding source files to `project` (either from disk, in-memory fixtures, or
+ * a tsconfig).
+ */
+export interface ExtractForgeFieldEntriesInput {
+    readonly project: Project;
+}
+/**
+ * Result of {@link extractForgeFieldEntries}.
+ */
+export interface ExtractForgeFieldEntriesResult {
+    readonly entries: readonly ExtractedForgeFieldEntry[];
+    readonly warnings: readonly ForgeExtractWarning[];
+}
+/**
+ * Walks the supplied project and returns every export tagged with the
+ * `@dbxFormField` JSDoc marker. Order is stable: source files in the order
+ * ts-morph reports them, declarations within a file in source order.
+ *
+ * @param input - The ts-morph project to scan.
+ * @returns The extracted entries plus any non-fatal warnings.
+ */
+export declare function extractForgeFieldEntries(input: ExtractForgeFieldEntriesInput): ExtractForgeFieldEntriesResult;
+/**
+ * Arktype validator that mirrors {@link ExtractedForgeFieldEntry}. Useful for
+ * tests and for runtime-validating fixture entries crafted by hand.
+ */
+export declare const ExtractedForgeFieldEntrySchema: 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;
+    }[];
+    filePath: string;
+    line: number;
+    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;
+}, {}>;