@contractspec/bundle.workspace 1.46.1 → 1.47.0

package/dist/services/impact/types.d.mts

@@ -0,0 +1,63 @@
+import { ImpactResult as ImpactResult$1 } from "@contractspec/module.workspace";
+
+//#region src/services/impact/types.d.ts
+
+/** Options for impact detection */
+interface ImpactDetectionOptions {
+  /** Git ref to compare against (branch, tag, commit) */
+  baseline?: string;
+  /** Glob pattern for spec discovery */
+  pattern?: string;
+  /** Workspace root directory */
+  workspaceRoot?: string;
+}
+/** Impact detection result with additional context */
+interface ImpactDetectionResult extends ImpactResult$1 {
+  /** Working directory */
+  workspaceRoot: string;
+  /** Number of specs analyzed */
+  specsAnalyzed: number;
+}
+/** PR comment options */
+interface PrCommentOptions {
+  /** Template style */
+  template: 'minimal' | 'detailed';
+  /** Include links to files */
+  includeLinks?: boolean;
+  /** Repository URL for links */
+  repositoryUrl?: string;
+  /** Commit SHA for links */
+  commitSha?: string;
+  /** Drift detection result */
+  drift?: {
+    hasDrift: boolean;
+    files: string[];
+  };
+}
+/** GitHub check run payload */
+interface CheckRunPayload {
+  /** Check run name */
+  name: string;
+  /** Head SHA */
+  headSha: string;
+  /** Conclusion */
+  conclusion: 'success' | 'failure' | 'neutral';
+  /** Output title */
+  title: string;
+  /** Output summary */
+  summary: string;
+  /** Annotations */
+  annotations?: CheckRunAnnotation[];
+}
+/** Check run annotation */
+interface CheckRunAnnotation {
+  path: string;
+  startLine: number;
+  endLine: number;
+  annotationLevel: 'notice' | 'warning' | 'failure';
+  message: string;
+  title?: string;
+}
+//#endregion
+export { CheckRunAnnotation, CheckRunPayload, ImpactDetectionOptions, ImpactDetectionResult, type ImpactResult$1 as ImpactResult, PrCommentOptions };
+//# sourceMappingURL=types.d.mts.map

package/dist/services/impact/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/services/impact/types.ts"],"sourcesContent":[],"mappings":";;;;AA4BA;AAiBiB,UAnCA,sBAAA,CA+CD;EAIC;;;;;;;;UAzCA,qBAAA,SAA8B;;;;;;;UAQ9B,gBAAA;;;;;;;;;;;;;;;;UAiBA,eAAA;;;;;;;;;;;;gBAYD;;;UAIC,kBAAA"}

package/dist/services/implementation/discovery.d.mts

@@ -0,0 +1,30 @@
+import { FsAdapter } from "../../ports/fs.mjs";
+import { DiscoveryOptions, SpecReferenceMatch } from "./types.mjs";
+import { ImplementationType } from "@contractspec/lib.contracts";
+
+//#region src/services/implementation/discovery.d.ts
+
+/**
+ * Infer implementation type from file path.
+ */
+declare function inferImplementationType(filePath: string): ImplementationType;
+/**
+ * Extract spec references from source code.
+ */
+declare function extractSpecReferences(code: string, filePath: string): SpecReferenceMatch[];
+/**
+ * Discover implementations that reference a specific spec.
+ */
+declare function discoverImplementationsForSpec(specKey: string, adapters: {
+  fs: FsAdapter;
+}, options?: DiscoveryOptions): Promise<SpecReferenceMatch[]>;
+/**
+ * Discover all spec references in the workspace.
+ * Returns a map of spec key to implementation references.
+ */
+declare function discoverAllImplementations(adapters: {
+  fs: FsAdapter;
+}, options?: DiscoveryOptions): Promise<Map<string, SpecReferenceMatch[]>>;
+//#endregion
+export { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType };
+//# sourceMappingURL=discovery.d.mts.map

package/dist/services/implementation/discovery.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.mts","names":[],"sources":["../../../src/services/implementation/discovery.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAsLU,iBAnIM,uBAAA,CAmIN,QAAA,EAAA,MAAA,CAAA,EAnIiD,kBAmIjD;AAkCV;;;AAGuB,iBAhJP,qBAAA,CAgJO,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,CAAA,EA7IpB,kBA6IoB,EAAA;;;;iBAzCD,8BAAA;MAEJ;aACP,mBACR,QAAQ;;;;;iBAkCW,0BAAA;MACJ;aACP,mBACR,QAAQ,YAAY"}

package/dist/services/implementation/discovery.mjs

@@ -0,0 +1,144 @@
+//#region src/services/implementation/discovery.ts
+/**
+* Patterns for detecting spec references in source code.
+*/
+const SPEC_REFERENCE_PATTERNS = {
+	namedImport: /import\s*\{[^}]*\b(\w+(?:Spec|Contract|Command|Query))\b[^}]*\}\s*from/g,
+	defaultImport: /import\s+(\w+(?:Spec|Contract|Command|Query))\s+from/g,
+	contractHandler: /ContractHandler\s*<\s*typeof\s+(\w+)\s*>/g,
+	typeofSpec: /typeof\s+(\w+(?:Spec|Contract|Command|Query))\b/g,
+	specAssignment: /(?:spec|contract)\s*[:=]\s*(\w+(?:Spec|Contract|Command|Query))\b/gi
+};
+/**
+* File patterns that indicate implementation types.
+*/
+const IMPLEMENTATION_TYPE_PATTERNS = {
+	".handler.ts": "handler",
+	".handler.tsx": "handler",
+	".service.ts": "service",
+	".service.tsx": "service",
+	".test.ts": "test",
+	".test.tsx": "test",
+	".spec.ts": "test",
+	".spec.tsx": "test",
+	".component.tsx": "component",
+	".tsx": "component",
+	".form.tsx": "form",
+	".hook.ts": "hook",
+	".hook.tsx": "hook"
+};
+/**
+* Infer implementation type from file path.
+*/
+function inferImplementationType(filePath) {
+	const lowerPath = filePath.toLowerCase();
+	for (const [pattern, type] of Object.entries(IMPLEMENTATION_TYPE_PATTERNS)) if (lowerPath.endsWith(pattern)) return type;
+	if (lowerPath.includes("/handlers/")) return "handler";
+	if (lowerPath.includes("/services/")) return "service";
+	if (lowerPath.includes("/components/")) return "component";
+	if (lowerPath.includes("/forms/")) return "form";
+	if (lowerPath.includes("/hooks/")) return "hook";
+	if (lowerPath.includes("/__tests__/")) return "test";
+	return "other";
+}
+/**
+* Extract spec references from source code.
+*/
+function extractSpecReferences(code, filePath) {
+	const matches = [];
+	const seenSpecs = /* @__PURE__ */ new Set();
+	const addMatch = (specKey, referenceType, lineNumber) => {
+		const key = `${specKey}:${referenceType}`;
+		if (seenSpecs.has(key)) return;
+		seenSpecs.add(key);
+		matches.push({
+			filePath,
+			specKey,
+			referenceType,
+			lineNumber,
+			inferredType: inferImplementationType(filePath)
+		});
+	};
+	const getLineNumber = (position) => {
+		return code.substring(0, position).split("\n").length;
+	};
+	let match;
+	const handlerPattern = new RegExp(SPEC_REFERENCE_PATTERNS.contractHandler);
+	while ((match = handlerPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "handler", getLineNumber(match.index));
+	const typeofPattern = new RegExp(SPEC_REFERENCE_PATTERNS.typeofSpec);
+	while ((match = typeofPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "typeof", getLineNumber(match.index));
+	const namedPattern = new RegExp(SPEC_REFERENCE_PATTERNS.namedImport);
+	while ((match = namedPattern.exec(code)) !== null) {
+		const specNames = match[0].match(/\b(\w+(?:Spec|Contract|Command|Query))\b/g);
+		if (specNames) for (const name of specNames) addMatch(name, "import", getLineNumber(match.index));
+	}
+	const defaultPattern = new RegExp(SPEC_REFERENCE_PATTERNS.defaultImport);
+	while ((match = defaultPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "import", getLineNumber(match.index));
+	const assignPattern = new RegExp(SPEC_REFERENCE_PATTERNS.specAssignment);
+	while ((match = assignPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "unknown", getLineNumber(match.index));
+	return matches;
+}
+/**
+* Default glob patterns for implementation files.
+*/
+const DEFAULT_INCLUDE_PATTERNS = ["**/*.ts", "**/*.tsx"];
+const DEFAULT_EXCLUDE_PATTERNS = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.git/**",
+	"**/*.d.ts",
+	"**/*.operation.ts",
+	"**/*.spec.ts",
+	"**/*.feature.ts",
+	"**/*.event.ts",
+	"**/*.presentation.ts"
+];
+/**
+* Discover implementations that reference a specific spec.
+*/
+async function discoverImplementationsForSpec(specKey, adapters, options = {}) {
+	const { fs } = adapters;
+	const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;
+	const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;
+	const allMatches = [];
+	for (const pattern of includePatterns) {
+		const files = await fs.glob({
+			pattern,
+			ignore: excludePatterns
+		});
+		for (const filePath of files) try {
+			const matchingRefs = extractSpecReferences(await fs.readFile(filePath), filePath).filter((ref) => ref.specKey === specKey);
+			allMatches.push(...matchingRefs);
+		} catch {}
+	}
+	return allMatches;
+}
+/**
+* Discover all spec references in the workspace.
+* Returns a map of spec key to implementation references.
+*/
+async function discoverAllImplementations(adapters, options = {}) {
+	const { fs } = adapters;
+	const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;
+	const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;
+	const specToImplementations = /* @__PURE__ */ new Map();
+	for (const pattern of includePatterns) {
+		const files = await fs.glob({
+			pattern,
+			ignore: excludePatterns
+		});
+		for (const filePath of files) try {
+			const references = extractSpecReferences(await fs.readFile(filePath), filePath);
+			for (const ref of references) {
+				const existing = specToImplementations.get(ref.specKey) ?? [];
+				existing.push(ref);
+				specToImplementations.set(ref.specKey, existing);
+			}
+		} catch {}
+	}
+	return specToImplementations;
+}
+
+//#endregion
+export { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType };
+//# sourceMappingURL=discovery.mjs.map

package/dist/services/implementation/discovery.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.mjs","names":[],"sources":["../../../src/services/implementation/discovery.ts"],"sourcesContent":["/**\n * Implementation auto-discovery service.\n *\n * Scans workspace files to find implementations that reference specs.\n * Uses regex-based pattern matching for performance (avoids full AST parsing).\n */\n\nimport type { FsAdapter } from '../../ports/fs';\nimport type { ImplementationType } from '@contractspec/lib.contracts';\nimport type { DiscoveryOptions, SpecReferenceMatch } from './types';\n\n/**\n * Patterns for detecting spec references in source code.\n */\nconst SPEC_REFERENCE_PATTERNS = {\n  // import { SpecName } from './path'\n  namedImport:\n    /import\\s*\\{[^}]*\\b(\\w+(?:Spec|Contract|Command|Query))\\b[^}]*\\}\\s*from/g,\n  // import SpecName from './path'\n  defaultImport: /import\\s+(\\w+(?:Spec|Contract|Command|Query))\\s+from/g,\n  // ContractHandler<typeof SpecName>\n  contractHandler: /ContractHandler\\s*<\\s*typeof\\s+(\\w+)\\s*>/g,\n  // typeof SpecName (generic usage)\n  typeofSpec: /typeof\\s+(\\w+(?:Spec|Contract|Command|Query))\\b/g,\n  // spec: SpecKey or spec = SpecKey\n  specAssignment:\n    /(?:spec|contract)\\s*[:=]\\s*(\\w+(?:Spec|Contract|Command|Query))\\b/gi,\n};\n\n/**\n * File patterns that indicate implementation types.\n */\nconst IMPLEMENTATION_TYPE_PATTERNS: Record<string, ImplementationType> = {\n  '.handler.ts': 'handler',\n  '.handler.tsx': 'handler',\n  '.service.ts': 'service',\n  '.service.tsx': 'service',\n  '.test.ts': 'test',\n  '.test.tsx': 'test',\n  '.spec.ts': 'test',\n  '.spec.tsx': 'test',\n  '.component.tsx': 'component',\n  '.tsx': 'component', // Default for TSX files\n  '.form.tsx': 'form',\n  '.hook.ts': 'hook',\n  '.hook.tsx': 'hook',\n};\n\n/**\n * Infer implementation type from file path.\n */\nexport function inferImplementationType(filePath: string): ImplementationType {\n  const lowerPath = filePath.toLowerCase();\n\n  // Check specific patterns first (order matters)\n  for (const [pattern, type] of Object.entries(IMPLEMENTATION_TYPE_PATTERNS)) {\n    if (lowerPath.endsWith(pattern)) {\n      return type;\n    }\n  }\n\n  // Check directory patterns\n  if (lowerPath.includes('/handlers/')) return 'handler';\n  if (lowerPath.includes('/services/')) return 'service';\n  if (lowerPath.includes('/components/')) return 'component';\n  if (lowerPath.includes('/forms/')) return 'form';\n  if (lowerPath.includes('/hooks/')) return 'hook';\n  if (lowerPath.includes('/__tests__/')) return 'test';\n\n  return 'other';\n}\n\n/**\n * Extract spec references from source code.\n */\nexport function extractSpecReferences(\n  code: string,\n  filePath: string\n): SpecReferenceMatch[] {\n  const matches: SpecReferenceMatch[] = [];\n  const seenSpecs = new Set<string>();\n\n  // Helper to add unique matches\n  const addMatch = (\n    specKey: string,\n    referenceType: SpecReferenceMatch['referenceType'],\n    lineNumber?: number\n  ) => {\n    const key = `${specKey}:${referenceType}`;\n    if (seenSpecs.has(key)) return;\n    seenSpecs.add(key);\n\n    matches.push({\n      filePath,\n      specKey,\n      referenceType,\n      lineNumber,\n      inferredType: inferImplementationType(filePath),\n    });\n  };\n\n  // Find line number for a match position\n  const getLineNumber = (position: number): number => {\n    const lines = code.substring(0, position).split('\\n');\n    return lines.length;\n  };\n\n  // Check ContractHandler pattern (most specific)\n  let match: RegExpExecArray | null;\n  const handlerPattern = new RegExp(SPEC_REFERENCE_PATTERNS.contractHandler);\n  while ((match = handlerPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'handler', getLineNumber(match.index));\n    }\n  }\n\n  // Check typeof pattern\n  const typeofPattern = new RegExp(SPEC_REFERENCE_PATTERNS.typeofSpec);\n  while ((match = typeofPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'typeof', getLineNumber(match.index));\n    }\n  }\n\n  // Check named imports\n  const namedPattern = new RegExp(SPEC_REFERENCE_PATTERNS.namedImport);\n  while ((match = namedPattern.exec(code)) !== null) {\n    // Extract all spec names from the import statement\n    const importBlock = match[0];\n    const specNames = importBlock.match(\n      /\\b(\\w+(?:Spec|Contract|Command|Query))\\b/g\n    );\n    if (specNames) {\n      for (const name of specNames) {\n        addMatch(name, 'import', getLineNumber(match.index));\n      }\n    }\n  }\n\n  // Check default imports\n  const defaultPattern = new RegExp(SPEC_REFERENCE_PATTERNS.defaultImport);\n  while ((match = defaultPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'import', getLineNumber(match.index));\n    }\n  }\n\n  // Check spec assignments\n  const assignPattern = new RegExp(SPEC_REFERENCE_PATTERNS.specAssignment);\n  while ((match = assignPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'unknown', getLineNumber(match.index));\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Default glob patterns for implementation files.\n */\nconst DEFAULT_INCLUDE_PATTERNS = ['**/*.ts', '**/*.tsx'];\n\nconst DEFAULT_EXCLUDE_PATTERNS = [\n  '**/node_modules/**',\n  '**/dist/**',\n  '**/.git/**',\n  '**/*.d.ts',\n  '**/*.operation.ts', // Skip spec files themselves\n  '**/*.spec.ts', // Skip test spec files\n  '**/*.feature.ts', // Skip feature files\n  '**/*.event.ts', // Skip event spec files\n  '**/*.presentation.ts', // Skip presentation files\n];\n\n/**\n * Discover implementations that reference a specific spec.\n */\nexport async function discoverImplementationsForSpec(\n  specKey: string,\n  adapters: { fs: FsAdapter },\n  options: DiscoveryOptions = {}\n): Promise<SpecReferenceMatch[]> {\n  const { fs } = adapters;\n  const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;\n  const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;\n\n  const allMatches: SpecReferenceMatch[] = [];\n\n  // Scan each include pattern\n  for (const pattern of includePatterns) {\n    const files = await fs.glob({ pattern, ignore: excludePatterns });\n\n    for (const filePath of files) {\n      try {\n        const content = await fs.readFile(filePath);\n        const references = extractSpecReferences(content, filePath);\n\n        // Filter to only references for the target spec\n        const matchingRefs = references.filter(\n          (ref) => ref.specKey === specKey\n        );\n        allMatches.push(...matchingRefs);\n      } catch {\n        // Skip files that can't be read\n      }\n    }\n  }\n\n  return allMatches;\n}\n\n/**\n * Discover all spec references in the workspace.\n * Returns a map of spec key to implementation references.\n */\nexport async function discoverAllImplementations(\n  adapters: { fs: FsAdapter },\n  options: DiscoveryOptions = {}\n): Promise<Map<string, SpecReferenceMatch[]>> {\n  const { fs } = adapters;\n  const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;\n  const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;\n\n  const specToImplementations = new Map<string, SpecReferenceMatch[]>();\n\n  // Scan each include pattern\n  for (const pattern of includePatterns) {\n    const files = await fs.glob({ pattern, ignore: excludePatterns });\n\n    for (const filePath of files) {\n      try {\n        const content = await fs.readFile(filePath);\n        const references = extractSpecReferences(content, filePath);\n\n        // Group by spec key\n        for (const ref of references) {\n          const existing = specToImplementations.get(ref.specKey) ?? [];\n          existing.push(ref);\n          specToImplementations.set(ref.specKey, existing);\n        }\n      } catch {\n        // Skip files that can't be read\n      }\n    }\n  }\n\n  return specToImplementations;\n}\n"],"mappings":"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"}

package/dist/services/implementation/index.d.mts

@@ -0,0 +1,6 @@
+import { DiscoveryOptions, ImplementationSource, ImplementationStatus, ResolvedImplementation, ResolverOptions, SpecImplementationResult, SpecReferenceMatch } from "./types.mjs";
+import { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType } from "./discovery.mjs";
+import { getSpecKeyVariants, parseExplicitImplementations } from "./resolver/parsers.mjs";
+import { getConventionPaths, toKebabCase } from "./resolver/conventions.mjs";
+import { determineStatus, getImplementationSummary } from "./resolver/status.mjs";
+import { resolveAllImplementations, resolveImplementations } from "./resolver/index.mjs";

package/dist/services/implementation/index.mjs

@@ -0,0 +1,7 @@
+import { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType } from "./discovery.mjs";
+import { getConventionPaths, toKebabCase } from "./resolver/conventions.mjs";
+import { getSpecKeyVariants, parseExplicitImplementations } from "./resolver/parsers.mjs";
+import { determineStatus, getImplementationSummary } from "./resolver/status.mjs";
+import { resolveAllImplementations, resolveImplementations } from "./resolver/index.mjs";
+
+export {  };

package/dist/services/implementation/resolver/conventions.d.mts

@@ -0,0 +1,18 @@
+import { ImplementationType } from "@contractspec/lib.contracts";
+
+//#region src/services/implementation/resolver/conventions.d.ts
+
+/**
+ * Convert string to kebab-case.
+ */
+declare function toKebabCase(value: string): string;
+/**
+ * Get convention-based implementation paths for a spec.
+ */
+declare function getConventionPaths(specType: string, specKey: string, outputDir: string): {
+  path: string;
+  type: ImplementationType;
+}[];
+//#endregion
+export { getConventionPaths, toKebabCase };
+//# sourceMappingURL=conventions.d.mts.map

package/dist/services/implementation/resolver/conventions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.d.mts","names":[],"sources":["../../../../src/services/implementation/resolver/conventions.ts"],"sourcesContent":[],"mappings":";;;;AAmBA;;;iBAVgB,WAAA;;;;iBAUA,kBAAA;;QAIS"}

package/dist/services/implementation/resolver/conventions.mjs

@@ -0,0 +1,59 @@
+//#region src/services/implementation/resolver/conventions.ts
+/**
+* Convert string to kebab-case.
+*/
+function toKebabCase(value) {
+	return value.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+* Get convention-based implementation paths for a spec.
+*/
+function getConventionPaths(specType, specKey, outputDir) {
+	const kebab = toKebabCase(specKey);
+	const paths = [];
+	if (specType === "operation") {
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.ts`,
+			type: "handler"
+		});
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.test.ts`,
+			type: "test"
+		});
+	}
+	if (specType === "presentation") {
+		paths.push({
+			path: `${outputDir}/components/${kebab}.tsx`,
+			type: "component"
+		});
+		paths.push({
+			path: `${outputDir}/components/${kebab}.test.tsx`,
+			type: "test"
+		});
+	}
+	if (specType === "form") {
+		paths.push({
+			path: `${outputDir}/forms/${kebab}.form.tsx`,
+			type: "form"
+		});
+		paths.push({
+			path: `${outputDir}/forms/${kebab}.form.test.tsx`,
+			type: "test"
+		});
+	}
+	if (specType === "event") {
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.ts`,
+			type: "handler"
+		});
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.test.ts`,
+			type: "test"
+		});
+	}
+	return paths;
+}
+
+//#endregion
+export { getConventionPaths, toKebabCase };
+//# sourceMappingURL=conventions.mjs.map

package/dist/services/implementation/resolver/conventions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.mjs","names":[],"sources":["../../../../src/services/implementation/resolver/conventions.ts"],"sourcesContent":["/**\n * Convention-based implementation path resolution.\n */\n\nimport type { ImplementationType } from '@contractspec/lib.contracts';\n\n/**\n * Convert string to kebab-case.\n */\nexport function toKebabCase(value: string): string {\n  return value\n    .replace(/\\./g, '-')\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .toLowerCase();\n}\n\n/**\n * Get convention-based implementation paths for a spec.\n */\nexport function getConventionPaths(\n  specType: string,\n  specKey: string,\n  outputDir: string\n): { path: string; type: ImplementationType }[] {\n  const kebab = toKebabCase(specKey);\n  const paths: { path: string; type: ImplementationType }[] = [];\n\n  if (specType === 'operation') {\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.ts`,\n      type: 'handler',\n    });\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.test.ts`,\n      type: 'test',\n    });\n  }\n\n  if (specType === 'presentation') {\n    paths.push({\n      path: `${outputDir}/components/${kebab}.tsx`,\n      type: 'component',\n    });\n    paths.push({\n      path: `${outputDir}/components/${kebab}.test.tsx`,\n      type: 'test',\n    });\n  }\n\n  if (specType === 'form') {\n    paths.push({\n      path: `${outputDir}/forms/${kebab}.form.tsx`,\n      type: 'form',\n    });\n    paths.push({\n      path: `${outputDir}/forms/${kebab}.form.test.tsx`,\n      type: 'test',\n    });\n  }\n\n  if (specType === 'event') {\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.ts`,\n      type: 'handler',\n    });\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.test.ts`,\n      type: 'test',\n    });\n  }\n\n  return paths;\n}\n"],"mappings":";;;;AASA,SAAgB,YAAY,OAAuB;AACjD,QAAO,MACJ,QAAQ,OAAO,IAAI,CACnB,QAAQ,mBAAmB,QAAQ,CACnC,aAAa;;;;;AAMlB,SAAgB,mBACd,UACA,SACA,WAC8C;CAC9C,MAAM,QAAQ,YAAY,QAAQ;CAClC,MAAM,QAAsD,EAAE;AAE9D,KAAI,aAAa,aAAa;AAC5B,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,YAAY,MAAM;GACrC,MAAM;GACP,CAAC;AACF,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,YAAY,MAAM;GACrC,MAAM;GACP,CAAC;;AAGJ,KAAI,aAAa,gBAAgB;AAC/B,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,cAAc,MAAM;GACvC,MAAM;GACP,CAAC;AACF,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,cAAc,MAAM;GACvC,MAAM;GACP,CAAC;;AAGJ,KAAI,aAAa,QAAQ;AACvB,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,SAAS,MAAM;GAClC,MAAM;GACP,CAAC;AACF,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,SAAS,MAAM;GAClC,MAAM;GACP,CAAC;;AAGJ,KAAI,aAAa,SAAS;AACxB,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,YAAY,MAAM;GACrC,MAAM;GACP,CAAC;AACF,QAAM,KAAK;GACT,MAAM,GAAG,UAAU,YAAY,MAAM;GACrC,MAAM;GACP,CAAC;;AAGJ,QAAO"}

package/dist/services/implementation/resolver/index.d.mts

@@ -0,0 +1,24 @@
+import { FsAdapter } from "../../../ports/fs.mjs";
+import { ResolverOptions, SpecImplementationResult } from "../types.mjs";
+import { getSpecKeyVariants, parseExplicitImplementations } from "./parsers.mjs";
+import { getConventionPaths, toKebabCase } from "./conventions.mjs";
+import { determineStatus, getImplementationSummary } from "./status.mjs";
+import { WorkspaceConfig } from "@contractspec/module.workspace";
+
+//#region src/services/implementation/resolver/index.d.ts
+
+/**
+ * Resolve all implementations for a spec file.
+ */
+declare function resolveImplementations(specFile: string, adapters: {
+  fs: FsAdapter;
+}, config: WorkspaceConfig, options?: ResolverOptions): Promise<SpecImplementationResult>;
+/**
+ * Resolve implementations for multiple spec files.
+ */
+declare function resolveAllImplementations(specFiles: string[], adapters: {
+  fs: FsAdapter;
+}, config: WorkspaceConfig, options?: ResolverOptions): Promise<SpecImplementationResult[]>;
+//#endregion
+export { resolveAllImplementations, resolveImplementations };
+//# sourceMappingURL=index.d.mts.map

package/dist/services/implementation/resolver/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../../src/services/implementation/resolver/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAyKA;;AAGU,iBA5HY,sBAAA,CA4HZ,QAAA,EAAA,MAAA,EAAA,QAAA,EAAA;EACC,EAAA,EA3HO,SA2HP;CACA,EAAA,MAAA,EA3HD,eA2HC,EAAA,OAAA,CAAA,EA1HA,eA0HA,CAAA,EAzHR,OAyHQ,CAzHA,wBAyHA,CAAA;;;;iBALW,yBAAA;MAEJ;WACR,2BACC,kBACR,QAAQ"}

package/dist/services/implementation/resolver/index.mjs

@@ -0,0 +1,111 @@
+import { discoverImplementationsForSpec } from "../discovery.mjs";
+import { getConventionPaths, toKebabCase } from "./conventions.mjs";
+import { getSpecKeyVariants, parseExplicitImplementations } from "./parsers.mjs";
+import { determineStatus, getImplementationSummary } from "./status.mjs";
+import { scanSpecSource } from "@contractspec/module.workspace";
+import path from "path";
+import { createHash } from "crypto";
+
+//#region src/services/implementation/resolver/index.ts
+/**
+* Implementation resolver service.
+*
+* Resolves all implementations for a spec by merging:
+* 1. Explicit mappings from spec.implementations
+* 2. Auto-discovered references from workspace scanning
+* 3. Convention-based paths (naming conventions)
+*/
+const DEFAULT_OPTIONS = {
+	includeExplicit: true,
+	includeDiscovered: true,
+	includeConvention: true,
+	computeHashes: true
+};
+/**
+* Compute SHA256 hash of content.
+*/
+function computeHash(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* Resolve all implementations for a spec file.
+*/
+async function resolveImplementations(specFile, adapters, config, options = {}) {
+	const opts = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const { fs } = adapters;
+	if (!await fs.exists(specFile)) throw new Error(`Spec file not found: ${specFile}`);
+	const specContent = await fs.readFile(specFile);
+	const specHash = opts.computeHashes ? computeHash(specContent) : void 0;
+	const scan = scanSpecSource(specContent, specFile);
+	const specKey = scan.key ?? path.basename(specFile).replace(/\.[jt]s$/, "");
+	const specVersion = scan.version ?? "1.0.0";
+	const specType = scan.specType ?? "operation";
+	const implementations = [];
+	const seenPaths = /* @__PURE__ */ new Set();
+	const addImpl = async (path$1, type, source, description) => {
+		if (seenPaths.has(path$1)) return;
+		seenPaths.add(path$1);
+		const exists = await fs.exists(path$1);
+		let contentHash;
+		if (exists && opts.computeHashes) try {
+			contentHash = computeHash(await fs.readFile(path$1));
+		} catch {}
+		implementations.push({
+			path: path$1,
+			type,
+			source,
+			exists,
+			contentHash,
+			description
+		});
+	};
+	if (opts.includeExplicit) {
+		const explicitImpls = parseExplicitImplementations(specContent);
+		for (const impl of explicitImpls) await addImpl(impl.path, impl.type, "explicit", impl.description);
+	}
+	if (opts.includeDiscovered) {
+		const discovered = await discoverImplementationsForSpec(specKey, adapters, opts);
+		const specKeyVariants = getSpecKeyVariants(specKey);
+		for (const variant of specKeyVariants) {
+			const variantDiscovered = await discoverImplementationsForSpec(variant, adapters, opts);
+			discovered.push(...variantDiscovered);
+		}
+		for (const ref of discovered) {
+			if (ref.filePath === specFile) continue;
+			await addImpl(ref.filePath, ref.inferredType, "discovered");
+		}
+	}
+	if (opts.includeConvention) {
+		const conventionPaths = getConventionPaths(specType, specKey, opts.outputDir ?? config.outputDir ?? "./src");
+		for (const { path: path$1, type } of conventionPaths) await addImpl(path$1, type, "convention");
+	}
+	return {
+		specKey,
+		specVersion,
+		specPath: specFile,
+		specType,
+		implementations,
+		status: determineStatus(implementations),
+		specHash
+	};
+}
+/**
+* Resolve implementations for multiple spec files.
+*/
+async function resolveAllImplementations(specFiles, adapters, config, options = {}) {
+	const results = [];
+	for (const specFile of specFiles) try {
+		const result = await resolveImplementations(specFile, adapters, config, options);
+		results.push(result);
+	} catch (error) {
+		console.error(`Failed to resolve implementations for ${specFile}:`, error);
+	}
+	return results;
+}
+
+//#endregion
+export { resolveAllImplementations, resolveImplementations };
+//# sourceMappingURL=index.mjs.map

package/dist/services/implementation/resolver/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["path"],"sources":["../../../../src/services/implementation/resolver/index.ts"],"sourcesContent":["/**\n * Implementation resolver service.\n *\n * Resolves all implementations for a spec by merging:\n * 1. Explicit mappings from spec.implementations\n * 2. Auto-discovered references from workspace scanning\n * 3. Convention-based paths (naming conventions)\n */\n\nimport { createHash } from 'crypto';\nimport path from 'path';\n\nimport type { WorkspaceConfig } from '@contractspec/module.workspace';\nimport { scanSpecSource } from '@contractspec/module.workspace';\nimport type { ImplementationType } from '@contractspec/lib.contracts';\nimport type { FsAdapter } from '../../../ports/fs';\nimport type {\n  ResolverOptions,\n  ResolvedImplementation,\n  SpecImplementationResult,\n} from '../types';\nimport { discoverImplementationsForSpec } from '../discovery';\n\nimport { getConventionPaths } from './conventions';\nimport { getSpecKeyVariants, parseExplicitImplementations } from './parsers';\nimport { determineStatus } from './status';\n\nexport * from './parsers';\nexport * from './conventions';\nexport * from './status';\n\nconst DEFAULT_OPTIONS: ResolverOptions = {\n  includeExplicit: true,\n  includeDiscovered: true,\n  includeConvention: true,\n  computeHashes: true,\n};\n\n/**\n * Compute SHA256 hash of content.\n */\nfunction computeHash(content: string): string {\n  return createHash('sha256').update(content).digest('hex');\n}\n\n/**\n * Resolve all implementations for a spec file.\n */\nexport async function resolveImplementations(\n  specFile: string,\n  adapters: { fs: FsAdapter },\n  config: WorkspaceConfig,\n  options: ResolverOptions = {}\n): Promise<SpecImplementationResult> {\n  const opts = { ...DEFAULT_OPTIONS, ...options };\n  const { fs } = adapters;\n\n  // Read and parse spec file\n  const specExists = await fs.exists(specFile);\n  if (!specExists) {\n    throw new Error(`Spec file not found: ${specFile}`);\n  }\n\n  const specContent = await fs.readFile(specFile);\n  const specHash = opts.computeHashes ? computeHash(specContent) : undefined;\n  const scan = scanSpecSource(specContent, specFile);\n\n  const specKey = scan.key ?? path.basename(specFile).replace(/\\.[jt]s$/, '');\n  const specVersion = scan.version ?? '1.0.0';\n  const specType = scan.specType ?? 'operation';\n\n  const implementations: ResolvedImplementation[] = [];\n  const seenPaths = new Set<string>();\n\n  // Helper to add unique implementations\n  const addImpl = async (\n    path: string,\n    type: ImplementationType,\n    source: ResolvedImplementation['source'],\n    description?: string\n  ) => {\n    if (seenPaths.has(path)) return;\n    seenPaths.add(path);\n\n    const exists = await fs.exists(path);\n    let contentHash: string | undefined;\n\n    if (exists && opts.computeHashes) {\n      try {\n        const content = await fs.readFile(path);\n        contentHash = computeHash(content);\n      } catch {\n        // Ignore hash computation errors\n      }\n    }\n\n    implementations.push({\n      path,\n      type,\n      source,\n      exists,\n      contentHash,\n      description,\n    });\n  };\n\n  // 1. Add explicit implementations from spec\n  if (opts.includeExplicit) {\n    // Parse explicit implementations from spec source\n    const explicitImpls = parseExplicitImplementations(specContent);\n    for (const impl of explicitImpls) {\n      await addImpl(impl.path, impl.type, 'explicit', impl.description);\n    }\n  }\n\n  // 2. Add auto-discovered implementations\n  if (opts.includeDiscovered) {\n    const discovered = await discoverImplementationsForSpec(\n      specKey,\n      adapters,\n      opts\n    );\n\n    // Also search for spec key variants\n    const specKeyVariants = getSpecKeyVariants(specKey);\n    for (const variant of specKeyVariants) {\n      const variantDiscovered = await discoverImplementationsForSpec(\n        variant,\n        adapters,\n        opts\n      );\n      discovered.push(...variantDiscovered);\n    }\n\n    for (const ref of discovered) {\n      // Skip the spec file itself\n      if (ref.filePath === specFile) continue;\n\n      await addImpl(ref.filePath, ref.inferredType, 'discovered');\n    }\n  }\n\n  // 3. Add convention-based implementations\n  if (opts.includeConvention) {\n    const outputDir = opts.outputDir ?? config.outputDir ?? './src';\n    const conventionPaths = getConventionPaths(specType, specKey, outputDir);\n\n    for (const { path, type } of conventionPaths) {\n      await addImpl(path, type, 'convention');\n    }\n  }\n\n  // Determine overall status\n  const status = determineStatus(implementations);\n\n  return {\n    specKey,\n    specVersion,\n    specPath: specFile,\n    specType,\n    implementations,\n    status,\n    specHash,\n  };\n}\n\n/**\n * Resolve implementations for multiple spec files.\n */\nexport async function resolveAllImplementations(\n  specFiles: string[],\n  adapters: { fs: FsAdapter },\n  config: WorkspaceConfig,\n  options: ResolverOptions = {}\n): Promise<SpecImplementationResult[]> {\n  const results: SpecImplementationResult[] = [];\n\n  for (const specFile of specFiles) {\n    try {\n      const result = await resolveImplementations(\n        specFile,\n        adapters,\n        config,\n        options\n      );\n      results.push(result);\n    } catch (error) {\n      // Log error but continue with other specs\n      console.error(\n        `Failed to resolve implementations for ${specFile}:`,\n        error\n      );\n    }\n  }\n\n  return results;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA+BA,MAAM,kBAAmC;CACvC,iBAAiB;CACjB,mBAAmB;CACnB,mBAAmB;CACnB,eAAe;CAChB;;;;AAKD,SAAS,YAAY,SAAyB;AAC5C,QAAO,WAAW,SAAS,CAAC,OAAO,QAAQ,CAAC,OAAO,MAAM;;;;;AAM3D,eAAsB,uBACpB,UACA,UACA,QACA,UAA2B,EAAE,EACM;CACnC,MAAM,OAAO;EAAE,GAAG;EAAiB,GAAG;EAAS;CAC/C,MAAM,EAAE,OAAO;AAIf,KAAI,CADe,MAAM,GAAG,OAAO,SAAS,CAE1C,OAAM,IAAI,MAAM,wBAAwB,WAAW;CAGrD,MAAM,cAAc,MAAM,GAAG,SAAS,SAAS;CAC/C,MAAM,WAAW,KAAK,gBAAgB,YAAY,YAAY,GAAG;CACjE,MAAM,OAAO,eAAe,aAAa,SAAS;CAElD,MAAM,UAAU,KAAK,OAAO,KAAK,SAAS,SAAS,CAAC,QAAQ,YAAY,GAAG;CAC3E,MAAM,cAAc,KAAK,WAAW;CACpC,MAAM,WAAW,KAAK,YAAY;CAElC,MAAM,kBAA4C,EAAE;CACpD,MAAM,4BAAY,IAAI,KAAa;CAGnC,MAAM,UAAU,OACd,QACA,MACA,QACA,gBACG;AACH,MAAI,UAAU,IAAIA,OAAK,CAAE;AACzB,YAAU,IAAIA,OAAK;EAEnB,MAAM,SAAS,MAAM,GAAG,OAAOA,OAAK;EACpC,IAAI;AAEJ,MAAI,UAAU,KAAK,cACjB,KAAI;AAEF,iBAAc,YADE,MAAM,GAAG,SAASA,OAAK,CACL;UAC5B;AAKV,kBAAgB,KAAK;GACnB;GACA;GACA;GACA;GACA;GACA;GACD,CAAC;;AAIJ,KAAI,KAAK,iBAAiB;EAExB,MAAM,gBAAgB,6BAA6B,YAAY;AAC/D,OAAK,MAAM,QAAQ,cACjB,OAAM,QAAQ,KAAK,MAAM,KAAK,MAAM,YAAY,KAAK,YAAY;;AAKrE,KAAI,KAAK,mBAAmB;EAC1B,MAAM,aAAa,MAAM,+BACvB,SACA,UACA,KACD;EAGD,MAAM,kBAAkB,mBAAmB,QAAQ;AACnD,OAAK,MAAM,WAAW,iBAAiB;GACrC,MAAM,oBAAoB,MAAM,+BAC9B,SACA,UACA,KACD;AACD,cAAW,KAAK,GAAG,kBAAkB;;AAGvC,OAAK,MAAM,OAAO,YAAY;AAE5B,OAAI,IAAI,aAAa,SAAU;AAE/B,SAAM,QAAQ,IAAI,UAAU,IAAI,cAAc,aAAa;;;AAK/D,KAAI,KAAK,mBAAmB;EAE1B,MAAM,kBAAkB,mBAAmB,UAAU,SADnC,KAAK,aAAa,OAAO,aAAa,QACgB;AAExE,OAAK,MAAM,EAAE,cAAM,UAAU,gBAC3B,OAAM,QAAQA,QAAM,MAAM,aAAa;;AAO3C,QAAO;EACL;EACA;EACA,UAAU;EACV;EACA;EACA,QARa,gBAAgB,gBAAgB;EAS7C;EACD;;;;;AAMH,eAAsB,0BACpB,WACA,UACA,QACA,UAA2B,EAAE,EACQ;CACrC,MAAM,UAAsC,EAAE;AAE9C,MAAK,MAAM,YAAY,UACrB,KAAI;EACF,MAAM,SAAS,MAAM,uBACnB,UACA,UACA,QACA,QACD;AACD,UAAQ,KAAK,OAAO;UACb,OAAO;AAEd,UAAQ,MACN,yCAAyC,SAAS,IAClD,MACD;;AAIL,QAAO"}

package/dist/services/implementation/resolver/parsers.d.mts

@@ -0,0 +1,16 @@
+import { ImplementationRef } from "@contractspec/lib.contracts";
+
+//#region src/services/implementation/resolver/parsers.d.ts
+
+/**
+ * Parse explicit implementations from spec source code using ts-morph.
+ * Looks for: implementations: [{ path: '...', type: '...' }] inside the main spec object.
+ */
+declare function parseExplicitImplementations(code: string): ImplementationRef[];
+/**
+ * Get common variants of a spec key for discovery.
+ */
+declare function getSpecKeyVariants(specKey: string): string[];
+//#endregion
+export { getSpecKeyVariants, parseExplicitImplementations };
+//# sourceMappingURL=parsers.d.mts.map

package/dist/services/implementation/resolver/parsers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers.d.mts","names":[],"sources":["../../../../src/services/implementation/resolver/parsers.ts"],"sourcesContent":[],"mappings":";;;;AAqIA;;;;iBAvHgB,4BAAA,gBAEb;;;;iBAqHa,kBAAA"}

package/dist/services/implementation/resolver/parsers.mjs

@@ -0,0 +1,100 @@
+import { Node, Project, SyntaxKind } from "ts-morph";
+
+//#region src/services/implementation/resolver/parsers.ts
+/**
+* Parse explicit implementations from spec source code using ts-morph.
+* Looks for: implementations: [{ path: '...', type: '...' }] inside the main spec object.
+*/
+function parseExplicitImplementations(code) {
+	const implementations = [];
+	const sourceFile = new Project({ useInMemoryFileSystem: true }).createSourceFile("spec.ts", code);
+	const extractImpls = (obj) => {
+		if (!Node.isObjectLiteralExpression(obj)) return;
+		const prop = obj.getProperty("implementations");
+		if (prop && Node.isPropertyAssignment(prop)) {
+			const init = prop.getInitializer();
+			if (init && Node.isArrayLiteralExpression(init)) {
+				for (const elem of init.getElements()) if (Node.isObjectLiteralExpression(elem)) {
+					let pathVal;
+					let typeVal;
+					let descVal;
+					const pathProp = elem.getProperty("path");
+					if (pathProp && Node.isPropertyAssignment(pathProp)) {
+						const init$1 = pathProp.getInitializer();
+						if (Node.isStringLiteral(init$1)) pathVal = init$1.getLiteralText();
+					}
+					const typeProp = elem.getProperty("type");
+					if (typeProp && Node.isPropertyAssignment(typeProp)) {
+						const init$1 = typeProp.getInitializer();
+						if (Node.isStringLiteral(init$1)) typeVal = init$1.getLiteralText();
+					}
+					const descProp = elem.getProperty("description");
+					if (descProp && Node.isPropertyAssignment(descProp)) {
+						const init$1 = descProp.getInitializer();
+						if (Node.isStringLiteral(init$1)) descVal = init$1.getLiteralText();
+					}
+					if (pathVal && typeVal) implementations.push({
+						path: pathVal,
+						type: typeVal,
+						description: descVal
+					});
+				}
+			}
+		}
+	};
+	const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+	for (const call of callExpressions) {
+		const expr = call.getExpression().getText();
+		if ([
+			"defineCommand",
+			"defineQuery",
+			"defineEvent",
+			"defineFeature"
+		].includes(expr)) {
+			const args = call.getArguments();
+			if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+				extractImpls(args[0]);
+				return implementations;
+			}
+		}
+	}
+	const varStmts = sourceFile.getVariableStatements();
+	for (const stmt of varStmts) if (stmt.isExported()) for (const decl of stmt.getDeclarations()) {
+		const init = decl.getInitializer();
+		if (init && Node.isObjectLiteralExpression(init)) {
+			if (init.getProperty("implementations")) {
+				extractImpls(init);
+				return implementations;
+			}
+		}
+	}
+	const exportAssign = sourceFile.getExportAssignment((d) => !d.isExportEquals());
+	if (exportAssign) {
+		const expr = exportAssign.getExpression();
+		if (Node.isObjectLiteralExpression(expr)) extractImpls(expr);
+		else if (Node.isAsExpression(expr) && Node.isObjectLiteralExpression(expr.getExpression())) extractImpls(expr.getExpression());
+	}
+	return implementations;
+}
+/**
+* Get common variants of a spec key for discovery.
+*/
+function getSpecKeyVariants(specKey) {
+	const variants = [];
+	const base = specKey.replace(/Spec$/, "").replace(/Contract$/, "").replace(/Command$/, "").replace(/Query$/, "");
+	if (base !== specKey) {
+		variants.push(base);
+		variants.push(`${base}Spec`);
+		variants.push(`${base}Contract`);
+	}
+	const parts = specKey.split(".");
+	if (parts.length > 1) {
+		const pascalName = parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+		variants.push(pascalName);
+	}
+	return variants;
+}
+
+//#endregion
+export { getSpecKeyVariants, parseExplicitImplementations };
+//# sourceMappingURL=parsers.mjs.map