dialekt 0.1.0 → 0.1.1

package/src/config/types.test.ts

@@ -1,69 +1,75 @@
-import { describe, expect, it } from 'vitest';
-import type { DialektConfig, ModelConfig, ChunkingConfig, RetryConfig } from './types.js';
+import { describe, expect, it } from "vitest";
+import type { DialektConfig, ModelConfig, ChunkingConfig, RetryConfig } from "./types.js";
 
-describe('config type conformance', () => {
-  it('accepts all known model providers', () => {
-    const providers: ModelConfig['provider'][] = ['openai', 'anthropic', 'google', 'mistral', 'cohere'];
+describe("config type conformance", () => {
+  it("accepts all known model providers", () => {
+    const providers: ModelConfig["provider"][] = [
+      "openai",
+      "anthropic",
+      "google",
+      "mistral",
+      "cohere",
+    ];
     for (const provider of providers) {
-      const m: ModelConfig = { provider, modelId: 'test-model' };
+      const m: ModelConfig = { provider, modelId: "test-model" };
       expect(m.provider).toBe(provider);
     }
   });
 
-  it('accepts any string provider at compile time', () => {
+  it("accepts any string provider at compile time", () => {
     // provider is typed as string, not a literal union
-    const valid: ModelConfig = { provider: 'unknown-provider', modelId: 'x' };
-    expect(valid.provider).toBe('unknown-provider');
+    const valid: ModelConfig = { provider: "unknown-provider", modelId: "x" };
+    expect(valid.provider).toBe("unknown-provider");
   });
 
-  it('ChunkingConfig enforces positive maxTokens', () => {
+  it("ChunkingConfig enforces positive maxTokens", () => {
     const c: ChunkingConfig = { maxTokens: 1, charsPerToken: 1.0, concurrency: 1 };
     expect(c.maxTokens).toBe(1);
     expect(c.concurrency).toBe(1);
   });
 
-  it('RetryConfig enforces positive maxAttempts', () => {
+  it("RetryConfig enforces positive maxAttempts", () => {
     const r: RetryConfig = { maxAttempts: 1, baseDelayMs: 0 };
     expect(r.maxAttempts).toBe(1);
     expect(r.baseDelayMs).toBe(0);
   });
 
-  it('DialektConfig requires sourceLocale and targetLocales', () => {
+  it("DialektConfig requires sourceLocale and targetLocales", () => {
     const minimal: DialektConfig = {
-      sourceLocale: 'en',
-      targetLocales: ['de'],
-      strategy: 'one-shot',
-      model: { provider: 'openai', modelId: 'gpt-4o' },
-      fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+      sourceLocale: "en",
+      targetLocales: ["de"],
+      strategy: "one-shot",
+      model: { provider: "openai", modelId: "gpt-4o" },
+      fastModel: { provider: "openai", modelId: "gpt-4o-mini" },
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
       retry: { maxAttempts: 3, baseDelayMs: 1000 },
       adapters: [],
     };
-    expect(minimal.sourceLocale).toBe('en');
-    expect(minimal.targetLocales).toEqual(['de']);
+    expect(minimal.sourceLocale).toBe("en");
+    expect(minimal.targetLocales).toEqual(["de"]);
   });
 
-  it('DialektConfig accepts tool-loop-agent strategy', () => {
+  it("DialektConfig accepts tool-loop-agent strategy", () => {
     const config: DialektConfig = {
-      sourceLocale: 'en',
-      targetLocales: ['de'],
-      strategy: 'tool-loop-agent',
-      model: { provider: 'openai', modelId: 'gpt-4o' },
-      fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+      sourceLocale: "en",
+      targetLocales: ["de"],
+      strategy: "tool-loop-agent",
+      model: { provider: "openai", modelId: "gpt-4o" },
+      fastModel: { provider: "openai", modelId: "gpt-4o-mini" },
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
       retry: { maxAttempts: 3, baseDelayMs: 1000 },
       adapters: [],
     };
-    expect(config.strategy).toBe('tool-loop-agent');
+    expect(config.strategy).toBe("tool-loop-agent");
   });
 
-  it('targetLocales can be empty', () => {
+  it("targetLocales can be empty", () => {
     const config: DialektConfig = {
-      sourceLocale: 'en',
+      sourceLocale: "en",
       targetLocales: [],
-      strategy: 'one-shot',
-      model: { provider: 'openai', modelId: 'gpt-4o' },
-      fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+      strategy: "one-shot",
+      model: { provider: "openai", modelId: "gpt-4o" },
+      fastModel: { provider: "openai", modelId: "gpt-4o-mini" },
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
       retry: { maxAttempts: 3, baseDelayMs: 1000 },
       adapters: [],
@@ -71,13 +77,13 @@ describe('config type conformance', () => {
     expect(config.targetLocales).toEqual([]);
   });
 
-  it('accepts multiple target locales', () => {
+  it("accepts multiple target locales", () => {
     const config: DialektConfig = {
-      sourceLocale: 'en',
-      targetLocales: ['de', 'fr', 'es', 'ja'],
-      strategy: 'one-shot',
-      model: { provider: 'openai', modelId: 'gpt-4o' },
-      fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+      sourceLocale: "en",
+      targetLocales: ["de", "fr", "es", "ja"],
+      strategy: "one-shot",
+      model: { provider: "openai", modelId: "gpt-4o" },
+      fastModel: { provider: "openai", modelId: "gpt-4o-mini" },
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
       retry: { maxAttempts: 3, baseDelayMs: 1000 },
       adapters: [],
@@ -85,17 +91,17 @@ describe('config type conformance', () => {
     expect(config.targetLocales).toHaveLength(4);
   });
 
-  it('fastModel can be different provider from model', () => {
+  it("fastModel can be different provider from model", () => {
     const config: DialektConfig = {
-      sourceLocale: 'en',
-      targetLocales: ['de'],
-      strategy: 'one-shot',
-      model: { provider: 'openai', modelId: 'gpt-4o' },
-      fastModel: { provider: 'anthropic', modelId: 'claude-3-haiku' },
+      sourceLocale: "en",
+      targetLocales: ["de"],
+      strategy: "one-shot",
+      model: { provider: "openai", modelId: "gpt-4o" },
+      fastModel: { provider: "anthropic", modelId: "claude-3-haiku" },
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
       retry: { maxAttempts: 3, baseDelayMs: 1000 },
       adapters: [],
     };
-    expect(config.fastModel.provider).toBe('anthropic');
+    expect(config.fastModel.provider).toBe("anthropic");
   });
 });

package/src/config/types.ts

@@ -1,4 +1,4 @@
-import type { TranslationAdapter } from '../adapter/types.js';
+import type { TranslationAdapter } from "../adapter/types.js";
 
 export interface ModelConfig {
   readonly provider: string;
@@ -19,7 +19,7 @@ export interface RetryConfig {
 export interface DialektConfig {
   readonly sourceLocale: string;
   readonly targetLocales: readonly string[] | null;
-  readonly strategy: 'one-shot' | 'tool-loop-agent';
+  readonly strategy: "one-shot" | "tool-loop-agent";
   readonly model: ModelConfig;
   readonly fastModel: ModelConfig;
   readonly chunking: ChunkingConfig;

package/src/index.ts

@@ -1,25 +1,21 @@
-export { defineConfig } from './config/define-config.js';
-export type { DialektConfig, ModelConfig, ChunkingConfig, RetryConfig } from './config/types.js';
-export type {
-  ResourceRef,
-  TranslationAdapter,
-  AdapterCapabilities,
-} from './adapter/types.js';
-export { AdapterReadError, AdapterWriteError } from './adapter/types.js';
-export { flattenObject, unflattenObject, diffKeys } from './keys/flatten.js';
-export { chunkKeys } from './translation/chunking.js';
-export { NodePlatformLayer } from './sdk/node-layer.js';
-export { readFileIfExists, writeFileEnsuringDir } from './sdk/file-io.js';
-export { readPhpArrayAsJson, PhpExecutionError } from './sdk/php-array-reader.js';
-export { resolveModel, UnknownProviderError } from './translation/model-registry.js';
-export type { TranslationContext, TranslationStrategy } from './translation/types.js';
-export { TranslationFailedError } from './translation/types.js';
-export { createOneShotStrategy } from './translation/one-shot-strategy.js';
-export { createToolLoopStrategy } from './translation/tool-loop-strategy.js';
-export { runTranslation } from './translation/orchestrator.js';
-export { buildSystemPrompt, buildUserPrompt } from './translation/prompt.js';
-export { computeMissingKeys } from './translation/missing-keys.js';
-export { loadConfig, ConfigLoadError } from './config/load-config.js';
+export { defineConfig } from "./config/define-config.js";
+export type { DialektConfig, ModelConfig, ChunkingConfig, RetryConfig } from "./config/types.js";
+export type { ResourceRef, TranslationAdapter, AdapterCapabilities } from "./adapter/types.js";
+export { AdapterReadError, AdapterWriteError } from "./adapter/types.js";
+export { flattenObject, unflattenObject, diffKeys } from "./keys/flatten.js";
+export { chunkKeys } from "./translation/chunking.js";
+export { NodePlatformLayer } from "./sdk/node-layer.js";
+export { readFileIfExists, writeFileEnsuringDir } from "./sdk/file-io.js";
+export { readPhpArrayAsJson, PhpExecutionError } from "./sdk/php-array-reader.js";
+export { resolveModel, UnknownProviderError } from "./translation/model-registry.js";
+export type { TranslationContext, TranslationStrategy } from "./translation/types.js";
+export { TranslationFailedError } from "./translation/types.js";
+export { createOneShotStrategy } from "./translation/one-shot-strategy.js";
+export { createToolLoopStrategy } from "./translation/tool-loop-strategy.js";
+export { runTranslation } from "./translation/orchestrator.js";
+export { buildSystemPrompt, buildUserPrompt } from "./translation/prompt.js";
+export { computeMissingKeys } from "./translation/missing-keys.js";
+export { loadConfig, ConfigLoadError } from "./config/load-config.js";
 export {
   detectFormat,
   color,
@@ -32,8 +28,8 @@ export {
   warning,
   info,
   keyValue,
-} from './cli/format.js';
-export type { OutputFormat } from './cli/format.js';
+} from "./cli/format.js";
+export type { OutputFormat } from "./cli/format.js";
 export {
   formatMissingKeys,
   formatUnusedKeys,
@@ -43,7 +39,7 @@ export {
   formatAdd,
   formatBenchmark,
   formatError,
-} from './cli/formatters.js';
+} from "./cli/formatters.js";
 export type {
   MissingKeyEntry,
   UnusedKeyEntry,
@@ -53,4 +49,4 @@ export type {
   TranslateResult,
   AddResult,
   BenchmarkEntry,
-} from './cli/formatters.js';
+} from "./cli/formatters.js";

package/src/keys/flatten.test.ts

@@ -1,111 +1,111 @@
-import { describe, expect, it } from 'vitest';
-import { flattenObject, unflattenObject, diffKeys } from './flatten.js';
+import { describe, expect, it } from "vitest";
+import { flattenObject, unflattenObject, diffKeys } from "./flatten.js";
 
-describe('flattenObject', () => {
-  it('flattens nested objects to dot-notation keys', () => {
+describe("flattenObject", () => {
+  it("flattens nested objects to dot-notation keys", () => {
     expect(
       flattenObject({
-        validation: { email: 'Email', nested: { deep: 'x' } },
+        validation: { email: "Email", nested: { deep: "x" } },
       }),
-    ).toEqual({ 'validation.email': 'Email', 'validation.nested.deep': 'x' });
+    ).toEqual({ "validation.email": "Email", "validation.nested.deep": "x" });
   });
 
-  it('returns {} for an empty object', () => {
+  it("returns {} for an empty object", () => {
     expect(flattenObject({})).toEqual({});
   });
 
-  it('preserves empty string values', () => {
-    expect(flattenObject({ a: '' })).toEqual({ a: '' });
+  it("preserves empty string values", () => {
+    expect(flattenObject({ a: "" })).toEqual({ a: "" });
   });
 
-  it('handles deeply nested structures', () => {
-    expect(
-      flattenObject({ a: { b: { c: { d: { e: 'deep' } } } } }),
-    ).toEqual({ 'a.b.c.d.e': 'deep' });
+  it("handles deeply nested structures", () => {
+    expect(flattenObject({ a: { b: { c: { d: { e: "deep" } } } } })).toEqual({
+      "a.b.c.d.e": "deep",
+    });
   });
 
-  it('ignores arrays (not flattened)', () => {
-    expect(flattenObject({ items: ['first', 'second'] })).toEqual({});
+  it("ignores arrays (not flattened)", () => {
+    expect(flattenObject({ items: ["first", "second"] })).toEqual({});
   });
 
-  it('ignores mixed arrays and objects', () => {
-    expect(flattenObject({ items: [{ name: 'a' }, { name: 'b' }] })).toEqual({});
+  it("ignores mixed arrays and objects", () => {
+    expect(flattenObject({ items: [{ name: "a" }, { name: "b" }] })).toEqual({});
   });
 
-  it('ignores null values', () => {
+  it("ignores null values", () => {
     expect(flattenObject({ a: null })).toEqual({});
   });
 
-  it('ignores numeric values', () => {
+  it("ignores numeric values", () => {
     expect(flattenObject({ count: 42 })).toEqual({});
   });
 
-  it('ignores boolean values', () => {
+  it("ignores boolean values", () => {
     expect(flattenObject({ enabled: true })).toEqual({});
   });
 
-  it('preserves unicode values', () => {
-    expect(flattenObject({ greeting: 'Héllo 🌍' })).toEqual({
-      greeting: 'Héllo 🌍',
+  it("preserves unicode values", () => {
+    expect(flattenObject({ greeting: "Héllo 🌍" })).toEqual({
+      greeting: "Héllo 🌍",
     });
   });
 });
 
-describe('unflattenObject', () => {
-  it('rebuilds nested structure from dot-notation keys', () => {
-    expect(unflattenObject({ 'validation.email': 'Email' })).toEqual({
-      validation: { email: 'Email' },
+describe("unflattenObject", () => {
+  it("rebuilds nested structure from dot-notation keys", () => {
+    expect(unflattenObject({ "validation.email": "Email" })).toEqual({
+      validation: { email: "Email" },
     });
   });
 
-  it('round-trips with flattenObject', () => {
-    const original = { a: { b: { c: '1' }, d: '2' } };
+  it("round-trips with flattenObject", () => {
+    const original = { a: { b: { c: "1" }, d: "2" } };
     expect(unflattenObject(flattenObject(original))).toEqual(original);
   });
 
-  it('handles deeply nested keys', () => {
-    expect(
-      unflattenObject({ 'a.b.c.d.e': 'deep' }),
-    ).toEqual({ a: { b: { c: { d: { e: 'deep' } } } } });
+  it("handles deeply nested keys", () => {
+    expect(unflattenObject({ "a.b.c.d.e": "deep" })).toEqual({
+      a: { b: { c: { d: { e: "deep" } } } },
+    });
   });
 
-  it('treats numeric keys as object properties, not array indices', () => {
-    expect(unflattenObject({ 'items.0': 'first', 'items.1': 'second' })).toEqual({
-      items: { '0': 'first', '1': 'second' },
+  it("treats numeric keys as object properties, not array indices", () => {
+    expect(unflattenObject({ "items.0": "first", "items.1": "second" })).toEqual({
+      items: { "0": "first", "1": "second" },
     });
   });
 
-  it('handles empty flat object', () => {
+  it("handles empty flat object", () => {
     expect(unflattenObject({})).toEqual({});
   });
 
-  it('handles single-level keys', () => {
-    expect(unflattenObject({ a: '1', b: '2' })).toEqual({ a: '1', b: '2' });
+  it("handles single-level keys", () => {
+    expect(unflattenObject({ a: "1", b: "2" })).toEqual({ a: "1", b: "2" });
   });
 });
 
-describe('diffKeys', () => {
-  it('returns keys present in source but missing in target', () => {
-    expect(diffKeys({ a: '1', b: '2' }, { a: '1' })).toEqual(['b']);
+describe("diffKeys", () => {
+  it("returns keys present in source but missing in target", () => {
+    expect(diffKeys({ a: "1", b: "2" }, { a: "1" })).toEqual(["b"]);
   });
 
-  it('returns [] when target has all source keys', () => {
-    expect(diffKeys({ a: '1' }, { a: '1', b: '2' })).toEqual([]);
+  it("returns [] when target has all source keys", () => {
+    expect(diffKeys({ a: "1" }, { a: "1", b: "2" })).toEqual([]);
   });
 
-  it('returns all keys when target is empty', () => {
-    expect(diffKeys({ a: '1', b: '2' }, {})).toEqual(['a', 'b']);
+  it("returns all keys when target is empty", () => {
+    expect(diffKeys({ a: "1", b: "2" }, {})).toEqual(["a", "b"]);
   });
 
-  it('returns [] when source is empty', () => {
-    expect(diffKeys({}, { a: '1' })).toEqual([]);
+  it("returns [] when source is empty", () => {
+    expect(diffKeys({}, { a: "1" })).toEqual([]);
   });
 
-  it('handles keys with different values', () => {
-    expect(diffKeys({ a: '1' }, { a: '2' })).toEqual([]);
+  it("handles keys with different values", () => {
+    expect(diffKeys({ a: "1" }, { a: "2" })).toEqual([]);
   });
 
-  it('handles nested flattened keys', () => {
-    expect(diffKeys({ 'a.b': '1', 'a.c': '2' }, { 'a.b': '1' })).toEqual(['a.c']);
+  it("handles nested flattened keys", () => {
+    expect(diffKeys({ "a.b": "1", "a.c": "2" }, { "a.b": "1" })).toEqual(["a.c"]);
   });
 });

package/src/keys/flatten.ts

@@ -1,29 +1,27 @@
 export function flattenObject(
   input: Readonly<Record<string, unknown>>,
-  prefix = '',
+  prefix = "",
 ): Record<string, string> {
   const output: Record<string, string> = {};
   for (const [key, value] of Object.entries(input)) {
-    const fullKey = prefix === '' ? key : `${prefix}.${key}`;
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+    const fullKey = prefix === "" ? key : `${prefix}.${key}`;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
       Object.assign(output, flattenObject(value as Record<string, unknown>, fullKey));
-    } else if (typeof value === 'string') {
+    } else if (typeof value === "string") {
       output[fullKey] = value;
     }
   }
   return output;
 }
 
-export function unflattenObject(
-  input: Readonly<Record<string, string>>,
-): Record<string, unknown> {
+export function unflattenObject(input: Readonly<Record<string, string>>): Record<string, unknown> {
   const output: Record<string, unknown> = {};
   for (const [dottedKey, value] of Object.entries(input)) {
-    const segments = dottedKey.split('.');
+    const segments = dottedKey.split(".");
     let cursor = output;
     for (let i = 0; i < segments.length - 1; i++) {
       const segment = segments[i]!;
-      if (typeof cursor[segment] !== 'object' || cursor[segment] === null) {
+      if (typeof cursor[segment] !== "object" || cursor[segment] === null) {
         cursor[segment] = {};
       }
       cursor = cursor[segment] as Record<string, unknown>;

package/src/sdk/file-io.test.ts

@@ -1,7 +1,7 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Layer } from 'effect';
-import { FileSystem, Path } from '@effect/platform';
-import { readFileIfExists, writeFileEnsuringDir } from './file-io.js';
+import { describe, expect, it } from "vitest";
+import { Effect, Layer } from "effect";
+import { FileSystem, Path } from "@effect/platform";
+import { readFileIfExists, writeFileEnsuringDir } from "./file-io.js";
 
 function makeFsLayer(files: Record<string, string>) {
   const stub = FileSystem.makeNoop({
@@ -9,9 +9,7 @@ function makeFsLayer(files: Record<string, string>) {
     readFileString: (path) =>
       path in files
         ? Effect.succeed(files[path]!)
-        : Effect.fail(
-            new Error(`ENOENT: ${path}`) as never,
-          ),
+        : Effect.fail(new Error(`ENOENT: ${path}`) as never),
     writeFileString: (path, content) => {
       files[path] = content;
       return Effect.void;
@@ -21,119 +19,109 @@ function makeFsLayer(files: Record<string, string>) {
   return Layer.succeed(FileSystem.FileSystem, stub);
 }
 
-describe('readFileIfExists', () => {
-  it('returns content when file exists', async () => {
-    const files = { '/a/b.txt': 'hello' };
-    const program = readFileIfExists('/a/b.txt').pipe(
-      Effect.provide(makeFsLayer(files)),
-    );
+describe("readFileIfExists", () => {
+  it("returns content when file exists", async () => {
+    const files = { "/a/b.txt": "hello" };
+    const program = readFileIfExists("/a/b.txt").pipe(Effect.provide(makeFsLayer(files)));
     const result = await Effect.runPromise(program);
-    expect(result).toBe('hello');
+    expect(result).toBe("hello");
   });
 
-  it('returns null when file does not exist', async () => {
-    const program = readFileIfExists('/a/missing.txt').pipe(
-      Effect.provide(makeFsLayer({})),
-    );
+  it("returns null when file does not exist", async () => {
+    const program = readFileIfExists("/a/missing.txt").pipe(Effect.provide(makeFsLayer({})));
     const result = await Effect.runPromise(program);
     expect(result).toBeNull();
   });
 
-  it('returns null for empty file system', async () => {
-    const program = readFileIfExists('/any/path.txt').pipe(
-      Effect.provide(makeFsLayer({})),
-    );
+  it("returns null for empty file system", async () => {
+    const program = readFileIfExists("/any/path.txt").pipe(Effect.provide(makeFsLayer({})));
     const result = await Effect.runPromise(program);
     expect(result).toBeNull();
   });
 
-  it('returns content for deeply nested path', async () => {
-    const files = { '/very/deep/nested/file.txt': 'deep content' };
-    const program = readFileIfExists('/very/deep/nested/file.txt').pipe(
+  it("returns content for deeply nested path", async () => {
+    const files = { "/very/deep/nested/file.txt": "deep content" };
+    const program = readFileIfExists("/very/deep/nested/file.txt").pipe(
       Effect.provide(makeFsLayer(files)),
     );
     const result = await Effect.runPromise(program);
-    expect(result).toBe('deep content');
+    expect(result).toBe("deep content");
   });
 
-  it('handles unicode content', async () => {
-    const files = { '/unicode.txt': 'Héllo 🌍 — 日本語' };
-    const program = readFileIfExists('/unicode.txt').pipe(
-      Effect.provide(makeFsLayer(files)),
-    );
+  it("handles unicode content", async () => {
+    const files = { "/unicode.txt": "Héllo 🌍 — 日本語" };
+    const program = readFileIfExists("/unicode.txt").pipe(Effect.provide(makeFsLayer(files)));
     const result = await Effect.runPromise(program);
-    expect(result).toBe('Héllo 🌍 — 日本語');
+    expect(result).toBe("Héllo 🌍 — 日本語");
   });
 
-  it('handles empty string content', async () => {
-    const files = { '/empty.txt': '' };
-    const program = readFileIfExists('/empty.txt').pipe(
-      Effect.provide(makeFsLayer(files)),
-    );
+  it("handles empty string content", async () => {
+    const files = { "/empty.txt": "" };
+    const program = readFileIfExists("/empty.txt").pipe(Effect.provide(makeFsLayer(files)));
     const result = await Effect.runPromise(program);
-    expect(result).toBe('');
+    expect(result).toBe("");
   });
 });
 
-describe('writeFileEnsuringDir', () => {
-  it('writes content and creates parent directories', async () => {
+describe("writeFileEnsuringDir", () => {
+  it("writes content and creates parent directories", async () => {
     const files: Record<string, string> = {};
-    const program = writeFileEnsuringDir('/a/b/c.txt', 'content').pipe(
+    const program = writeFileEnsuringDir("/a/b/c.txt", "content").pipe(
       Effect.provide(makeFsLayer(files)),
       Effect.provide(Path.layer),
     );
     await Effect.runPromise(program);
-    expect(files['/a/b/c.txt']).toBe('content');
+    expect(files["/a/b/c.txt"]).toBe("content");
   });
 
-  it('overwrites existing file', async () => {
-    const files: Record<string, string> = { '/existing.txt': 'old' };
-    const program = writeFileEnsuringDir('/existing.txt', 'new').pipe(
+  it("overwrites existing file", async () => {
+    const files: Record<string, string> = { "/existing.txt": "old" };
+    const program = writeFileEnsuringDir("/existing.txt", "new").pipe(
       Effect.provide(makeFsLayer(files)),
       Effect.provide(Path.layer),
     );
     await Effect.runPromise(program);
-    expect(files['/existing.txt']).toBe('new');
+    expect(files["/existing.txt"]).toBe("new");
   });
 
-  it('handles deeply nested paths', async () => {
+  it("handles deeply nested paths", async () => {
     const files: Record<string, string> = {};
-    const program = writeFileEnsuringDir('/a/b/c/d/e.txt', 'nested').pipe(
+    const program = writeFileEnsuringDir("/a/b/c/d/e.txt", "nested").pipe(
       Effect.provide(makeFsLayer(files)),
       Effect.provide(Path.layer),
     );
     await Effect.runPromise(program);
-    expect(files['/a/b/c/d/e.txt']).toBe('nested');
+    expect(files["/a/b/c/d/e.txt"]).toBe("nested");
   });
 
-  it('handles empty content', async () => {
+  it("handles empty content", async () => {
     const files: Record<string, string> = {};
-    const program = writeFileEnsuringDir('/empty.txt', '').pipe(
+    const program = writeFileEnsuringDir("/empty.txt", "").pipe(
       Effect.provide(makeFsLayer(files)),
       Effect.provide(Path.layer),
     );
     await Effect.runPromise(program);
-    expect(files['/empty.txt']).toBe('');
+    expect(files["/empty.txt"]).toBe("");
   });
 
-  it('handles unicode content', async () => {
+  it("handles unicode content", async () => {
     const files: Record<string, string> = {};
-    const content = 'Héllo 🌍 — 日本語';
-    const program = writeFileEnsuringDir('/unicode.txt', content).pipe(
+    const content = "Héllo 🌍 — 日本語";
+    const program = writeFileEnsuringDir("/unicode.txt", content).pipe(
       Effect.provide(makeFsLayer(files)),
       Effect.provide(Path.layer),
     );
     await Effect.runPromise(program);
-    expect(files['/unicode.txt']).toBe(content);
+    expect(files["/unicode.txt"]).toBe(content);
   });
 
-  it('handles paths with spaces', async () => {
+  it("handles paths with spaces", async () => {
     const files: Record<string, string> = {};
-    const program = writeFileEnsuringDir('/path with spaces/file.txt', 'content').pipe(
+    const program = writeFileEnsuringDir("/path with spaces/file.txt", "content").pipe(
       Effect.provide(makeFsLayer(files)),
       Effect.provide(Path.layer),
     );
     await Effect.runPromise(program);
-    expect(files['/path with spaces/file.txt']).toBe('content');
+    expect(files["/path with spaces/file.txt"]).toBe("content");
   });
 });