@contractspec/bundle.workspace 1.44.0

package/dist/services/validate-implementation.js

@@ -0,0 +1,64 @@
+import { scanSpecSource } from "@contractspec/module.workspace";
+
+//#region src/services/validate-implementation.ts
+function toKebabCase(value) {
+	return value.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toPascalCase(value) {
+	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+async function validateImplementationFiles(specFile, adapters, config, options = {}) {
+	const { fs } = adapters;
+	const errors = [];
+	const warnings = [];
+	if (!await fs.exists(specFile)) return {
+		valid: false,
+		errors: [`Spec file not found: ${specFile}`],
+		warnings: [],
+		expected: {}
+	};
+	const scan = scanSpecSource(await fs.readFile(specFile), specFile);
+	const specName = scan.key ?? fs.basename(specFile).replace(/\.[jt]s$/, "");
+	const outRoot = options.outputDir ?? config.outputDir ?? "./src";
+	const kebab = toKebabCase(specName);
+	const expected = {};
+	if (scan.specType === "operation") {
+		expected.handlerPath = fs.join(outRoot, "handlers", `${kebab}.handler.ts`);
+		expected.handlerTestPath = fs.join(outRoot, "handlers", `${kebab}.handler.test.ts`);
+	}
+	if (scan.specType === "presentation") {
+		expected.componentPath = fs.join(outRoot, "components", `${kebab}.tsx`);
+		expected.componentTestPath = fs.join(outRoot, "components", `${kebab}.test.tsx`);
+	}
+	if (scan.specType === "form") {
+		expected.formPath = fs.join(outRoot, "forms", `${kebab}.form.tsx`);
+		expected.formTestPath = fs.join(outRoot, "forms", `${kebab}.form.test.tsx`);
+	}
+	if (options.checkHandlers && expected.handlerPath) if (!await fs.exists(expected.handlerPath)) errors.push(`Missing handler file: ${expected.handlerPath}`);
+	else {
+		const handlerCode = await fs.readFile(expected.handlerPath);
+		const expectedSpecVar = `${toPascalCase(specName.split(".").pop() ?? specName)}Spec`;
+		const hasContractHandlerType = /ContractHandler<\s*typeof\s+\w+\s*>/.test(handlerCode);
+		const referencesExpectedSpec = (/* @__PURE__ */ new RegExp(`typeof\\s+${expectedSpecVar}\\b`)).test(handlerCode);
+		if (!hasContractHandlerType) warnings.push(`Handler does not appear to type itself as ContractHandler<typeof Spec>: ${expected.handlerPath}`);
+		else if (!referencesExpectedSpec) warnings.push(`Handler ContractHandler typing does not reference expected spec var (${expectedSpecVar}): ${expected.handlerPath}`);
+	}
+	if (options.checkTests) {
+		const candidateTests = [
+			expected.handlerTestPath,
+			expected.componentTestPath,
+			expected.formTestPath
+		].filter((p) => typeof p === "string");
+		for (const testPath of candidateTests) if (!await fs.exists(testPath)) errors.push(`Missing test file: ${testPath}`);
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings,
+		expected
+	};
+}
+
+//#endregion
+export { validateImplementationFiles };
+//# sourceMappingURL=validate-implementation.js.map

package/dist/services/validate-implementation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-implementation.js","names":["errors: string[]","warnings: string[]","expected: ValidateImplementationResult['expected']"],"sources":["../../src/services/validate-implementation.ts"],"sourcesContent":["/**\n * Implementation validation service (handlers + tests).\n *\n * Deterministic, static checks intended for reuse across CLI/VSCode/web tooling.\n * This does NOT execute spec modules.\n */\n\nimport type { WorkspaceConfig } from '@contractspec/module.workspace';\nimport { scanSpecSource } from '@contractspec/module.workspace';\nimport type { FsAdapter } from '../ports/fs';\n\nexport interface ValidateImplementationOptions {\n  checkHandlers?: boolean;\n  checkTests?: boolean;\n  /**\n   * Override workspace outputDir (defaults to config.outputDir).\n   */\n  outputDir?: string;\n}\n\nexport interface ValidateImplementationResult {\n  valid: boolean;\n  errors: string[];\n  warnings: string[];\n  expected: {\n    handlerPath?: string;\n    handlerTestPath?: string;\n    componentPath?: string;\n    componentTestPath?: string;\n    formPath?: string;\n    formTestPath?: string;\n  };\n}\n\nfunction toKebabCase(value: string): string {\n  return value\n    .replace(/\\./g, '-')\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .toLowerCase();\n}\n\nfunction toPascalCase(value: string): string {\n  return value\n    .split(/[-_.]/)\n    .filter(Boolean)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))\n    .join('');\n}\n\nexport async function validateImplementationFiles(\n  specFile: string,\n  adapters: { fs: FsAdapter },\n  config: WorkspaceConfig,\n  options: ValidateImplementationOptions = {}\n): Promise<ValidateImplementationResult> {\n  const { fs } = adapters;\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  const exists = await fs.exists(specFile);\n  if (!exists) {\n    return {\n      valid: false,\n      errors: [`Spec file not found: ${specFile}`],\n      warnings: [],\n      expected: {},\n    };\n  }\n\n  const code = await fs.readFile(specFile);\n  const scan = scanSpecSource(code, specFile);\n  const specName = scan.key ?? fs.basename(specFile).replace(/\\.[jt]s$/, '');\n  const outRoot = options.outputDir ?? config.outputDir ?? './src';\n  const kebab = toKebabCase(specName);\n\n  const expected: ValidateImplementationResult['expected'] = {};\n\n  if (scan.specType === 'operation') {\n    expected.handlerPath = fs.join(outRoot, 'handlers', `${kebab}.handler.ts`);\n    expected.handlerTestPath = fs.join(\n      outRoot,\n      'handlers',\n      `${kebab}.handler.test.ts`\n    );\n  }\n  if (scan.specType === 'presentation') {\n    expected.componentPath = fs.join(outRoot, 'components', `${kebab}.tsx`);\n    expected.componentTestPath = fs.join(\n      outRoot,\n      'components',\n      `${kebab}.test.tsx`\n    );\n  }\n  if (scan.specType === 'form') {\n    expected.formPath = fs.join(outRoot, 'forms', `${kebab}.form.tsx`);\n    expected.formTestPath = fs.join(outRoot, 'forms', `${kebab}.form.test.tsx`);\n  }\n\n  if (options.checkHandlers && expected.handlerPath) {\n    const handlerExists = await fs.exists(expected.handlerPath);\n    if (!handlerExists) {\n      errors.push(`Missing handler file: ${expected.handlerPath}`);\n    } else {\n      const handlerCode = await fs.readFile(expected.handlerPath);\n\n      const expectedSpecVar = `${toPascalCase(specName.split('.').pop() ?? specName)}Spec`;\n      const hasContractHandlerType = /ContractHandler<\\s*typeof\\s+\\w+\\s*>/.test(\n        handlerCode\n      );\n      const referencesExpectedSpec = new RegExp(\n        `typeof\\\\s+${expectedSpecVar}\\\\b`\n      ).test(handlerCode);\n      if (!hasContractHandlerType) {\n        warnings.push(\n          `Handler does not appear to type itself as ContractHandler<typeof Spec>: ${expected.handlerPath}`\n        );\n      } else if (!referencesExpectedSpec) {\n        warnings.push(\n          `Handler ContractHandler typing does not reference expected spec var (${expectedSpecVar}): ${expected.handlerPath}`\n        );\n      }\n    }\n  }\n\n  if (options.checkTests) {\n    const candidateTests = [\n      expected.handlerTestPath,\n      expected.componentTestPath,\n      expected.formTestPath,\n    ].filter((p): p is string => typeof p === 'string');\n\n    for (const testPath of candidateTests) {\n      const testExists = await fs.exists(testPath);\n      if (!testExists) {\n        errors.push(`Missing test file: ${testPath}`);\n      }\n    }\n  }\n\n  return {\n    valid: errors.length === 0,\n    errors,\n    warnings,\n    expected,\n  };\n}\n"],"mappings":";;;AAkCA,SAAS,YAAY,OAAuB;AAC1C,QAAO,MACJ,QAAQ,OAAO,IAAI,CACnB,QAAQ,mBAAmB,QAAQ,CACnC,aAAa;;AAGlB,SAAS,aAAa,OAAuB;AAC3C,QAAO,MACJ,MAAM,QAAQ,CACd,OAAO,QAAQ,CACf,KAAK,SAAS,KAAK,OAAO,EAAE,CAAC,aAAa,GAAG,KAAK,MAAM,EAAE,CAAC,CAC3D,KAAK,GAAG;;AAGb,eAAsB,4BACpB,UACA,UACA,QACA,UAAyC,EAAE,EACJ;CACvC,MAAM,EAAE,OAAO;CACf,MAAMA,SAAmB,EAAE;CAC3B,MAAMC,WAAqB,EAAE;AAG7B,KAAI,CADW,MAAM,GAAG,OAAO,SAAS,CAEtC,QAAO;EACL,OAAO;EACP,QAAQ,CAAC,wBAAwB,WAAW;EAC5C,UAAU,EAAE;EACZ,UAAU,EAAE;EACb;CAIH,MAAM,OAAO,eADA,MAAM,GAAG,SAAS,SAAS,EACN,SAAS;CAC3C,MAAM,WAAW,KAAK,OAAO,GAAG,SAAS,SAAS,CAAC,QAAQ,YAAY,GAAG;CAC1E,MAAM,UAAU,QAAQ,aAAa,OAAO,aAAa;CACzD,MAAM,QAAQ,YAAY,SAAS;CAEnC,MAAMC,WAAqD,EAAE;AAE7D,KAAI,KAAK,aAAa,aAAa;AACjC,WAAS,cAAc,GAAG,KAAK,SAAS,YAAY,GAAG,MAAM,aAAa;AAC1E,WAAS,kBAAkB,GAAG,KAC5B,SACA,YACA,GAAG,MAAM,kBACV;;AAEH,KAAI,KAAK,aAAa,gBAAgB;AACpC,WAAS,gBAAgB,GAAG,KAAK,SAAS,cAAc,GAAG,MAAM,MAAM;AACvE,WAAS,oBAAoB,GAAG,KAC9B,SACA,cACA,GAAG,MAAM,WACV;;AAEH,KAAI,KAAK,aAAa,QAAQ;AAC5B,WAAS,WAAW,GAAG,KAAK,SAAS,SAAS,GAAG,MAAM,WAAW;AAClE,WAAS,eAAe,GAAG,KAAK,SAAS,SAAS,GAAG,MAAM,gBAAgB;;AAG7E,KAAI,QAAQ,iBAAiB,SAAS,YAEpC,KAAI,CADkB,MAAM,GAAG,OAAO,SAAS,YAAY,CAEzD,QAAO,KAAK,yBAAyB,SAAS,cAAc;MACvD;EACL,MAAM,cAAc,MAAM,GAAG,SAAS,SAAS,YAAY;EAE3D,MAAM,kBAAkB,GAAG,aAAa,SAAS,MAAM,IAAI,CAAC,KAAK,IAAI,SAAS,CAAC;EAC/E,MAAM,yBAAyB,sCAAsC,KACnE,YACD;EACD,MAAM,0CAAyB,IAAI,OACjC,aAAa,gBAAgB,KAC9B,EAAC,KAAK,YAAY;AACnB,MAAI,CAAC,uBACH,UAAS,KACP,2EAA2E,SAAS,cACrF;WACQ,CAAC,uBACV,UAAS,KACP,wEAAwE,gBAAgB,KAAK,SAAS,cACvG;;AAKP,KAAI,QAAQ,YAAY;EACtB,MAAM,iBAAiB;GACrB,SAAS;GACT,SAAS;GACT,SAAS;GACV,CAAC,QAAQ,MAAmB,OAAO,MAAM,SAAS;AAEnD,OAAK,MAAM,YAAY,eAErB,KAAI,CADe,MAAM,GAAG,OAAO,SAAS,CAE1C,QAAO,KAAK,sBAAsB,WAAW;;AAKnD,QAAO;EACL,OAAO,OAAO,WAAW;EACzB;EACA;EACA;EACD"}

package/dist/services/validate.d.ts

@@ -0,0 +1,41 @@
+import { FsAdapter } from "../ports/fs.js";
+import { LoggerAdapter } from "../ports/logger.js";
+import { ValidationResult } from "@contractspec/module.workspace";
+
+//#region src/services/validate.d.ts
+
+/**
+ * Options for spec validation.
+ */
+interface ValidateSpecOptions {
+  /**
+   * Skip spec structure validation (e.g., for blueprint files).
+   */
+  skipStructure?: boolean;
+}
+/**
+ * Result of spec validation.
+ */
+interface ValidateSpecResult {
+  valid: boolean;
+  structureResult?: ValidationResult;
+  errors: string[];
+  warnings: string[];
+}
+/**
+ * Validate a spec file.
+ */
+declare function validateSpec(specFile: string, adapters: {
+  fs: FsAdapter;
+  logger: LoggerAdapter;
+}, options?: ValidateSpecOptions): Promise<ValidateSpecResult>;
+/**
+ * Validate multiple spec files.
+ */
+declare function validateSpecs(specFiles: string[], adapters: {
+  fs: FsAdapter;
+  logger: LoggerAdapter;
+}, options?: ValidateSpecOptions): Promise<Map<string, ValidateSpecResult>>;
+//#endregion
+export { ValidateSpecOptions, ValidateSpecResult, validateSpec, validateSpecs };
+//# sourceMappingURL=validate.d.ts.map

package/dist/services/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","names":[],"sources":["../../src/services/validate.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;AAUA;;AAEqC,UAtBpB,mBAAA,CAsBoB;EAC1B;;;EACD,aAAA,CAAA,EAAA,OAAA;AAoCV;;;;AAIuB,UAtDN,kBAAA,CAsDM;EAAZ,KAAA,EAAA,OAAA;EAAR,eAAA,CAAA,EApDiB,gBAoDjB;EAAO,MAAA,EAAA,MAAA,EAAA;;;;;;iBA5CY,YAAA;MAEJ;UAAmB;aAC1B,sBACR,QAAQ;;;;iBAoCW,aAAA;MAEJ;UAAmB;aAC1B,sBACR,QAAQ,YAAY"}

package/dist/services/validate.js

@@ -0,0 +1,48 @@
+import { validateSpecStructure } from "@contractspec/module.workspace";
+
+//#region src/services/validate.ts
+/**
+* Validation service.
+*/
+/**
+* Validate a spec file.
+*/
+async function validateSpec(specFile, adapters, options = {}) {
+	const { fs } = adapters;
+	if (!await fs.exists(specFile)) return {
+		valid: false,
+		errors: [`Spec file not found: ${specFile}`],
+		warnings: []
+	};
+	const specCode = await fs.readFile(specFile);
+	const fileName = fs.basename(specFile);
+	const allErrors = [];
+	const allWarnings = [];
+	let structureResult;
+	if (!options.skipStructure) {
+		structureResult = validateSpecStructure(specCode, fileName);
+		allErrors.push(...structureResult.errors);
+		allWarnings.push(...structureResult.warnings);
+	}
+	return {
+		valid: allErrors.length === 0,
+		structureResult,
+		errors: allErrors,
+		warnings: allWarnings
+	};
+}
+/**
+* Validate multiple spec files.
+*/
+async function validateSpecs(specFiles, adapters, options = {}) {
+	const results = /* @__PURE__ */ new Map();
+	for (const specFile of specFiles) {
+		const result = await validateSpec(specFile, adapters, options);
+		results.set(specFile, result);
+	}
+	return results;
+}
+
+//#endregion
+export { validateSpec, validateSpecs };
+//# sourceMappingURL=validate.js.map

package/dist/services/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","names":["allErrors: string[]","allWarnings: string[]","structureResult: ValidationResult | undefined"],"sources":["../../src/services/validate.ts"],"sourcesContent":["/**\n * Validation service.\n */\n\nimport {\n  validateSpecStructure,\n  type ValidationResult,\n} from '@contractspec/module.workspace';\nimport type { FsAdapter } from '../ports/fs';\nimport type { LoggerAdapter } from '../ports/logger';\n\n/**\n * Options for spec validation.\n */\nexport interface ValidateSpecOptions {\n  /**\n   * Skip spec structure validation (e.g., for blueprint files).\n   */\n  skipStructure?: boolean;\n}\n\n/**\n * Result of spec validation.\n */\nexport interface ValidateSpecResult {\n  valid: boolean;\n  structureResult?: ValidationResult;\n  errors: string[];\n  warnings: string[];\n}\n\n/**\n * Validate a spec file.\n */\nexport async function validateSpec(\n  specFile: string,\n  adapters: { fs: FsAdapter; logger: LoggerAdapter },\n  options: ValidateSpecOptions = {}\n): Promise<ValidateSpecResult> {\n  const { fs } = adapters;\n\n  const exists = await fs.exists(specFile);\n  if (!exists) {\n    return {\n      valid: false,\n      errors: [`Spec file not found: ${specFile}`],\n      warnings: [],\n    };\n  }\n\n  const specCode = await fs.readFile(specFile);\n  const fileName = fs.basename(specFile);\n\n  const allErrors: string[] = [];\n  const allWarnings: string[] = [];\n  let structureResult: ValidationResult | undefined;\n\n  if (!options.skipStructure) {\n    structureResult = validateSpecStructure(specCode, fileName);\n    allErrors.push(...structureResult.errors);\n    allWarnings.push(...structureResult.warnings);\n  }\n\n  return {\n    valid: allErrors.length === 0,\n    structureResult,\n    errors: allErrors,\n    warnings: allWarnings,\n  };\n}\n\n/**\n * Validate multiple spec files.\n */\nexport async function validateSpecs(\n  specFiles: string[],\n  adapters: { fs: FsAdapter; logger: LoggerAdapter },\n  options: ValidateSpecOptions = {}\n): Promise<Map<string, ValidateSpecResult>> {\n  const results = new Map<string, ValidateSpecResult>();\n\n  for (const specFile of specFiles) {\n    const result = await validateSpec(specFile, adapters, options);\n    results.set(specFile, result);\n  }\n\n  return results;\n}\n"],"mappings":";;;;;;;;;AAkCA,eAAsB,aACpB,UACA,UACA,UAA+B,EAAE,EACJ;CAC7B,MAAM,EAAE,OAAO;AAGf,KAAI,CADW,MAAM,GAAG,OAAO,SAAS,CAEtC,QAAO;EACL,OAAO;EACP,QAAQ,CAAC,wBAAwB,WAAW;EAC5C,UAAU,EAAE;EACb;CAGH,MAAM,WAAW,MAAM,GAAG,SAAS,SAAS;CAC5C,MAAM,WAAW,GAAG,SAAS,SAAS;CAEtC,MAAMA,YAAsB,EAAE;CAC9B,MAAMC,cAAwB,EAAE;CAChC,IAAIC;AAEJ,KAAI,CAAC,QAAQ,eAAe;AAC1B,oBAAkB,sBAAsB,UAAU,SAAS;AAC3D,YAAU,KAAK,GAAG,gBAAgB,OAAO;AACzC,cAAY,KAAK,GAAG,gBAAgB,SAAS;;AAG/C,QAAO;EACL,OAAO,UAAU,WAAW;EAC5B;EACA,QAAQ;EACR,UAAU;EACX;;;;;AAMH,eAAsB,cACpB,WACA,UACA,UAA+B,EAAE,EACS;CAC1C,MAAM,0BAAU,IAAI,KAAiC;AAErD,MAAK,MAAM,YAAY,WAAW;EAChC,MAAM,SAAS,MAAM,aAAa,UAAU,UAAU,QAAQ;AAC9D,UAAQ,IAAI,UAAU,OAAO;;AAG/B,QAAO"}

package/dist/services/verification-cache/adapters/filesystem.d.ts

@@ -0,0 +1,46 @@
+import { CacheKeyString, CacheStorageAdapter, VerificationCacheEntry } from "../types.js";
+
+//#region src/services/verification-cache/adapters/filesystem.d.ts
+
+/**
+ * Filesystem storage adapter.
+ */
+declare class FileSystemCacheStorage implements CacheStorageAdapter {
+  private filePath;
+  private cache;
+  private isDirty;
+  constructor(filePath?: string, workspaceRoot?: string);
+  /**
+   * Load cache from disk synchronously.
+   */
+  private loadSync;
+  /**
+   * Save cache to disk.
+   */
+  private saveSync;
+  get(key: CacheKeyString): Promise<VerificationCacheEntry | null>;
+  set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void>;
+  delete(key: CacheKeyString): Promise<boolean>;
+  has(key: CacheKeyString): Promise<boolean>;
+  keys(): Promise<CacheKeyString[]>;
+  clear(): Promise<void>;
+  stats(): Promise<{
+    entryCount: number;
+    memoryUsage?: number;
+  }>;
+  /**
+   * Force save any pending changes.
+   */
+  flush(): void;
+  /**
+   * Reload cache from disk.
+   */
+  reload(): void;
+}
+/**
+ * Create a filesystem cache storage adapter.
+ */
+declare function createFileSystemCacheStorage(filePath?: string, workspaceRoot?: string): FileSystemCacheStorage;
+//#endregion
+export { FileSystemCacheStorage, createFileSystemCacheStorage };
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/services/verification-cache/adapters/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","names":[],"sources":["../../../../src/services/verification-cache/adapters/filesystem.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwHoB,cAhFP,sBAAA,YAAkC,mBAgF3B,CAAA;EAAiB,QAAA,QAAA;EASpB,QAAA,KAAA;EAAiB,QAAA,OAAA;EAIV,WAAA,CAAA,QAAA,CAAA,EAAA,MAAA,EAAA,aAAA,CAAA,EAAA,MAAA;EAAR;;;EA7F+B,QAAA,QAAA;EAAmB;AA4IlE;;;WAtEiB,iBAAiB,QAAQ;WAIzB,uBAAuB,yBAAyB;cAM7C,iBAAiB;WASpB,iBAAiB;UAIlB,QAAQ;WAIP;WAMA;;;;;;;;;;;;;;;;iBAqCD,4BAAA,6CAGb"}

package/dist/services/verification-cache/adapters/filesystem.js

@@ -0,0 +1,120 @@
+import { dirname, join } from "path";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+
+//#region src/services/verification-cache/adapters/filesystem.ts
+/**
+* Filesystem cache storage adapter.
+*
+* Stores cache entries in a JSON file for CLI and CI environments.
+* Uses atomic writes to prevent corruption.
+*/
+/**
+* Default cache file location.
+*/
+const DEFAULT_CACHE_FILE = ".contractspec/verification-cache.json";
+const CURRENT_VERSION = 1;
+/**
+* Filesystem storage adapter.
+*/
+var FileSystemCacheStorage = class {
+	filePath;
+	cache;
+	isDirty = false;
+	constructor(filePath, workspaceRoot) {
+		const root = workspaceRoot ?? process.cwd();
+		this.filePath = filePath ?? join(root, DEFAULT_CACHE_FILE);
+		this.cache = /* @__PURE__ */ new Map();
+		this.loadSync();
+	}
+	/**
+	* Load cache from disk synchronously.
+	*/
+	loadSync() {
+		try {
+			if (!existsSync(this.filePath)) return;
+			const content = readFileSync(this.filePath, "utf-8");
+			const data = JSON.parse(content);
+			if (data.version !== CURRENT_VERSION) return;
+			for (const [key, entry] of Object.entries(data.entries)) this.cache.set(key, entry);
+		} catch {}
+	}
+	/**
+	* Save cache to disk.
+	*/
+	saveSync() {
+		if (!this.isDirty) return;
+		try {
+			const dir = dirname(this.filePath);
+			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+			const data = {
+				version: CURRENT_VERSION,
+				entries: Object.fromEntries(this.cache.entries())
+			};
+			const tempPath = `${this.filePath}.tmp`;
+			writeFileSync(tempPath, JSON.stringify(data, null, 2), "utf-8");
+			renameSync(tempPath, this.filePath);
+			this.isDirty = false;
+		} catch {}
+	}
+	async get(key) {
+		return this.cache.get(key) ?? null;
+	}
+	async set(key, entry) {
+		this.cache.set(key, entry);
+		this.isDirty = true;
+		this.saveSync();
+	}
+	async delete(key) {
+		const existed = this.cache.delete(key);
+		if (existed) {
+			this.isDirty = true;
+			this.saveSync();
+		}
+		return existed;
+	}
+	async has(key) {
+		return this.cache.has(key);
+	}
+	async keys() {
+		return Array.from(this.cache.keys());
+	}
+	async clear() {
+		this.cache.clear();
+		this.isDirty = true;
+		this.saveSync();
+	}
+	async stats() {
+		let fileSize = 0;
+		try {
+			if (existsSync(this.filePath)) fileSize = statSync(this.filePath).size;
+		} catch {}
+		return {
+			entryCount: this.cache.size,
+			memoryUsage: fileSize
+		};
+	}
+	/**
+	* Force save any pending changes.
+	*/
+	flush() {
+		this.saveSync();
+	}
+	/**
+	* Reload cache from disk.
+	*/
+	reload() {
+		this.cache.clear();
+		this.loadSync();
+		this.isDirty = false;
+	}
+};
+/**
+* Create a filesystem cache storage adapter.
+*/
+function createFileSystemCacheStorage(filePath, workspaceRoot) {
+	return new FileSystemCacheStorage(filePath, workspaceRoot);
+}
+
+//#endregion
+export { FileSystemCacheStorage, createFileSystemCacheStorage };
+//# sourceMappingURL=filesystem.js.map

package/dist/services/verification-cache/adapters/filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.js","names":["data: CacheFileData"],"sources":["../../../../src/services/verification-cache/adapters/filesystem.ts"],"sourcesContent":["/**\n * Filesystem cache storage adapter.\n *\n * Stores cache entries in a JSON file for CLI and CI environments.\n * Uses atomic writes to prevent corruption.\n */\n\nimport {\n  existsSync,\n  mkdirSync,\n  readFileSync,\n  writeFileSync,\n  statSync,\n  renameSync,\n} from 'fs';\nimport { dirname, join } from 'path';\nimport type {\n  CacheKeyString,\n  CacheStorageAdapter,\n  VerificationCacheEntry,\n} from '../types';\n\n/**\n * Default cache file location.\n */\nconst DEFAULT_CACHE_FILE = '.contractspec/verification-cache.json';\n\n/**\n * Cache file structure.\n */\ninterface CacheFileData {\n  version: number;\n  entries: Record<CacheKeyString, VerificationCacheEntry>;\n}\n\nconst CURRENT_VERSION = 1;\n\n/**\n * Filesystem storage adapter.\n */\nexport class FileSystemCacheStorage implements CacheStorageAdapter {\n  private filePath: string;\n  private cache: Map<CacheKeyString, VerificationCacheEntry>;\n  private isDirty = false;\n\n  constructor(filePath?: string, workspaceRoot?: string) {\n    const root = workspaceRoot ?? process.cwd();\n    this.filePath = filePath ?? join(root, DEFAULT_CACHE_FILE);\n    this.cache = new Map();\n    this.loadSync();\n  }\n\n  /**\n   * Load cache from disk synchronously.\n   */\n  private loadSync(): void {\n    try {\n      if (!existsSync(this.filePath)) {\n        return;\n      }\n\n      const content = readFileSync(this.filePath, 'utf-8');\n      const data = JSON.parse(content) as CacheFileData;\n\n      // Version check\n      if (data.version !== CURRENT_VERSION) {\n        // Incompatible version, start fresh\n        return;\n      }\n\n      // Load entries\n      for (const [key, entry] of Object.entries(data.entries)) {\n        this.cache.set(key, entry);\n      }\n    } catch {\n      // Ignore load errors, start with empty cache\n    }\n  }\n\n  /**\n   * Save cache to disk.\n   */\n  private saveSync(): void {\n    if (!this.isDirty) return;\n\n    try {\n      // Ensure directory exists\n      const dir = dirname(this.filePath);\n      if (!existsSync(dir)) {\n        mkdirSync(dir, { recursive: true });\n      }\n\n      const data: CacheFileData = {\n        version: CURRENT_VERSION,\n        entries: Object.fromEntries(this.cache.entries()),\n      };\n\n      // Atomic write: write to temp file, then rename\n      const tempPath = `${this.filePath}.tmp`;\n      writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');\n\n      // Rename is atomic on most filesystems\n      renameSync(tempPath, this.filePath);\n\n      this.isDirty = false;\n    } catch {\n      // Ignore save errors\n    }\n  }\n\n  async get(key: CacheKeyString): Promise<VerificationCacheEntry | null> {\n    return this.cache.get(key) ?? null;\n  }\n\n  async set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void> {\n    this.cache.set(key, entry);\n    this.isDirty = true;\n    this.saveSync();\n  }\n\n  async delete(key: CacheKeyString): Promise<boolean> {\n    const existed = this.cache.delete(key);\n    if (existed) {\n      this.isDirty = true;\n      this.saveSync();\n    }\n    return existed;\n  }\n\n  async has(key: CacheKeyString): Promise<boolean> {\n    return this.cache.has(key);\n  }\n\n  async keys(): Promise<CacheKeyString[]> {\n    return Array.from(this.cache.keys());\n  }\n\n  async clear(): Promise<void> {\n    this.cache.clear();\n    this.isDirty = true;\n    this.saveSync();\n  }\n\n  async stats(): Promise<{ entryCount: number; memoryUsage?: number }> {\n    let fileSize = 0;\n    try {\n      if (existsSync(this.filePath)) {\n        const stat = statSync(this.filePath);\n        fileSize = stat.size;\n      }\n    } catch {\n      // Ignore\n    }\n\n    return {\n      entryCount: this.cache.size,\n      memoryUsage: fileSize,\n    };\n  }\n\n  /**\n   * Force save any pending changes.\n   */\n  flush(): void {\n    this.saveSync();\n  }\n\n  /**\n   * Reload cache from disk.\n   */\n  reload(): void {\n    this.cache.clear();\n    this.loadSync();\n    this.isDirty = false;\n  }\n}\n\n/**\n * Create a filesystem cache storage adapter.\n */\nexport function createFileSystemCacheStorage(\n  filePath?: string,\n  workspaceRoot?: string\n): FileSystemCacheStorage {\n  return new FileSystemCacheStorage(filePath, workspaceRoot);\n}\n"],"mappings":";;;;;;;;;;;;;AAyBA,MAAM,qBAAqB;AAU3B,MAAM,kBAAkB;;;;AAKxB,IAAa,yBAAb,MAAmE;CACjE,AAAQ;CACR,AAAQ;CACR,AAAQ,UAAU;CAElB,YAAY,UAAmB,eAAwB;EACrD,MAAM,OAAO,iBAAiB,QAAQ,KAAK;AAC3C,OAAK,WAAW,YAAY,KAAK,MAAM,mBAAmB;AAC1D,OAAK,wBAAQ,IAAI,KAAK;AACtB,OAAK,UAAU;;;;;CAMjB,AAAQ,WAAiB;AACvB,MAAI;AACF,OAAI,CAAC,WAAW,KAAK,SAAS,CAC5B;GAGF,MAAM,UAAU,aAAa,KAAK,UAAU,QAAQ;GACpD,MAAM,OAAO,KAAK,MAAM,QAAQ;AAGhC,OAAI,KAAK,YAAY,gBAEnB;AAIF,QAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,QAAQ,CACrD,MAAK,MAAM,IAAI,KAAK,MAAM;UAEtB;;;;;CAQV,AAAQ,WAAiB;AACvB,MAAI,CAAC,KAAK,QAAS;AAEnB,MAAI;GAEF,MAAM,MAAM,QAAQ,KAAK,SAAS;AAClC,OAAI,CAAC,WAAW,IAAI,CAClB,WAAU,KAAK,EAAE,WAAW,MAAM,CAAC;GAGrC,MAAMA,OAAsB;IAC1B,SAAS;IACT,SAAS,OAAO,YAAY,KAAK,MAAM,SAAS,CAAC;IAClD;GAGD,MAAM,WAAW,GAAG,KAAK,SAAS;AAClC,iBAAc,UAAU,KAAK,UAAU,MAAM,MAAM,EAAE,EAAE,QAAQ;AAG/D,cAAW,UAAU,KAAK,SAAS;AAEnC,QAAK,UAAU;UACT;;CAKV,MAAM,IAAI,KAA6D;AACrE,SAAO,KAAK,MAAM,IAAI,IAAI,IAAI;;CAGhC,MAAM,IAAI,KAAqB,OAA8C;AAC3E,OAAK,MAAM,IAAI,KAAK,MAAM;AAC1B,OAAK,UAAU;AACf,OAAK,UAAU;;CAGjB,MAAM,OAAO,KAAuC;EAClD,MAAM,UAAU,KAAK,MAAM,OAAO,IAAI;AACtC,MAAI,SAAS;AACX,QAAK,UAAU;AACf,QAAK,UAAU;;AAEjB,SAAO;;CAGT,MAAM,IAAI,KAAuC;AAC/C,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,MAAM,OAAkC;AACtC,SAAO,MAAM,KAAK,KAAK,MAAM,MAAM,CAAC;;CAGtC,MAAM,QAAuB;AAC3B,OAAK,MAAM,OAAO;AAClB,OAAK,UAAU;AACf,OAAK,UAAU;;CAGjB,MAAM,QAA+D;EACnE,IAAI,WAAW;AACf,MAAI;AACF,OAAI,WAAW,KAAK,SAAS,CAE3B,YADa,SAAS,KAAK,SAAS,CACpB;UAEZ;AAIR,SAAO;GACL,YAAY,KAAK,MAAM;GACvB,aAAa;GACd;;;;;CAMH,QAAc;AACZ,OAAK,UAAU;;;;;CAMjB,SAAe;AACb,OAAK,MAAM,OAAO;AAClB,OAAK,UAAU;AACf,OAAK,UAAU;;;;;;AAOnB,SAAgB,6BACd,UACA,eACwB;AACxB,QAAO,IAAI,uBAAuB,UAAU,cAAc"}

package/dist/services/verification-cache/adapters/in-memory.d.ts

@@ -0,0 +1,27 @@
+import { CacheKeyString, CacheStorageAdapter, VerificationCacheEntry } from "../types.js";
+
+//#region src/services/verification-cache/adapters/in-memory.d.ts
+
+/**
+ * In-memory storage adapter using a Map.
+ */
+declare class InMemoryCacheStorage implements CacheStorageAdapter {
+  private cache;
+  get(key: CacheKeyString): Promise<VerificationCacheEntry | null>;
+  set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void>;
+  delete(key: CacheKeyString): Promise<boolean>;
+  has(key: CacheKeyString): Promise<boolean>;
+  keys(): Promise<CacheKeyString[]>;
+  clear(): Promise<void>;
+  stats(): Promise<{
+    entryCount: number;
+    memoryUsage?: number;
+  }>;
+}
+/**
+ * Create an in-memory cache storage adapter.
+ */
+declare function createInMemoryCacheStorage(): InMemoryCacheStorage;
+//#endregion
+export { InMemoryCacheStorage, createInMemoryCacheStorage };
+//# sourceMappingURL=in-memory.d.ts.map

package/dist/services/verification-cache/adapters/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","names":[],"sources":["../../../../src/services/verification-cache/adapters/in-memory.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2BoB,cAXP,oBAAA,YAAgC,mBAWzB,CAAA;EAAiB,QAAA,KAAA;EAIpB,GAAA,CAAA,GAAA,EAZA,cAYA,CAAA,EAZiB,OAYjB,CAZyB,sBAYzB,GAAA,IAAA,CAAA;EAAiB,GAAA,CAAA,GAAA,EARjB,cAQiB,EAAA,KAAA,EARM,sBAQN,CAAA,EAR+B,OAQ/B,CAAA,IAAA,CAAA;EAIV,MAAA,CAAA,GAAA,EARJ,cAQI,CAAA,EARa,OAQb,CAAA,OAAA,CAAA;EAAR,GAAA,CAAA,GAAA,EAJC,cAID,CAAA,EAJkB,OAIlB,CAAA,OAAA,CAAA;EAIC,IAAA,CAAA,CAAA,EAJD,OAIC,CAJO,cAIP,EAAA,CAAA;EAIA,KAAA,CAAA,CAAA,EAJA,OAIA,CAAA,IAAA,CAAA;EA3B4B,KAAA,CAAA,CAAA,EA2B5B,OA3B4B,CAAA;IAAmB,UAAA,EAAA,MAAA;IA6ChD,WAAA,CAAA,EAAA,MAAA;;;;;;iBAAA,0BAAA,CAAA,GAA8B"}

package/dist/services/verification-cache/adapters/in-memory.js

@@ -0,0 +1,46 @@
+//#region src/services/verification-cache/adapters/in-memory.ts
+/**
+* In-memory storage adapter using a Map.
+*/
+var InMemoryCacheStorage = class {
+	cache = /* @__PURE__ */ new Map();
+	async get(key) {
+		return this.cache.get(key) ?? null;
+	}
+	async set(key, entry) {
+		this.cache.set(key, entry);
+	}
+	async delete(key) {
+		return this.cache.delete(key);
+	}
+	async has(key) {
+		return this.cache.has(key);
+	}
+	async keys() {
+		return Array.from(this.cache.keys());
+	}
+	async clear() {
+		this.cache.clear();
+	}
+	async stats() {
+		let memoryUsage = 0;
+		for (const [key, value] of this.cache.entries()) {
+			memoryUsage += key.length * 2;
+			memoryUsage += JSON.stringify(value).length * 2;
+		}
+		return {
+			entryCount: this.cache.size,
+			memoryUsage
+		};
+	}
+};
+/**
+* Create an in-memory cache storage adapter.
+*/
+function createInMemoryCacheStorage() {
+	return new InMemoryCacheStorage();
+}
+
+//#endregion
+export { InMemoryCacheStorage, createInMemoryCacheStorage };
+//# sourceMappingURL=in-memory.js.map

package/dist/services/verification-cache/adapters/in-memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.js","names":[],"sources":["../../../../src/services/verification-cache/adapters/in-memory.ts"],"sourcesContent":["/**\n * In-memory cache storage adapter.\n *\n * Suitable for tests and single-process environments.\n * Data is lost on process restart.\n */\n\nimport type {\n  CacheKeyString,\n  CacheStorageAdapter,\n  VerificationCacheEntry,\n} from '../types';\n\n/**\n * In-memory storage adapter using a Map.\n */\nexport class InMemoryCacheStorage implements CacheStorageAdapter {\n  private cache = new Map<CacheKeyString, VerificationCacheEntry>();\n\n  async get(key: CacheKeyString): Promise<VerificationCacheEntry | null> {\n    return this.cache.get(key) ?? null;\n  }\n\n  async set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void> {\n    this.cache.set(key, entry);\n  }\n\n  async delete(key: CacheKeyString): Promise<boolean> {\n    return this.cache.delete(key);\n  }\n\n  async has(key: CacheKeyString): Promise<boolean> {\n    return this.cache.has(key);\n  }\n\n  async keys(): Promise<CacheKeyString[]> {\n    return Array.from(this.cache.keys());\n  }\n\n  async clear(): Promise<void> {\n    this.cache.clear();\n  }\n\n  async stats(): Promise<{ entryCount: number; memoryUsage?: number }> {\n    // Estimate memory usage (rough approximation)\n    let memoryUsage = 0;\n    for (const [key, value] of this.cache.entries()) {\n      memoryUsage += key.length * 2; // UTF-16 string\n      memoryUsage += JSON.stringify(value).length * 2;\n    }\n\n    return {\n      entryCount: this.cache.size,\n      memoryUsage,\n    };\n  }\n}\n\n/**\n * Create an in-memory cache storage adapter.\n */\nexport function createInMemoryCacheStorage(): InMemoryCacheStorage {\n  return new InMemoryCacheStorage();\n}\n"],"mappings":";;;;AAgBA,IAAa,uBAAb,MAAiE;CAC/D,AAAQ,wBAAQ,IAAI,KAA6C;CAEjE,MAAM,IAAI,KAA6D;AACrE,SAAO,KAAK,MAAM,IAAI,IAAI,IAAI;;CAGhC,MAAM,IAAI,KAAqB,OAA8C;AAC3E,OAAK,MAAM,IAAI,KAAK,MAAM;;CAG5B,MAAM,OAAO,KAAuC;AAClD,SAAO,KAAK,MAAM,OAAO,IAAI;;CAG/B,MAAM,IAAI,KAAuC;AAC/C,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,MAAM,OAAkC;AACtC,SAAO,MAAM,KAAK,KAAK,MAAM,MAAM,CAAC;;CAGtC,MAAM,QAAuB;AAC3B,OAAK,MAAM,OAAO;;CAGpB,MAAM,QAA+D;EAEnE,IAAI,cAAc;AAClB,OAAK,MAAM,CAAC,KAAK,UAAU,KAAK,MAAM,SAAS,EAAE;AAC/C,kBAAe,IAAI,SAAS;AAC5B,kBAAe,KAAK,UAAU,MAAM,CAAC,SAAS;;AAGhD,SAAO;GACL,YAAY,KAAK,MAAM;GACvB;GACD;;;;;;AAOL,SAAgB,6BAAmD;AACjE,QAAO,IAAI,sBAAsB"}

package/dist/services/verification-cache/adapters/index.d.ts

@@ -0,0 +1,3 @@
+import { InMemoryCacheStorage, createInMemoryCacheStorage } from "./in-memory.js";
+import { FileSystemCacheStorage, createFileSystemCacheStorage } from "./filesystem.js";
+import { KeyValueStore, WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage } from "./workspace-state.js";

package/dist/services/verification-cache/adapters/index.js

@@ -0,0 +1,3 @@
+import { InMemoryCacheStorage, createInMemoryCacheStorage } from "./in-memory.js";
+import { FileSystemCacheStorage, createFileSystemCacheStorage } from "./filesystem.js";
+import { WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage } from "./workspace-state.js";

package/dist/services/verification-cache/adapters/workspace-state.d.ts

@@ -0,0 +1,49 @@
+import { CacheKeyString, CacheStorageAdapter, VerificationCacheEntry } from "../types.js";
+
+//#region src/services/verification-cache/adapters/workspace-state.d.ts
+
+/**
+ * Interface for key-value store (compatible with VSCode's Memento).
+ */
+interface KeyValueStore {
+  get<T>(key: string): T | undefined;
+  update(key: string, value: unknown): Thenable<void>;
+  keys?(): readonly string[];
+}
+/**
+ * Workspace state storage adapter.
+ */
+declare class WorkspaceStateCacheStorage implements CacheStorageAdapter {
+  private store;
+  private keyIndex;
+  constructor(store: KeyValueStore);
+  /**
+   * Load the key index from storage.
+   */
+  private loadKeyIndex;
+  /**
+   * Save the key index to storage.
+   */
+  private saveKeyIndex;
+  /**
+   * Get the storage key for a cache key.
+   */
+  private getStorageKey;
+  get(key: CacheKeyString): Promise<VerificationCacheEntry | null>;
+  set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void>;
+  delete(key: CacheKeyString): Promise<boolean>;
+  has(key: CacheKeyString): Promise<boolean>;
+  keys(): Promise<CacheKeyString[]>;
+  clear(): Promise<void>;
+  stats(): Promise<{
+    entryCount: number;
+    memoryUsage?: number;
+  }>;
+}
+/**
+ * Create a workspace state cache storage adapter.
+ */
+declare function createWorkspaceStateCacheStorage(store: KeyValueStore): WorkspaceStateCacheStorage;
+//#endregion
+export { KeyValueStore, WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage };
+//# sourceMappingURL=workspace-state.d.ts.map

package/dist/services/verification-cache/adapters/workspace-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-state.d.ts","names":[],"sources":["../../../../src/services/verification-cache/adapters/workspace-state.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4EwC,UA5DvB,aAAA,CA4DuB;EAAyB,GAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EA3D1C,CA2D0C,GAAA,SAAA;EAU7C,MAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,OAAA,CAAA,EApEmB,QAoEnB,CAAA,IAAA,CAAA;EAAiB,IAAA,GAAA,EAAA,SAAA,MAAA,EAAA;;;;;AAqBpB,cAxEJ,0BAAA,YAAsC,mBAwElC,CAAA;EAYA,QAAA,KAAA;EApFkC,QAAA,QAAA;EAAmB,WAAA,CAAA,KAAA,EAIjD,aAJiD;EA8FtD;;;;;;;;;;;;WA3DC,iBAAiB,QAAQ;WAMzB,uBAAuB,yBAAyB;cAU7C,iBAAiB;WAapB,iBAAiB;UAIlB,QAAQ;WAIP;WAYA;;;;;;;;iBAUD,gCAAA,QACP,gBACN"}

package/dist/services/verification-cache/adapters/workspace-state.js

@@ -0,0 +1,91 @@
+//#region src/services/verification-cache/adapters/workspace-state.ts
+/**
+* Cache key prefix to avoid collisions.
+*/
+const CACHE_PREFIX = "contractspec.verification-cache.";
+/**
+* Index key for tracking all cache keys.
+*/
+const INDEX_KEY = `${CACHE_PREFIX}__index__`;
+/**
+* Workspace state storage adapter.
+*/
+var WorkspaceStateCacheStorage = class {
+	store;
+	keyIndex;
+	constructor(store) {
+		this.store = store;
+		this.keyIndex = new Set(this.loadKeyIndex());
+	}
+	/**
+	* Load the key index from storage.
+	*/
+	loadKeyIndex() {
+		try {
+			return this.store.get(INDEX_KEY) ?? [];
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Save the key index to storage.
+	*/
+	async saveKeyIndex() {
+		await this.store.update(INDEX_KEY, Array.from(this.keyIndex));
+	}
+	/**
+	* Get the storage key for a cache key.
+	*/
+	getStorageKey(key) {
+		return `${CACHE_PREFIX}${key}`;
+	}
+	async get(key) {
+		const storageKey = this.getStorageKey(key);
+		return this.store.get(storageKey) ?? null;
+	}
+	async set(key, entry) {
+		const storageKey = this.getStorageKey(key);
+		await this.store.update(storageKey, entry);
+		if (!this.keyIndex.has(key)) {
+			this.keyIndex.add(key);
+			await this.saveKeyIndex();
+		}
+	}
+	async delete(key) {
+		const storageKey = this.getStorageKey(key);
+		const existed = this.keyIndex.has(key);
+		if (existed) {
+			await this.store.update(storageKey, void 0);
+			this.keyIndex.delete(key);
+			await this.saveKeyIndex();
+		}
+		return existed;
+	}
+	async has(key) {
+		return this.keyIndex.has(key);
+	}
+	async keys() {
+		return Array.from(this.keyIndex);
+	}
+	async clear() {
+		for (const key of this.keyIndex) {
+			const storageKey = this.getStorageKey(key);
+			await this.store.update(storageKey, void 0);
+		}
+		this.keyIndex.clear();
+		await this.saveKeyIndex();
+	}
+	async stats() {
+		return { entryCount: this.keyIndex.size };
+	}
+};
+/**
+* Create a workspace state cache storage adapter.
+*/
+function createWorkspaceStateCacheStorage(store) {
+	return new WorkspaceStateCacheStorage(store);
+}
+
+//#endregion
+export { WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage };
+//# sourceMappingURL=workspace-state.js.map

package/dist/services/verification-cache/adapters/workspace-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-state.js","names":[],"sources":["../../../../src/services/verification-cache/adapters/workspace-state.ts"],"sourcesContent":["/**\n * Workspace state cache storage adapter.\n *\n * Generic adapter for key-value stores like VSCode's ExtensionContext.workspaceState.\n * Can also be used with localStorage-like APIs.\n */\n\nimport type {\n  CacheKeyString,\n  CacheStorageAdapter,\n  VerificationCacheEntry,\n} from '../types';\n\n/**\n * Interface for key-value store (compatible with VSCode's Memento).\n */\nexport interface KeyValueStore {\n  get<T>(key: string): T | undefined;\n  update(key: string, value: unknown): Thenable<void>;\n  keys?(): readonly string[];\n}\n\n/**\n * Cache key prefix to avoid collisions.\n */\nconst CACHE_PREFIX = 'contractspec.verification-cache.';\n\n/**\n * Index key for tracking all cache keys.\n */\nconst INDEX_KEY = `${CACHE_PREFIX}__index__`;\n\n/**\n * Workspace state storage adapter.\n */\nexport class WorkspaceStateCacheStorage implements CacheStorageAdapter {\n  private store: KeyValueStore;\n  private keyIndex: Set<string>;\n\n  constructor(store: KeyValueStore) {\n    this.store = store;\n    this.keyIndex = new Set(this.loadKeyIndex());\n  }\n\n  /**\n   * Load the key index from storage.\n   */\n  private loadKeyIndex(): string[] {\n    try {\n      const index = this.store.get<string[]>(INDEX_KEY);\n      return index ?? [];\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Save the key index to storage.\n   */\n  private async saveKeyIndex(): Promise<void> {\n    await this.store.update(INDEX_KEY, Array.from(this.keyIndex));\n  }\n\n  /**\n   * Get the storage key for a cache key.\n   */\n  private getStorageKey(key: CacheKeyString): string {\n    return `${CACHE_PREFIX}${key}`;\n  }\n\n  async get(key: CacheKeyString): Promise<VerificationCacheEntry | null> {\n    const storageKey = this.getStorageKey(key);\n    const entry = this.store.get<VerificationCacheEntry>(storageKey);\n    return entry ?? null;\n  }\n\n  async set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void> {\n    const storageKey = this.getStorageKey(key);\n    await this.store.update(storageKey, entry);\n\n    if (!this.keyIndex.has(key)) {\n      this.keyIndex.add(key);\n      await this.saveKeyIndex();\n    }\n  }\n\n  async delete(key: CacheKeyString): Promise<boolean> {\n    const storageKey = this.getStorageKey(key);\n    const existed = this.keyIndex.has(key);\n\n    if (existed) {\n      await this.store.update(storageKey, undefined);\n      this.keyIndex.delete(key);\n      await this.saveKeyIndex();\n    }\n\n    return existed;\n  }\n\n  async has(key: CacheKeyString): Promise<boolean> {\n    return this.keyIndex.has(key);\n  }\n\n  async keys(): Promise<CacheKeyString[]> {\n    return Array.from(this.keyIndex);\n  }\n\n  async clear(): Promise<void> {\n    // Delete all entries\n    for (const key of this.keyIndex) {\n      const storageKey = this.getStorageKey(key);\n      await this.store.update(storageKey, undefined);\n    }\n\n    // Clear index\n    this.keyIndex.clear();\n    await this.saveKeyIndex();\n  }\n\n  async stats(): Promise<{ entryCount: number; memoryUsage?: number }> {\n    return {\n      entryCount: this.keyIndex.size,\n    };\n  }\n}\n\n/**\n * Create a workspace state cache storage adapter.\n */\nexport function createWorkspaceStateCacheStorage(\n  store: KeyValueStore\n): WorkspaceStateCacheStorage {\n  return new WorkspaceStateCacheStorage(store);\n}\n"],"mappings":";;;;AAyBA,MAAM,eAAe;;;;AAKrB,MAAM,YAAY,GAAG,aAAa;;;;AAKlC,IAAa,6BAAb,MAAuE;CACrE,AAAQ;CACR,AAAQ;CAER,YAAY,OAAsB;AAChC,OAAK,QAAQ;AACb,OAAK,WAAW,IAAI,IAAI,KAAK,cAAc,CAAC;;;;;CAM9C,AAAQ,eAAyB;AAC/B,MAAI;AAEF,UADc,KAAK,MAAM,IAAc,UAAU,IACjC,EAAE;UACZ;AACN,UAAO,EAAE;;;;;;CAOb,MAAc,eAA8B;AAC1C,QAAM,KAAK,MAAM,OAAO,WAAW,MAAM,KAAK,KAAK,SAAS,CAAC;;;;;CAM/D,AAAQ,cAAc,KAA6B;AACjD,SAAO,GAAG,eAAe;;CAG3B,MAAM,IAAI,KAA6D;EACrE,MAAM,aAAa,KAAK,cAAc,IAAI;AAE1C,SADc,KAAK,MAAM,IAA4B,WAAW,IAChD;;CAGlB,MAAM,IAAI,KAAqB,OAA8C;EAC3E,MAAM,aAAa,KAAK,cAAc,IAAI;AAC1C,QAAM,KAAK,MAAM,OAAO,YAAY,MAAM;AAE1C,MAAI,CAAC,KAAK,SAAS,IAAI,IAAI,EAAE;AAC3B,QAAK,SAAS,IAAI,IAAI;AACtB,SAAM,KAAK,cAAc;;;CAI7B,MAAM,OAAO,KAAuC;EAClD,MAAM,aAAa,KAAK,cAAc,IAAI;EAC1C,MAAM,UAAU,KAAK,SAAS,IAAI,IAAI;AAEtC,MAAI,SAAS;AACX,SAAM,KAAK,MAAM,OAAO,YAAY,OAAU;AAC9C,QAAK,SAAS,OAAO,IAAI;AACzB,SAAM,KAAK,cAAc;;AAG3B,SAAO;;CAGT,MAAM,IAAI,KAAuC;AAC/C,SAAO,KAAK,SAAS,IAAI,IAAI;;CAG/B,MAAM,OAAkC;AACtC,SAAO,MAAM,KAAK,KAAK,SAAS;;CAGlC,MAAM,QAAuB;AAE3B,OAAK,MAAM,OAAO,KAAK,UAAU;GAC/B,MAAM,aAAa,KAAK,cAAc,IAAI;AAC1C,SAAM,KAAK,MAAM,OAAO,YAAY,OAAU;;AAIhD,OAAK,SAAS,OAAO;AACrB,QAAM,KAAK,cAAc;;CAG3B,MAAM,QAA+D;AACnE,SAAO,EACL,YAAY,KAAK,SAAS,MAC3B;;;;;;AAOL,SAAgB,iCACd,OAC4B;AAC5B,QAAO,IAAI,2BAA2B,MAAM"}