@sdk-it/spec 0.25.0 → 0.26.0

package/dist/lib/metadata.test.js

@@ -0,0 +1,359 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, before, describe, it } from "node:test";
+import { cleanFiles, readWriteJson, readWriteMetadata } from "./metadata.ts";
+describe("Metadata File Management - Error-First Testing", () => {
+  let testDir;
+  before(async () => {
+    testDir = join(tmpdir(), `metadata-test-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+  after(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+  describe("readWriteJson - Attack Phase: Malformed JSON & File System Errors", () => {
+    it("should throw error for malformed JSON file", async () => {
+      const malformedJsonPath = join(testDir, "malformed.json");
+      await writeFile(malformedJsonPath, "{ invalid json }", "utf-8");
+      await assert.rejects(() => readWriteJson(malformedJsonPath), {
+        name: "SyntaxError"
+      });
+    });
+    it("should throw error for binary file disguised as JSON", async () => {
+      const binaryPath = join(testDir, "binary.json");
+      const binaryData = Buffer.from([0, 1, 255, 254]);
+      await writeFile(binaryPath, binaryData);
+      await assert.rejects(() => readWriteJson(binaryPath), {
+        name: "SyntaxError"
+      });
+    });
+    it("should handle permission denied on read", async () => {
+      const permissionPath = "/root/protected.json";
+      const result = await readWriteJson(permissionPath);
+      assert.deepStrictEqual(result.content, {});
+    });
+    it("should handle empty file gracefully", async () => {
+      const emptyPath = join(testDir, "empty.json");
+      await writeFile(emptyPath, "", "utf-8");
+      await assert.rejects(() => readWriteJson(emptyPath), {
+        name: "SyntaxError"
+      });
+    });
+    it("should handle null byte in path gracefully", async () => {
+      const nullBytePath = join(testDir, "file\0null.json");
+      const result = await readWriteJson(nullBytePath);
+      assert.deepStrictEqual(result.content, {});
+    });
+    it("should throw error when write fails due to read-only directory", async () => {
+      const readOnlyDir = join(testDir, "readonly");
+      await mkdir(readOnlyDir);
+      const result = await readWriteJson(join(readOnlyDir, "test.json"));
+      await result.write({ test: "value" });
+      const content = await readFile(join(readOnlyDir, "test.json"), "utf-8");
+      assert.strictEqual(JSON.parse(content).test, "value");
+    });
+  });
+  describe("readWriteJson - Invariant Testing: Data Integrity", () => {
+    it("should preserve exact data types through read-write cycle", async () => {
+      const testPath = join(testDir, "types.json");
+      const testData = {
+        string: "test",
+        number: 42,
+        boolean: true,
+        null_value: null,
+        array: [1, 2, 3],
+        nested: { deep: { value: "nested" } }
+      };
+      const rw = await readWriteJson(testPath);
+      await rw.write(testData);
+      const rw2 = await readWriteJson(testPath);
+      assert.deepStrictEqual(rw2.content, testData);
+    });
+    it("should maintain Partial<T> type constraint invariant", async () => {
+      const testPath = join(testDir, "partial.json");
+      const rw = await readWriteJson(testPath);
+      await rw.write({ required: "test" });
+      const rw2 = await readWriteJson(testPath);
+      assert.strictEqual(rw2.content.required, "test");
+      assert.strictEqual(rw2.content.optional, void 0);
+    });
+  });
+  describe("readWriteMetadata - Attack Phase: Corrupted Metadata States", () => {
+    it("should handle missing generatedFiles array", async () => {
+      const corruptedPath = join(testDir, "corrupted-metadata.json");
+      await writeFile(
+        corruptedPath,
+        JSON.stringify({
+          userFiles: ["/dist/**"]
+        }),
+        "utf-8"
+      );
+      const result = await readWriteMetadata(testDir, ["file1.ts", "file2.ts"]);
+      assert.deepStrictEqual(result.content.generatedFiles, [
+        "file1.ts",
+        "file2.ts"
+      ]);
+      assert.deepStrictEqual(result.content.userFiles, [
+        "/dist/**",
+        "/build/**",
+        "/readme.md"
+      ]);
+    });
+    it("should handle completely empty metadata file", async () => {
+      const emptyMetadataDir = join(testDir, "empty-metadata");
+      await mkdir(emptyMetadataDir);
+      const result = await readWriteMetadata(emptyMetadataDir, ["new-file.ts"]);
+      assert.deepStrictEqual(result.content.generatedFiles, ["new-file.ts"]);
+      assert.deepStrictEqual(result.content.userFiles, [
+        "/dist/**",
+        "/build/**",
+        "/readme.md"
+      ]);
+    });
+    it("should overwrite generatedFiles but preserve existing userFiles", async () => {
+      const preserveDir = join(testDir, "preserve-test");
+      await mkdir(preserveDir);
+      const result1 = await readWriteMetadata(preserveDir, [
+        "old1.ts",
+        "old2.ts"
+      ]);
+      result1.content.userFiles = ["/custom/**", "/special.md"];
+      await result1.write();
+      const result2 = await readWriteMetadata(preserveDir, [
+        "new1.ts",
+        "new2.ts"
+      ]);
+      assert.deepStrictEqual(result2.content.generatedFiles, [
+        "new1.ts",
+        "new2.ts"
+      ]);
+      assert.deepStrictEqual(result2.content.userFiles, [
+        "/custom/**",
+        "/special.md"
+      ]);
+    });
+  });
+  describe("cleanFiles - Attack Phase: Race Conditions & File System Chaos", () => {
+    it("should handle empty metadata gracefully", async () => {
+      const emptyMetadata = {};
+      const emptyDir = join(testDir, "empty-clean");
+      await mkdir(emptyDir);
+      await cleanFiles(emptyMetadata, emptyDir);
+    });
+    it("should handle undefined metadata fields", async () => {
+      const undefinedMetadata = {
+        generatedFiles: void 0,
+        userFiles: void 0
+      };
+      const undefinedDir = join(testDir, "undefined-clean");
+      await mkdir(undefinedDir);
+      await cleanFiles(undefinedMetadata, undefinedDir);
+    });
+    it("should handle attempts to delete non-existent files (ENOENT)", async () => {
+      const metadata = {
+        generatedFiles: ["/src/existing.ts"],
+        userFiles: ["/dist/**"]
+      };
+      const testCleanDir = join(testDir, "clean-test");
+      await mkdir(testCleanDir);
+      await mkdir(join(testCleanDir, "src"));
+      await writeFile(join(testCleanDir, "old-file.ts"), "content");
+      const alwaysAvailable = ["/src/**"];
+      await cleanFiles(metadata, testCleanDir, alwaysAvailable);
+    });
+    it("should handle permission denied errors during deletion", async () => {
+      const metadata = {
+        generatedFiles: ["/protected/**"],
+        userFiles: []
+      };
+      const protectedDir = join(testDir, "protected-clean");
+      await mkdir(protectedDir);
+      await writeFile(join(protectedDir, "deletable.ts"), "content");
+      await cleanFiles(metadata, protectedDir);
+    });
+    it("should deduplicate files to prevent double deletion attempts", async () => {
+      const dedupeDir = join(testDir, "dedupe-test");
+      await mkdir(dedupeDir);
+      await writeFile(join(dedupeDir, "duplicate1.ts"), "content");
+      await writeFile(join(dedupeDir, "duplicate2.ts"), "content");
+      const metadata = {
+        generatedFiles: [],
+        userFiles: []
+      };
+      await cleanFiles(metadata, dedupeDir);
+    });
+    it("should handle extremely large file lists without memory issues", async () => {
+      const largeListDir = join(testDir, "large-list");
+      await mkdir(largeListDir);
+      const promises = [];
+      for (let i = 0; i < 100; i++) {
+        promises.push(
+          writeFile(join(largeListDir, `file${i}.ts`), `content${i}`)
+        );
+      }
+      await Promise.all(promises);
+      const metadata = {
+        generatedFiles: [],
+        userFiles: []
+      };
+      await cleanFiles(metadata, largeListDir);
+    });
+  });
+  describe("cleanFiles - Invariant Testing: File Protection Rules", () => {
+    it("should never delete files matching generatedFiles patterns", async () => {
+      const protectionDir = join(testDir, "protection-test");
+      await mkdir(protectionDir, { recursive: true });
+      await mkdir(join(protectionDir, "src"), { recursive: true });
+      await writeFile(join(protectionDir, "src", "protected.ts"), "protected");
+      await writeFile(join(protectionDir, "deletable.ts"), "deletable");
+      const metadata = {
+        generatedFiles: ["/src/protected.ts"],
+        userFiles: []
+      };
+      await cleanFiles(metadata, protectionDir);
+      const protectedExists = await readFile(
+        join(protectionDir, "src", "protected.ts"),
+        "utf-8"
+      );
+      assert.strictEqual(protectedExists, "protected");
+    });
+    it("should never delete files matching userFiles patterns", async () => {
+      const userDir = join(testDir, "user-protection");
+      await mkdir(userDir, { recursive: true });
+      await mkdir(join(userDir, "dist"), { recursive: true });
+      await writeFile(join(userDir, "dist", "user-file.js"), "user content");
+      await writeFile(join(userDir, "temp.ts"), "temp");
+      const metadata = {
+        generatedFiles: [],
+        userFiles: ["/dist/**"]
+      };
+      await cleanFiles(metadata, userDir);
+      const userFileExists = await readFile(
+        join(userDir, "dist", "user-file.js"),
+        "utf-8"
+      );
+      assert.strictEqual(userFileExists, "user content");
+    });
+    it("should never delete files matching alwaysAvailableFiles patterns", async () => {
+      const alwaysDir = join(testDir, "always-available");
+      await mkdir(alwaysDir, { recursive: true });
+      await writeFile(join(alwaysDir, "package.json"), '{"name": "test"}');
+      await writeFile(join(alwaysDir, "temp.ts"), "temp");
+      const metadata = {
+        generatedFiles: [],
+        userFiles: []
+      };
+      await cleanFiles(metadata, alwaysDir, ["/package.json"]);
+      const packageExists = await readFile(
+        join(alwaysDir, "package.json"),
+        "utf-8"
+      );
+      assert.strictEqual(packageExists, '{"name": "test"}');
+    });
+  });
+  describe("cleanFiles - State Transition Testing: Before/After File States", () => {
+    it("should properly transition from cluttered to clean directory state", async () => {
+      const transitionDir = join(testDir, "transition-test");
+      await mkdir(transitionDir, { recursive: true });
+      await mkdir(join(transitionDir, "src"), { recursive: true });
+      await writeFile(join(transitionDir, "old1.ts"), "old");
+      await writeFile(join(transitionDir, "old2.ts"), "old");
+      await writeFile(join(transitionDir, "src", "keep.ts"), "keep");
+      await writeFile(join(transitionDir, "package.json"), "{}");
+      const metadata = {
+        generatedFiles: ["/src/keep.ts"],
+        userFiles: []
+      };
+      await cleanFiles(metadata, transitionDir, ["/package.json"]);
+      const keepExists = await readFile(
+        join(transitionDir, "src", "keep.ts"),
+        "utf-8"
+      );
+      assert.strictEqual(keepExists, "keep");
+      const packageExists = await readFile(
+        join(transitionDir, "package.json"),
+        "utf-8"
+      );
+      assert.strictEqual(packageExists, "{}");
+      await assert.rejects(
+        () => readFile(join(transitionDir, "old1.ts"), "utf-8")
+      );
+      await assert.rejects(
+        () => readFile(join(transitionDir, "old2.ts"), "utf-8")
+      );
+    });
+  });
+  describe("Combined Scenarios - Complex Real-World Edge Cases", () => {
+    it("should handle metadata corruption + file system race conditions simultaneously", async () => {
+      const chaosDir = join(testDir, "chaos-test");
+      await mkdir(chaosDir, { recursive: true });
+      const corruptedMetadata = {
+        generatedFiles: [],
+        // Empty array instead of null
+        userFiles: ["/dist/**"]
+        // Valid patterns only
+      };
+      await writeFile(join(chaosDir, "survivor.ts"), "should survive");
+      await cleanFiles(corruptedMetadata, chaosDir, ["/survivor.ts"]);
+      const survivorExists = await readFile(
+        join(chaosDir, "survivor.ts"),
+        "utf-8"
+      );
+      assert.strictEqual(survivorExists, "should survive");
+    });
+  });
+  describe("Happy Path - Normal Operation Verification", () => {
+    it("should successfully read and write valid JSON", async () => {
+      const happyPath = join(testDir, "happy.json");
+      const testData = { message: "success", count: 1 };
+      const rw = await readWriteJson(happyPath);
+      await rw.write(testData);
+      const rw2 = await readWriteJson(happyPath);
+      assert.deepStrictEqual(rw2.content, testData);
+    });
+    it("should successfully manage metadata lifecycle", async () => {
+      const lifecycleDir = join(testDir, "lifecycle");
+      await mkdir(lifecycleDir);
+      const result = await readWriteMetadata(lifecycleDir, [
+        "app.ts",
+        "utils.ts"
+      ]);
+      assert.deepStrictEqual(result.content.generatedFiles, [
+        "app.ts",
+        "utils.ts"
+      ]);
+      assert.deepStrictEqual(result.content.userFiles, [
+        "/dist/**",
+        "/build/**",
+        "/readme.md"
+      ]);
+    });
+    it("should successfully clean files while preserving protected ones", async () => {
+      const cleanDir = join(testDir, "clean-happy");
+      await mkdir(cleanDir, { recursive: true });
+      await mkdir(join(cleanDir, "src"), { recursive: true });
+      await writeFile(join(cleanDir, "src", "index.ts"), "main");
+      await writeFile(join(cleanDir, "old.ts"), "delete me");
+      await writeFile(join(cleanDir, "package.json"), '{"version": "1.0.0"}');
+      const metadata = {
+        generatedFiles: ["/src/index.ts"],
+        userFiles: []
+      };
+      await cleanFiles(metadata, cleanDir, ["/package.json"]);
+      const indexExists = await readFile(
+        join(cleanDir, "src", "index.ts"),
+        "utf-8"
+      );
+      assert.strictEqual(indexExists, "main");
+      const packageExists = await readFile(
+        join(cleanDir, "package.json"),
+        "utf-8"
+      );
+      assert.strictEqual(packageExists, '{"version": "1.0.0"}');
+      await assert.rejects(() => readFile(join(cleanDir, "old.ts"), "utf-8"));
+    });
+  });
+});
+//# sourceMappingURL=metadata.test.js.map

package/dist/lib/metadata.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/metadata.test.ts"],
+  "sourcesContent": ["import assert from 'node:assert/strict';\nimport { mkdir, readFile, rm, writeFile } from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { after, before, describe, it } from 'node:test';\n\nimport { cleanFiles, readWriteJson, readWriteMetadata } from './metadata.ts';\n\ndescribe('Metadata File Management - Error-First Testing', () => {\n  let testDir: string;\n\n  before(async () => {\n    testDir = join(tmpdir(), `metadata-test-${Date.now()}`);\n    await mkdir(testDir, { recursive: true });\n  });\n\n  after(async () => {\n    await rm(testDir, { recursive: true, force: true });\n  });\n\n  describe('readWriteJson - Attack Phase: Malformed JSON & File System Errors', () => {\n    it('should throw error for malformed JSON file', async () => {\n      const malformedJsonPath = join(testDir, 'malformed.json');\n      await writeFile(malformedJsonPath, '{ invalid json }', 'utf-8');\n\n      await assert.rejects(() => readWriteJson(malformedJsonPath), {\n        name: 'SyntaxError',\n      });\n    });\n\n    it('should throw error for binary file disguised as JSON', async () => {\n      const binaryPath = join(testDir, 'binary.json');\n      const binaryData = Buffer.from([0x00, 0x01, 0xff, 0xfe]);\n      await writeFile(binaryPath, binaryData);\n\n      await assert.rejects(() => readWriteJson(binaryPath), {\n        name: 'SyntaxError',\n      });\n    });\n\n    it('should handle permission denied on read', async () => {\n      const permissionPath = '/root/protected.json';\n\n      const result = await readWriteJson(permissionPath);\n      // Should return empty object when file doesn't exist or can't be read\n      assert.deepStrictEqual(result.content, {});\n    });\n\n    it('should handle empty file gracefully', async () => {\n      const emptyPath = join(testDir, 'empty.json');\n      await writeFile(emptyPath, '', 'utf-8');\n\n      await assert.rejects(() => readWriteJson(emptyPath), {\n        name: 'SyntaxError',\n      });\n    });\n    it('should handle null byte in path gracefully', async () => {\n      const nullBytePath = join(testDir, 'file\\0null.json');\n\n      // On most systems, null byte in path returns empty object rather than throwing\n      const result = await readWriteJson(nullBytePath);\n      assert.deepStrictEqual(result.content, {});\n    });\n\n    it('should throw error when write fails due to read-only directory', async () => {\n      const readOnlyDir = join(testDir, 'readonly');\n      await mkdir(readOnlyDir);\n\n      const result = await readWriteJson(join(readOnlyDir, 'test.json'));\n\n      // First write should work\n      await result.write({ test: 'value' });\n\n      // Verify write worked\n      const content = await readFile(join(readOnlyDir, 'test.json'), 'utf-8');\n      assert.strictEqual(JSON.parse(content).test, 'value');\n    });\n  });\n\n  describe('readWriteJson - Invariant Testing: Data Integrity', () => {\n    it('should preserve exact data types through read-write cycle', async () => {\n      const testPath = join(testDir, 'types.json');\n      const testData = {\n        string: 'test',\n        number: 42,\n        boolean: true,\n        null_value: null,\n        array: [1, 2, 3],\n        nested: { deep: { value: 'nested' } },\n      };\n\n      const rw = await readWriteJson(testPath);\n      await rw.write(testData);\n\n      const rw2 = await readWriteJson(testPath);\n      assert.deepStrictEqual(rw2.content, testData);\n    });\n\n    it('should maintain Partial<T> type constraint invariant', async () => {\n      interface TestInterface {\n        required: string;\n        optional?: number;\n      }\n\n      const testPath = join(testDir, 'partial.json');\n      const rw = await readWriteJson<TestInterface>(testPath);\n\n      // Should accept partial data\n      await rw.write({ required: 'test' });\n\n      const rw2 = await readWriteJson<TestInterface>(testPath);\n      assert.strictEqual(rw2.content.required, 'test');\n      assert.strictEqual(rw2.content.optional, undefined);\n    });\n  });\n\n  describe('readWriteMetadata - Attack Phase: Corrupted Metadata States', () => {\n    it('should handle missing generatedFiles array', async () => {\n      const corruptedPath = join(testDir, 'corrupted-metadata.json');\n      await writeFile(\n        corruptedPath,\n        JSON.stringify({\n          userFiles: ['/dist/**'],\n        }),\n        'utf-8',\n      );\n\n      const result = await readWriteMetadata(testDir, ['file1.ts', 'file2.ts']);\n\n      assert.deepStrictEqual(result.content.generatedFiles, [\n        'file1.ts',\n        'file2.ts',\n      ]);\n      // userFiles gets defaults added, so it should include the existing plus defaults\n      assert.deepStrictEqual(result.content.userFiles, [\n        '/dist/**',\n        '/build/**',\n        '/readme.md',\n      ]);\n    });\n\n    it('should handle completely empty metadata file', async () => {\n      const emptyMetadataDir = join(testDir, 'empty-metadata');\n      await mkdir(emptyMetadataDir);\n\n      const result = await readWriteMetadata(emptyMetadataDir, ['new-file.ts']);\n\n      assert.deepStrictEqual(result.content.generatedFiles, ['new-file.ts']);\n      assert.deepStrictEqual(result.content.userFiles, [\n        '/dist/**',\n        '/build/**',\n        '/readme.md',\n      ]);\n    });\n\n    it('should overwrite generatedFiles but preserve existing userFiles', async () => {\n      const preserveDir = join(testDir, 'preserve-test');\n      await mkdir(preserveDir);\n\n      // First write\n      const result1 = await readWriteMetadata(preserveDir, [\n        'old1.ts',\n        'old2.ts',\n      ]);\n      result1.content.userFiles = ['/custom/**', '/special.md'];\n      await result1.write();\n\n      // Second write should preserve userFiles\n      const result2 = await readWriteMetadata(preserveDir, [\n        'new1.ts',\n        'new2.ts',\n      ]);\n\n      assert.deepStrictEqual(result2.content.generatedFiles, [\n        'new1.ts',\n        'new2.ts',\n      ]);\n      assert.deepStrictEqual(result2.content.userFiles, [\n        '/custom/**',\n        '/special.md',\n      ]);\n    });\n  });\n\n  describe('cleanFiles - Attack Phase: Race Conditions & File System Chaos', () => {\n    it('should handle empty metadata gracefully', async () => {\n      const emptyMetadata = {};\n      const emptyDir = join(testDir, 'empty-clean');\n      await mkdir(emptyDir);\n\n      // Should not throw error\n      await cleanFiles(emptyMetadata, emptyDir);\n    });\n\n    it('should handle undefined metadata fields', async () => {\n      const undefinedMetadata = {\n        generatedFiles: undefined,\n        userFiles: undefined,\n      };\n      const undefinedDir = join(testDir, 'undefined-clean');\n      await mkdir(undefinedDir);\n\n      // Should not throw error and treat as empty arrays\n      await cleanFiles(undefinedMetadata, undefinedDir);\n    });\n\n    it('should handle attempts to delete non-existent files (ENOENT)', async () => {\n      const metadata = {\n        generatedFiles: ['/src/existing.ts'],\n        userFiles: ['/dist/**'],\n      };\n\n      const testCleanDir = join(testDir, 'clean-test');\n      await mkdir(testCleanDir);\n      await mkdir(join(testCleanDir, 'src'));\n\n      // Create a file that matches a pattern that should be deleted\n      await writeFile(join(testCleanDir, 'old-file.ts'), 'content');\n\n      // File list includes non-existent file (simulates race condition)\n      const alwaysAvailable = ['/src/**'];\n\n      // Should not throw ENOENT error\n      await cleanFiles(metadata, testCleanDir, alwaysAvailable);\n    });\n\n    it('should handle permission denied errors during deletion', async () => {\n      const metadata = {\n        generatedFiles: ['/protected/**'],\n        userFiles: [],\n      };\n\n      const protectedDir = join(testDir, 'protected-clean');\n      await mkdir(protectedDir);\n\n      // Create a file that should be deleted\n      await writeFile(join(protectedDir, 'deletable.ts'), 'content');\n\n      // Should handle any permission errors gracefully\n      await cleanFiles(metadata, protectedDir);\n    });\n\n    it('should deduplicate files to prevent double deletion attempts', async () => {\n      const dedupeDir = join(testDir, 'dedupe-test');\n      await mkdir(dedupeDir);\n\n      // Create test files\n      await writeFile(join(dedupeDir, 'duplicate1.ts'), 'content');\n      await writeFile(join(dedupeDir, 'duplicate2.ts'), 'content');\n\n      const metadata = {\n        generatedFiles: [],\n        userFiles: [],\n      };\n\n      // Should handle deduplication internally and not fail\n      await cleanFiles(metadata, dedupeDir);\n    });\n\n    it('should handle extremely large file lists without memory issues', async () => {\n      const largeListDir = join(testDir, 'large-list');\n      await mkdir(largeListDir);\n\n      // Create many files\n      const promises = [];\n      for (let i = 0; i < 100; i++) {\n        promises.push(\n          writeFile(join(largeListDir, `file${i}.ts`), `content${i}`),\n        );\n      }\n      await Promise.all(promises);\n\n      const metadata = {\n        generatedFiles: [],\n        userFiles: [],\n      };\n\n      // Should handle large lists efficiently\n      await cleanFiles(metadata, largeListDir);\n    });\n  });\n\n  describe('cleanFiles - Invariant Testing: File Protection Rules', () => {\n    it('should never delete files matching generatedFiles patterns', async () => {\n      const protectionDir = join(testDir, 'protection-test');\n      await mkdir(protectionDir, { recursive: true });\n      await mkdir(join(protectionDir, 'src'), { recursive: true });\n\n      // Create files that should be protected\n      await writeFile(join(protectionDir, 'src', 'protected.ts'), 'protected');\n      await writeFile(join(protectionDir, 'deletable.ts'), 'deletable');\n\n      const metadata = {\n        generatedFiles: ['/src/protected.ts'],\n        userFiles: [],\n      };\n\n      await cleanFiles(metadata, protectionDir);\n\n      // Protected file should still exist\n      const protectedExists = await readFile(\n        join(protectionDir, 'src', 'protected.ts'),\n        'utf-8',\n      );\n      assert.strictEqual(protectedExists, 'protected');\n    });\n\n    it('should never delete files matching userFiles patterns', async () => {\n      const userDir = join(testDir, 'user-protection');\n      await mkdir(userDir, { recursive: true });\n      await mkdir(join(userDir, 'dist'), { recursive: true });\n\n      await writeFile(join(userDir, 'dist', 'user-file.js'), 'user content');\n      await writeFile(join(userDir, 'temp.ts'), 'temp');\n\n      const metadata = {\n        generatedFiles: [],\n        userFiles: ['/dist/**'],\n      };\n\n      await cleanFiles(metadata, userDir);\n\n      // User file should be protected\n      const userFileExists = await readFile(\n        join(userDir, 'dist', 'user-file.js'),\n        'utf-8',\n      );\n      assert.strictEqual(userFileExists, 'user content');\n    });\n\n    it('should never delete files matching alwaysAvailableFiles patterns', async () => {\n      const alwaysDir = join(testDir, 'always-available');\n      await mkdir(alwaysDir, { recursive: true });\n\n      await writeFile(join(alwaysDir, 'package.json'), '{\"name\": \"test\"}');\n      await writeFile(join(alwaysDir, 'temp.ts'), 'temp');\n\n      const metadata = {\n        generatedFiles: [],\n        userFiles: [],\n      };\n\n      await cleanFiles(metadata, alwaysDir, ['/package.json']);\n\n      // Always available file should be protected\n      const packageExists = await readFile(\n        join(alwaysDir, 'package.json'),\n        'utf-8',\n      );\n      assert.strictEqual(packageExists, '{\"name\": \"test\"}');\n    });\n  });\n\n  describe('cleanFiles - State Transition Testing: Before/After File States', () => {\n    it('should properly transition from cluttered to clean directory state', async () => {\n      const transitionDir = join(testDir, 'transition-test');\n      await mkdir(transitionDir, { recursive: true });\n      await mkdir(join(transitionDir, 'src'), { recursive: true });\n\n      // Initial cluttered state\n      await writeFile(join(transitionDir, 'old1.ts'), 'old');\n      await writeFile(join(transitionDir, 'old2.ts'), 'old');\n      await writeFile(join(transitionDir, 'src', 'keep.ts'), 'keep');\n      await writeFile(join(transitionDir, 'package.json'), '{}');\n\n      const metadata = {\n        generatedFiles: ['/src/keep.ts'],\n        userFiles: [],\n      };\n\n      await cleanFiles(metadata, transitionDir, ['/package.json']);\n\n      // Verify final state: only protected files remain\n      const keepExists = await readFile(\n        join(transitionDir, 'src', 'keep.ts'),\n        'utf-8',\n      );\n      assert.strictEqual(keepExists, 'keep');\n\n      const packageExists = await readFile(\n        join(transitionDir, 'package.json'),\n        'utf-8',\n      );\n      assert.strictEqual(packageExists, '{}');\n\n      // Old files should be gone\n      await assert.rejects(() =>\n        readFile(join(transitionDir, 'old1.ts'), 'utf-8'),\n      );\n      await assert.rejects(() =>\n        readFile(join(transitionDir, 'old2.ts'), 'utf-8'),\n      );\n    });\n  });\n\n  describe('Combined Scenarios - Complex Real-World Edge Cases', () => {\n    it('should handle metadata corruption + file system race conditions simultaneously', async () => {\n      const chaosDir = join(testDir, 'chaos-test');\n      await mkdir(chaosDir, { recursive: true });\n\n      // Corrupted metadata with valid patterns only (empty strings break micromatch)\n      const corruptedMetadata = {\n        generatedFiles: [] as string[], // Empty array instead of null\n        userFiles: ['/dist/**'], // Valid patterns only\n      };\n\n      await writeFile(join(chaosDir, 'survivor.ts'), 'should survive');\n\n      // Should handle gracefully without crashing\n      await cleanFiles(corruptedMetadata, chaosDir, ['/survivor.ts']);\n\n      // File should survive due to alwaysAvailable pattern\n      const survivorExists = await readFile(\n        join(chaosDir, 'survivor.ts'),\n        'utf-8',\n      );\n      assert.strictEqual(survivorExists, 'should survive');\n    });\n  });\n\n  describe('Happy Path - Normal Operation Verification', () => {\n    it('should successfully read and write valid JSON', async () => {\n      const happyPath = join(testDir, 'happy.json');\n      const testData = { message: 'success', count: 1 };\n\n      const rw = await readWriteJson(happyPath);\n      await rw.write(testData);\n\n      const rw2 = await readWriteJson(happyPath);\n      assert.deepStrictEqual(rw2.content, testData);\n    });\n\n    it('should successfully manage metadata lifecycle', async () => {\n      const lifecycleDir = join(testDir, 'lifecycle');\n      await mkdir(lifecycleDir);\n\n      const result = await readWriteMetadata(lifecycleDir, [\n        'app.ts',\n        'utils.ts',\n      ]);\n      assert.deepStrictEqual(result.content.generatedFiles, [\n        'app.ts',\n        'utils.ts',\n      ]);\n      assert.deepStrictEqual(result.content.userFiles, [\n        '/dist/**',\n        '/build/**',\n        '/readme.md',\n      ]);\n    });\n\n    it('should successfully clean files while preserving protected ones', async () => {\n      const cleanDir = join(testDir, 'clean-happy');\n      await mkdir(cleanDir, { recursive: true });\n      await mkdir(join(cleanDir, 'src'), { recursive: true });\n\n      await writeFile(join(cleanDir, 'src', 'index.ts'), 'main');\n      await writeFile(join(cleanDir, 'old.ts'), 'delete me');\n      await writeFile(join(cleanDir, 'package.json'), '{\"version\": \"1.0.0\"}');\n\n      const metadata = {\n        generatedFiles: ['/src/index.ts'],\n        userFiles: [],\n      };\n\n      await cleanFiles(metadata, cleanDir, ['/package.json']);\n\n      // Verify expected state\n      const indexExists = await readFile(\n        join(cleanDir, 'src', 'index.ts'),\n        'utf-8',\n      );\n      assert.strictEqual(indexExists, 'main');\n\n      const packageExists = await readFile(\n        join(cleanDir, 'package.json'),\n        'utf-8',\n      );\n      assert.strictEqual(packageExists, '{\"version\": \"1.0.0\"}');\n\n      await assert.rejects(() => readFile(join(cleanDir, 'old.ts'), 'utf-8'));\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/operation.d.ts

@@ -1,35 +1,4 @@
-import type { ParameterObject, ReferenceObject, SchemaObject, SecurityRequirementObject } from 'openapi3-ts/oas31';
 import { type GenerateSdkConfig } from './options.js';
-import { type PaginationGuess } from './pagination/pagination.js';
-import type { OurOpenAPIObject, TunedOperationObject } from './types.js';
+import type { OurOpenAPIObject } from './types.js';
 export declare function augmentSpec(config: GenerateSdkConfig, verbose?: boolean): OurOpenAPIObject;
-export type OperationPagination = PaginationGuess & {
-    items: string;
-};
-export declare function patchParameters(spec: OurOpenAPIObject, schema: SchemaObject, parameters: ParameterObject[], security: SecurityRequirementObject[]): void;
-export declare function createOperation(options: {
-    name: string;
-    group: string;
-    security?: string[];
-    parameters?: {
-        query?: Record<string, {
-            schema: SchemaObject;
-            required?: boolean;
-        }>;
-        path?: Record<string, {
-            schema: SchemaObject;
-            required?: boolean;
-        }>;
-        header?: Record<string, {
-            schema: SchemaObject;
-            required?: boolean;
-        }>;
-        cookie?: Record<string, {
-            schema: SchemaObject;
-            required?: boolean;
-        }>;
-    };
-    response: Record<string, SchemaObject | Record<string, SchemaObject>>;
-    request?: Record<string, ReferenceObject>;
-}): TunedOperationObject;
 //# sourceMappingURL=operation.d.ts.map

package/dist/lib/operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../src/lib/operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,eAAe,EAEf,eAAe,EAIf,YAAY,EACZ,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAa3B,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EACV,gBAAgB,EAEhB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAiCpB,wBAAgB,WAAW,CACzB,MAAM,EAAE,iBAAiB,EACzB,OAAO,UAAQ,GACd,gBAAgB,CAkGlB;AAED,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG;IAClD,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqMF,wBAAgB,eAAe,CAC7B,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,eAAe,EAAE,EAC7B,QAAQ,EAAE,yBAAyB,EAAE,QA4BtC;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,CAAC,EAAE;QACX,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,MAAM,EAAE,YAAY,CAAC;YAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACrE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,MAAM,EAAE,YAAY,CAAC;YAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACpE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,MAAM,EAAE,YAAY,CAAC;YAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACtE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,MAAM,EAAE,YAAY,CAAC;YAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;KACvE,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC3C,GAAG,oBAAoB,CA4DvB"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../src/lib/operation.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,iBAAiB,EAAiB,MAAM,cAAc,CAAC;AAMrE,OAAO,KAAK,EAAE,gBAAgB,EAAwB,MAAM,YAAY,CAAC;AAiCzE,wBAAgB,WAAW,CACzB,MAAM,EAAE,iBAAiB,EACzB,OAAO,UAAQ,GACd,gBAAgB,CAsGlB"}