speckeeper 0.4.2 → 0.6.0

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { z, ZodType } from 'zod';
+import { z } from 'zod';
+import { S as SpecEntry } from './model-2gVdKS3_.js';
+export { C as CheckResult, a as CoverageChecker, b as CoverageResult, E as Exporter, c as ExternalChecker, L as LintResult, d as LintRule, M as MergedDesign, e as Model, f as ModelLevel, R as RELATION_CONSTRAINTS, g as RELATION_TYPES, h as Relation, i as RelationSchema, j as RelationValidationError, k as RelationsFieldSchema, l as RenderContext, m as Renderer, n as SpecModule, o as buildRegistryFromConfig, p as defineSpecs, q as detectCycles, r as findModelTypeFromConfig, s as getLevelIndex, t as getSpecsFromConfig, u as inferModelIdFromSpecId, v as mergeSpecs, w as validateRelationLevel } from './model-2gVdKS3_.js';
 
 declare const PhaseSchema: z.ZodEnum<["REQ", "HLD", "LLD", "IMPL", "OPS", "CI"]>;
 type Phase = z.infer<typeof PhaseSchema>;
@@ -200,7 +202,7 @@ interface LintIssue {
 /**
  * Check Result
  */
-interface CheckResult$1 {
+interface CheckResult {
     /** Whether successful */
     success: boolean;
     /** List of error messages */
@@ -260,7 +262,7 @@ interface JsonSchemaExporter {
 /**
  * Lint Rule
  */
-interface LintRule$1<T> {
+interface LintRule<T> {
     /** Rule ID */
     id: string;
     /** Rule description */
@@ -273,11 +275,11 @@ interface LintRule$1<T> {
 /**
  * External SSOT Checker
  */
-interface ExternalChecker$1<T> {
+interface ExternalChecker<T> {
     /** External SSOT type to check */
     targetType: 'openapi' | 'ddl' | 'iac' | 'custom';
     /** Execute check */
-    check: (model: T, externalSource: unknown, context: CheckContext) => CheckResult$1;
+    check: (model: T, externalSource: unknown, context: CheckContext) => CheckResult;
     /** Get external SSOT file path (from model) */
     getSourcePath?: (model: T) => string | undefined;
 }
@@ -319,9 +321,9 @@ interface ModelDefinition<T extends z.ZodTypeAny = z.ZodTypeAny> {
         jsonSchema?: JsonSchemaExporter;
     };
     /** Lint rules */
-    lintRules?: LintRule$1<z.infer<T>>[];
+    lintRules?: LintRule<z.infer<T>>[];
     /** External SSOT checker */
-    externalChecker?: ExternalChecker$1<z.infer<T>>;
+    externalChecker?: ExternalChecker<z.infer<T>>;
     /** Reference definitions (for traceability) */
     references?: ReferenceDefinition[];
     /** DSL function name (the Xxx part of defineXxx) */
@@ -475,451 +477,6 @@ declare const CheckResultSchema: z.ZodObject<{
     }[];
 }>;
 
-/**
- * Definition and validation of model relations
- */
-
-/**
- * Model abstraction level
- *
- * - L0: Business + Domain Analysis (Why / Problem space)
- *       Desired outcomes/value, business flows, actors, terminology, business rules
- * - L1: Requirements (What)
- *       Functional/non-functional requirements, constraints, acceptance criteria
- * - L2: Design (How / Direction)
- *       Architecture, component breakdown, domain model, key sequences
- * - L3: Detailed Design/Implementation (How to build / Concrete artifacts)
- *       Screen/API/DB definitions, external SSOT references
- */
-type ModelLevel = 'L0' | 'L1' | 'L2' | 'L3';
-/**
- * Get numeric index of level
- */
-declare function getLevelIndex(level: ModelLevel): number;
-/**
- * Relation types
- */
-declare const RELATION_TYPES: readonly ["dependsOn", "uses", "includes", "implements", "refines", "verifies", "satisfies", "traces", "relatedTo"];
-type RelationType = typeof RELATION_TYPES[number];
-/**
- * Relation schema
- */
-declare const RelationSchema: z.ZodObject<{
-    /** Relation type */
-    type: z.ZodEnum<["dependsOn", "uses", "includes", "implements", "refines", "verifies", "satisfies", "traces", "relatedTo"]>;
-    /** Target ID */
-    target: z.ZodString;
-    /** Description (optional) */
-    description: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
-    target: string;
-    description?: string | undefined;
-}, {
-    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
-    target: string;
-    description?: string | undefined;
-}>;
-/**
- * Relation field to add to model schemas
- * Usage: schema.extend({ relations: RelationsFieldSchema })
- */
-declare const RelationsFieldSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
-    /** Relation type */
-    type: z.ZodEnum<["dependsOn", "uses", "includes", "implements", "refines", "verifies", "satisfies", "traces", "relatedTo"]>;
-    /** Target ID */
-    target: z.ZodString;
-    /** Description (optional) */
-    description: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
-    target: string;
-    description?: string | undefined;
-}, {
-    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
-    target: string;
-    description?: string | undefined;
-}>, "many">>;
-type Relation = z.infer<typeof RelationSchema>;
-/**
- * Definition of relation constraints
- */
-interface RelationConstraint {
-    /** Allowed target levels (all levels allowed if not specified) */
-    allowedTargetLevels?: ModelLevel[];
-    /** Level constraint rule */
-    levelRule: 'source>target' | 'source>=target' | 'same' | 'any';
-    /** Direction of impact propagation */
-    propagation: 'forward' | 'backward' | 'both';
-}
-/**
- * Constraint definitions per relation type
- *
- * Level hierarchy:
- *   L0 (Business) → L1 (Requirements) → L2 (Design) → L3 (Implementation)
- *   Abstract ───────────────────────────→ Concrete
- */
-declare const RELATION_CONSTRAINTS: Record<RelationType, RelationConstraint>;
-/**
- * Relation validation error
- */
-interface RelationValidationError {
-    type: 'level_violation' | 'target_level_violation' | 'self_reference' | 'cycle_detected';
-    message: string;
-    relation: Relation;
-    sourceId: string;
-}
-/**
- * Validate level constraint for single relation
- *
- * @param sourceLevel - Source model level (set in _models/)
- * @param sourceSpecId - Source spec ID
- * @param relation - Relation
- * @param targetLevel - Target model level
- */
-declare function validateRelationLevel(sourceLevel: ModelLevel | undefined, sourceSpecId: string, relation: Relation, targetLevel: ModelLevel | undefined): RelationValidationError | null;
-/**
- * Detect circular references
- */
-declare function detectCycles(relations: Array<{
-    sourceId: string;
-    targetId: string;
-    type: RelationType;
-}>): RelationValidationError[];
-/**
- * Infer model ID from spec ID (prefix-based)
- */
-declare function inferModelIdFromSpecId(specId: string): string | undefined;
-
-/**
- * Model base class
- *
- * All model definitions inherit from this class
- */
-
-/**
- * Lint rule definition
- */
-interface LintRule<T> {
-    id: string;
-    severity: 'error' | 'warning' | 'info';
-    message: string;
-    check: (spec: T) => boolean;
-}
-/**
- * Lint result
- */
-interface LintResult {
-    ruleId: string;
-    severity: 'error' | 'warning' | 'info';
-    message: string;
-    specId?: string;
-}
-/**
- * Exporter definition
- */
-interface Exporter<T> {
-    format: 'markdown' | 'json' | 'mermaid';
-    single?: (spec: T) => string;
-    index?: (specs: T[]) => string;
-    outputDir?: string;
-    filename?: (spec: T) => string;
-}
-/**
- * External checker definition
- */
-interface ExternalChecker<T> {
-    targetType: string;
-    sourcePath: (spec: T) => string;
-    check: (spec: T, externalData: unknown) => CheckResult;
-}
-/**
- * Check result
- */
-interface CheckResult {
-    success: boolean;
-    errors: {
-        message: string;
-        field?: string;
-        specId?: string;
-    }[];
-    warnings: {
-        message: string;
-        field?: string;
-        specId?: string;
-    }[];
-}
-/**
- * Coverage result
- */
-interface CoverageResult {
-    /** Total target count */
-    total: number;
-    /** Covered count */
-    covered: number;
-    /** Uncovered count */
-    uncovered: number;
-    /** Coverage rate (%) */
-    coveragePercent: number;
-    /** Details of covered items */
-    coveredItems: {
-        id: string;
-        description?: string;
-    }[];
-    /** Details of uncovered items */
-    uncoveredItems: {
-        id: string;
-        description?: string;
-        sourceId?: string;
-    }[];
-}
-/**
- * Coverage checker definition
- *
- * Verify cross-model consistency (coverage).
- * Example: Whether TestRef covers acceptanceCriteria of Requirement
- */
-interface CoverageChecker<T> {
-    /** Target model ID for coverage (e.g. 'requirement') */
-    targetModel: string;
-    /** Description of coverage check */
-    description: string;
-    /** Execute coverage check */
-    check: (specs: T[], registry: Record<string, Map<string, unknown>>) => CoverageResult;
-}
-/**
- * Render context
- * Simplified version compatible with embedoc's EmbedContext
- */
-interface RenderContext {
-    /** Parameters (filter conditions other than format, etc.) */
-    params: Record<string, string | undefined>;
-    /** Markdown helpers */
-    markdown: {
-        /** Generate table */
-        table: (headers: string[], rows: (string | unknown)[][]) => string;
-    };
-}
-/**
- * Renderer definition
- *
- * Model-specific rendering called from embeds
- */
-interface Renderer<T> {
-    /** Format ID ('table', 'list', 'detail', 'spec-chapter', etc.) */
-    format: string;
-    /** Rendering process */
-    render: (specs: T[], ctx: RenderContext) => string;
-}
-/**
- * Model base class
- *
- * @template TSchema - Zod schema type
- */
-declare abstract class Model<TSchema extends ZodType> {
-    /** Singleton instance storage (per subclass) */
-    private static _instances;
-    /**
-     * Get singleton instance of the model
-     * Usage: RequirementModel.instance
-     */
-    static get instance(): Model<ZodType>;
-    /** Model ID ('requirement', 'usecase', etc.) */
-    abstract readonly id: string;
-    /** Model name ('Requirement', 'UseCase', etc.) */
-    abstract readonly name: string;
-    /** ID prefix ('REQ', 'UC', etc.) */
-    abstract readonly idPrefix: string;
-    /** Zod schema */
-    abstract readonly schema: TSchema;
-    /** Model description (optional) */
-    readonly description?: string;
-    /** External SSOT type (optional, e.g. 'OpenAPI', 'DDL/Prisma') */
-    readonly externalSsotType?: string;
-    /** Spec instance type */
-    protected get specType(): z.infer<TSchema>;
-    /** Lint rules (override in subclass) */
-    protected lintRules: LintRule<z.infer<TSchema>>[];
-    /** Exporters (override in subclass) */
-    protected exporters: Exporter<z.infer<TSchema>>[];
-    /** External checker (optional) */
-    protected externalChecker?: ExternalChecker<z.infer<TSchema>>;
-    /** Coverage checker (optional) */
-    protected coverageChecker?: CoverageChecker<z.infer<TSchema>>;
-    /** Model level (set in _models/) */
-    protected modelLevel?: ModelLevel;
-    /** Renderers (for embeds, override in subclass) */
-    protected renderers: Renderer<z.infer<TSchema>>[];
-    /**
-     * Get model level
-     * Returns modelLevel set in _models/
-     */
-    get level(): ModelLevel | undefined;
-    /**
-     * Execute schema validation
-     */
-    validate(spec: unknown): z.infer<TSchema>;
-    /**
-     * Schema validation (safe version, returns error object on failure)
-     */
-    safeParse(spec: unknown): {
-        success: true;
-        data: z.infer<TSchema>;
-    } | {
-        success: false;
-        error: z.ZodError;
-    };
-    /**
-     * Execute lint
-     */
-    lint(spec: z.infer<TSchema>): LintResult[];
-    /**
-     * Execute lint for multiple specs
-     */
-    lintAll(specs: z.infer<TSchema>[]): LintResult[];
-    /**
-     * Validate level constraints of relations
-     * @param spec - Spec instance (if it has relations property)
-     * @returns Array of validation errors
-     */
-    validateRelations(spec: z.infer<TSchema>): RelationValidationError[];
-    /**
-     * Validate relations of multiple specs (including circular reference check)
-     */
-    validateAllRelations(specs: z.infer<TSchema>[]): RelationValidationError[];
-    /**
-     * Export in specified format (single spec)
-     */
-    exportSingle(spec: z.infer<TSchema>, format: string): string | null;
-    /**
-     * Export in specified format (index)
-     */
-    exportIndex(specs: z.infer<TSchema>[], format: string): string | null;
-    /**
-     * Get exporter output directory
-     */
-    getOutputDir(format: string): string | null;
-    /**
-     * Get filename
-     */
-    getFilename(spec: z.infer<TSchema>, format: string): string | null;
-    /**
-     * Check consistency with external SSOT
-     */
-    check(spec: z.infer<TSchema>, externalData: unknown): CheckResult;
-    /**
-     * Get external SSOT path
-     */
-    getExternalSourcePath(spec: z.infer<TSchema>): string | null;
-    /**
-     * Execute coverage check
-     * @param specs - Array of spec instances for this model
-     * @param registry - Registry of all models
-     */
-    checkCoverage(specs: z.infer<TSchema>[], registry: Record<string, Map<string, unknown>>): CoverageResult | null;
-    /**
-     * Get coverage checker
-     */
-    getCoverageChecker(): CoverageChecker<z.infer<TSchema>> | undefined;
-    /**
-     * Get lint rules
-     */
-    getLintRules(): LintRule<z.infer<TSchema>>[];
-    /**
-     * Get exporters
-     */
-    getExporters(): Exporter<z.infer<TSchema>>[];
-    /**
-     * Render in specified format
-     * @param format - Format ID ('table', 'list', 'detail', etc.)
-     * @param specs - Array of specs to render
-     * @param ctx - Render context
-     * @returns Rendered result (Markdown string), null if no matching renderer
-     */
-    render(format: string, specs: z.infer<TSchema>[], ctx: RenderContext): string | null;
-    /**
-     * Get list of available formats
-     */
-    getAvailableFormats(): string[];
-    /**
-     * Get renderers
-     */
-    getRenderers(): Renderer<z.infer<TSchema>>[];
-    /**
-     * Check if renderer exists for specific format
-     */
-    hasRenderer(format: string): boolean;
-    /**
-     * Register spec instances for this model.
-     * Stores specs in the global specStore keyed by this model's id.
-     */
-    register(specs: z.infer<TSchema>[]): void;
-}
-/**
- * A single (Model, data[]) pair.
- * Uses structural typing (not nominal Model<any>) so that
- * compiled dist/ Model instances are compatible with src/ types.
- */
-interface SpecEntry {
-    model: {
-        id: string;
-        register: (data: unknown[]) => void;
-    };
-    data: unknown[];
-}
-/**
- * Common export interface for spec data files.
- * Each spec file exports a SpecModule via defineSpecs().
- */
-interface SpecModule {
-    entries: SpecEntry[];
-}
-/**
- * Aggregated result from mergeSpecs().
- */
-interface MergedDesign {
-    models: SpecEntry['model'][];
-    specs: SpecEntry[];
-}
-/**
- * Define spec data in a spec file. Returns a SpecModule.
- *
- * @example
- * ```typescript
- * export default defineSpecs(
- *   [FunctionalRequirementModel.instance, functionalRequirements],
- *   [NonFunctionalRequirementModel.instance, nonFunctionalRequirements],
- * );
- * ```
- */
-declare function defineSpecs(...entries: [SpecEntry['model'], unknown[]][]): SpecModule;
-/**
- * Merge multiple SpecModules into a single MergedDesign.
- * Models are deduplicated by model.id.
- *
- * @example
- * ```typescript
- * // design/index.ts
- * export default mergeSpecs(requirements, usecases, glossary);
- * ```
- */
-declare function mergeSpecs(...modules: SpecModule[]): MergedDesign;
-/**
- * Build a registry (modelId -> Map<specId, spec>) from config.specs.
- * Pure function — no global state.
- */
-declare function buildRegistryFromConfig(specs: SpecEntry[] | undefined): Record<string, Map<string, unknown>>;
-/**
- * Get specs for a model ID from config.specs.
- * Pure function — no global state.
- */
-declare function getSpecsFromConfig(specs: SpecEntry[] | undefined, modelId: string): unknown[];
-/**
- * Find which model type a spec ID belongs to, from config.specs.
- * Pure function — no global state.
- */
-declare function findModelTypeFromConfig(specs: SpecEntry[] | undefined, specId: string): string | null;
-
 /**
  * Register model definition
  */
@@ -975,7 +532,7 @@ declare function resetModelInstances(): void;
 declare function lintModel<T extends {
     id: string;
 }>(modelId: string, instance: T, context: LintContext): Array<{
-    rule: LintRule$1<T>;
+    rule: LintRule<T>;
     issue: LintIssue;
 }>;
 /**
@@ -984,7 +541,7 @@ declare function lintModel<T extends {
 declare function lintAllModels(context: LintContext): Array<{
     modelId: string;
     instanceId: string;
-    rule: LintRule$1<unknown>;
+    rule: LintRule<unknown>;
     issue: LintIssue;
 }>;
 /**
@@ -1013,7 +570,7 @@ declare function exportAllModels(context: ExportContext): Array<{
  */
 declare function checkExternalSsot<T extends {
     id: string;
-}>(modelId: string, externalSource: unknown, context: CheckContext): CheckResult$1;
+}>(modelId: string, externalSource: unknown, context: CheckContext): CheckResult;
 /**
  * Resolve reference
  */
@@ -1072,6 +629,8 @@ interface SpeckeeperConfigInput {
             path: string;
         };
     };
+    /** External SSOT file paths — maps node IDs to file paths/globs */
+    externalPaths?: Record<string, string>;
     /** Lint configuration */
     lint?: {
         /** Strict mode */
@@ -1126,9 +685,9 @@ interface ModelDefinitionInput<T extends z.ZodTypeAny> {
         jsonSchema?: JsonSchemaExporter;
     };
     /** Lint rules */
-    lintRules?: LintRule$1<z.infer<T>>[];
+    lintRules?: LintRule<z.infer<T>>[];
     /** External SSOT checker */
-    externalChecker?: ExternalChecker$1<z.infer<T>>;
+    externalChecker?: ExternalChecker<z.infer<T>>;
     /** Reference definitions */
     references?: ReferenceDefinition[];
     /** DSL function name */
@@ -1203,7 +762,7 @@ declare function createLintRule<T>(config: {
         field?: string;
         suggestion?: string;
     } | null;
-}): LintRule$1<T>;
+}): LintRule<T>;
 /**
  * Load speckeeper.config.ts file and register custom models
  */
@@ -1354,4 +913,4 @@ declare function findDefinitionFiles(srcDir: string, subDir: string): Promise<st
 declare function generateDocsPath(baseDir: string, category: string, filename: string): string;
 declare function generateSpecsPath(baseDir: string, category: string, filename: string): string;
 
-export { type APIRefId, type ActorId, type BaseModelInstance, type BatchRefId, type BatchWriteResult, type BoundaryId, type CheckContext, type CheckError, CheckErrorSchema, type CheckResult, CheckResultSchema, type CheckWarning, CheckWarningSchema, type ComponentId, type ConcretizationSlot, ConcretizationSlotSchema, type CoverageChecker, type CoverageResult, type DTORequirementId, type DriftResult, type EntityId, type ErrorCaseId, type EventRequirementId, type ExportContext, type Exporter, type ExternalChecker, type FormId, ID_PATTERNS, type IaCRefId, type InferModelType, type JsonSchemaExporter, type LayerId, type Link, LinkSchema, type LintContext, type LintIssue, LintIssueSchema, type LintResult, type LintRule, type MarkdownExporter, type MergedDesign, type MermaidExporter, type MetaModelConfig, type MetaModelRegistry, Model, type ModelDefinition, type ModelDefinitionInput, type ModelLevel, type ModelRegistrySchema, type OutputPaths, type Phase, PhaseSchema, type Priority, PrioritySchema, type ProcessFlowId, RELATION_CONSTRAINTS, RELATION_TYPES, type ReferenceDefinition, ReferenceDefinitionSchema, type Relation, type RelationId, RelationSchema, type RelationValidationError, RelationsFieldSchema, type RenderContext, type Renderer, type RequirementId, type ResolvedSpeckeeperConfig, type RuleId, type ScreenId, type Severity, type SpecEntry, type SpecModule, type SpeckeeperConfig, type SpeckeeperConfigInput, type StateId, type TableRefId, type TermId, type TransitionId, type UIComponentId, type UseCaseId, type ValidationError, type ValidationResult, type WriteResult, batchWriteFiles, buildRegistryFromConfig, checkBatchDrift, checkExternalSsot, checkFileDrift, checkReferenceIntegrity, computeHash, createAPIRefId, createActorId, createBatchRefId, createBoundaryId, createComponentId, createDTORequirementId, createEntityId, createErrorCaseId, createEventRequirementId, createFormId, createIaCRefId, createLayerId, createLintRule, createMarkdownExporter, createMermaidExporter, createProcessFlowId, createRelationId, createRequirementId, createRuleId, createScreenId, createStateId, createTableRefId, createTermId, createTransitionId, createUIComponentId, createUseCaseId, defineConfig, defineModel, defineSpecs, detectCycles, ensureDir, exportAllModels, exportMarkdown, exportMermaid, findConfigFile, findDefinitionFiles, findFiles, findModelTypeFromConfig, findTypeScriptFiles, generateDocsPath, generateSpecsPath, getAllInstances, getAllModelDefinitions, getAllModelInstances, getExpectedOutputDirs, getGlobalModelRegistry, getLevelIndex, getModelDefinition, getModelInstance, getModelRegistryStats, getOutputPaths, getSpecsFromConfig, inferModelIdFromSpecId, lintAllModels, lintModel, loadConfig, loadSpeckeeperConfig, mergeSpecs, registerModelDefinition, registerModelDefinitions, registerModelInstance, resetModelInstances, resetModelRegistry, resolveReference, validateConfig, validateOutputPaths, validateRelationLevel, writeFile, writeJsonFile };
+export { type APIRefId, type ActorId, type BaseModelInstance, type BatchRefId, type BatchWriteResult, type BoundaryId, type CheckContext, type CheckError, CheckErrorSchema, CheckResultSchema, type CheckWarning, CheckWarningSchema, type ComponentId, type ConcretizationSlot, ConcretizationSlotSchema, type DTORequirementId, type DriftResult, type EntityId, type ErrorCaseId, type EventRequirementId, type ExportContext, type FormId, ID_PATTERNS, type IaCRefId, type InferModelType, type JsonSchemaExporter, type LayerId, type Link, LinkSchema, type LintContext, type LintIssue, LintIssueSchema, type MarkdownExporter, type MermaidExporter, type MetaModelConfig, type MetaModelRegistry, type ModelDefinition, type ModelDefinitionInput, type ModelRegistrySchema, type OutputPaths, type Phase, PhaseSchema, type Priority, PrioritySchema, type ProcessFlowId, type ReferenceDefinition, ReferenceDefinitionSchema, type RelationId, type RequirementId, type ResolvedSpeckeeperConfig, type RuleId, type ScreenId, type Severity, SpecEntry, type SpeckeeperConfig, type SpeckeeperConfigInput, type StateId, type TableRefId, type TermId, type TransitionId, type UIComponentId, type UseCaseId, type ValidationError, type ValidationResult, type WriteResult, batchWriteFiles, checkBatchDrift, checkExternalSsot, checkFileDrift, checkReferenceIntegrity, computeHash, createAPIRefId, createActorId, createBatchRefId, createBoundaryId, createComponentId, createDTORequirementId, createEntityId, createErrorCaseId, createEventRequirementId, createFormId, createIaCRefId, createLayerId, createLintRule, createMarkdownExporter, createMermaidExporter, createProcessFlowId, createRelationId, createRequirementId, createRuleId, createScreenId, createStateId, createTableRefId, createTermId, createTransitionId, createUIComponentId, createUseCaseId, defineConfig, defineModel, ensureDir, exportAllModels, exportMarkdown, exportMermaid, findConfigFile, findDefinitionFiles, findFiles, findTypeScriptFiles, generateDocsPath, generateSpecsPath, getAllInstances, getAllModelDefinitions, getAllModelInstances, getExpectedOutputDirs, getGlobalModelRegistry, getModelDefinition, getModelInstance, getModelRegistryStats, getOutputPaths, lintAllModels, lintModel, loadConfig, loadSpeckeeperConfig, registerModelDefinition, registerModelDefinitions, registerModelInstance, resetModelInstances, resetModelRegistry, resolveReference, validateConfig, validateOutputPaths, writeFile, writeJsonFile };

package/dist/index.js

@@ -101,6 +101,7 @@ var RELATION_TYPES = [
   "implements",
   "refines",
   "verifies",
+  "verifiedBy",
   "satisfies",
   "traces",
   "relatedTo"
@@ -170,6 +171,12 @@ var RELATION_CONSTRAINTS = {
     levelRule: "any",
     propagation: "both"
   },
+  // Spec→Test (verification relationship: spec is verified by test code)
+  "verifiedBy": {
+    allowedTargetLevels: ["L2", "L3"],
+    levelRule: "any",
+    propagation: "backward"
+  },
   // General relation
   "relatedTo": {
     levelRule: "any",