@dialekt/adapter-paraglide 0.1.0

package/TESTING.md

@@ -0,0 +1,28 @@
+# @dialekt/adapter-paraglide Testing Guide
+
+## Tested Areas Map
+
+| Export | Test File | Status |
+|--------|-----------|--------|
+| `paraglide()` adapter | `src/adapter.test.ts` | ✅ |
+| `readMessageFile` / `writeMessageFile` | `src/message-file.test.ts` | ✅ |
+| `findUnusedParaglideKeys` | `src/unused-keys.test.ts` | ✅ |
+
+## Known Coverage Gaps
+
+- Invalid JSON in message files — `readMessageFile` would throw but no explicit unhappy-path test
+- Nested objects in Paraglide JSON — `readMessageFile` flattens them but no explicit test for deeply nested structures
+- `scanPaths` edge cases with binary files or very large files
+
+## Specialties & Watch-Outs
+
+- Tests create real temp directories via `node:fs` and clean up with `rmSync`.
+- `writeMessageFile` preserves `$schema` and other meta keys by reading existing file first.
+- `findUnusedParaglideKeys` matches `m.keyName()` and `m.keyName` (without parens) patterns.
+- The adapter always reports exactly one resource (`messages`).
+
+## Running Tests
+
+```bash
+pnpm --filter @dialekt/adapter-paraglide test
+```

package/dist/index.d.mts

@@ -0,0 +1,10 @@
+import { TranslationAdapter } from "dialekt";
+
+//#region src/adapter.d.ts
+interface ParaglideAdapterOptions {
+  readonly messagesDir: string;
+  readonly scanPaths?: readonly string[];
+}
+declare function paraglide(options: ParaglideAdapterOptions): TranslationAdapter;
+//#endregion
+export { type ParaglideAdapterOptions, paraglide };

package/dist/index.mjs

@@ -0,0 +1,127 @@
+import { Effect } from "effect";
+import { Path } from "@effect/platform/Path";
+import { FileSystem } from "@effect/platform/FileSystem";
+import { AdapterReadError, AdapterWriteError, NodePlatformLayer, flattenObject, unflattenObject } from "dialekt";
+import { FileSystem as FileSystem$1, Path as Path$1 } from "@effect/platform";
+//#region src/message-file.ts
+function readMessageFile(path) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem$1.FileSystem;
+		if (!(yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false)))) return {
+			translations: {},
+			meta: {}
+		};
+		const content = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => "{}"));
+		const parsed = yield* Effect.try({
+			try: () => JSON.parse(content),
+			catch: () => ({})
+		}).pipe(Effect.orElseSucceed(() => ({})));
+		const meta = {};
+		const translations = {};
+		for (const [key, value] of Object.entries(parsed)) if (key.startsWith("$")) meta[key] = value;
+		else if (typeof value === "string") translations[key] = value;
+		else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			const flattened = flattenObject(value);
+			for (const [flatKey, flatValue] of Object.entries(flattened)) if (typeof flatValue === "string") translations[`${key}.${flatKey}`] = flatValue;
+		}
+		return {
+			translations,
+			meta
+		};
+	});
+}
+function writeMessageFile(path, translations, meta) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem$1.FileSystem;
+		const dir = (yield* Path$1.Path).dirname(path);
+		yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect.orElseSucceed(() => void 0));
+		const unflattened = unflattenObject(translations);
+		const output = { ...meta };
+		for (const [key, value] of Object.entries(unflattened)) output[key] = value;
+		yield* fs.writeFileString(path, JSON.stringify(output, null, 2) + "\n").pipe(Effect.orElseSucceed(() => void 0));
+	});
+}
+//#endregion
+//#region src/unused-keys.ts
+function findUnusedParaglideKeys(scanPaths, keys) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		const referenced = /* @__PURE__ */ new Set();
+		for (const scanPath of scanPaths) {
+			if (!(yield* fs.exists(scanPath).pipe(Effect.orElseSucceed(() => false)))) continue;
+			const entries = yield* fs.readDirectory(scanPath, { recursive: true }).pipe(Effect.orElseSucceed(() => []));
+			for (const relativePath of entries) {
+				if (!relativePath.endsWith(".ts") && !relativePath.endsWith(".tsx") && !relativePath.endsWith(".js") && !relativePath.endsWith(".jsx") && !relativePath.endsWith(".svelte") && !relativePath.endsWith(".vue")) continue;
+				const filePath = path.join(scanPath, relativePath);
+				const content = yield* fs.readFileString(filePath).pipe(Effect.orElseSucceed(() => ""));
+				for (const key of keys) if (new RegExp(`\\bm\\.${key}\\b`).test(content)) referenced.add(key);
+			}
+		}
+		return keys.filter((key) => !referenced.has(key));
+	}).pipe(Effect.mapError((cause) => new AdapterReadError({
+		adapter: "paraglide",
+		locale: "",
+		resource: "messages",
+		cause
+	})));
+}
+//#endregion
+//#region src/adapter.ts
+function paraglide(options) {
+	const { messagesDir, scanPaths = [] } = options;
+	return {
+		name: "paraglide",
+		capabilities: {
+			canCreateResource: true,
+			unusedKeyDetection: true
+		},
+		listLocales: () => Effect.gen(function* () {
+			const fs = yield* FileSystem;
+			yield* Path;
+			if (!(yield* fs.exists(messagesDir).pipe(Effect.orElseSucceed(() => false)))) return [];
+			const entries = yield* fs.readDirectory(messagesDir).pipe(Effect.orElseSucceed(() => []));
+			const locales = [];
+			for (const entry of entries) if (entry.endsWith(".json")) locales.push(entry.replace(/\.json$/, ""));
+			return locales;
+		}).pipe(Effect.mapError((cause) => new AdapterReadError({
+			adapter: "paraglide",
+			locale: "",
+			resource: "",
+			cause
+		})), Effect.provide([NodePlatformLayer])),
+		listResources: () => Effect.succeed([{
+			key: "messages",
+			label: "messages"
+		}]),
+		readResource: (locale, resource) => Effect.gen(function* () {
+			return (yield* readMessageFile((yield* Path).join(messagesDir, `${locale}.json`)).pipe(Effect.mapError((cause) => new AdapterReadError({
+				adapter: "paraglide",
+				locale,
+				resource: resource.key,
+				cause
+			})))).translations;
+		}).pipe(Effect.provide([NodePlatformLayer])),
+		writeResource: (locale, resource, entries) => Effect.gen(function* () {
+			const filePath = (yield* Path).join(messagesDir, `${locale}.json`);
+			yield* writeMessageFile(filePath, entries, (yield* readMessageFile(filePath).pipe(Effect.orElseSucceed(() => ({
+				translations: {},
+				meta: {}
+			})))).meta).pipe(Effect.mapError((cause) => new AdapterWriteError({
+				adapter: "paraglide",
+				locale,
+				resource: resource.key,
+				cause
+			})));
+		}).pipe(Effect.provide([NodePlatformLayer])),
+		findUnusedKeys: (locale, resource) => Effect.gen(function* () {
+			const path = yield* Path;
+			return yield* findUnusedParaglideKeys(scanPaths.length > 0 ? scanPaths : [path.resolve(messagesDir, "..")], yield* Effect.gen(function* () {
+				const map = yield* paraglide(options).readResource(locale, resource);
+				return Object.keys(map);
+			}));
+		}).pipe(Effect.provide([NodePlatformLayer]))
+	};
+}
+//#endregion
+export { paraglide };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@dialekt/adapter-paraglide",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@effect/platform": "^0.96.0",
+    "effect": "^3.21.0",
+    "dialekt": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.8.0",
+    "vitest": "^4.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/adapter.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, it } from 'vitest';
+import { Effect } from 'effect';
+import { NodePlatformLayer } from 'dialekt';
+import { paraglide } from './adapter.js';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('paraglide adapter', () => {
+  const testDir = join(tmpdir(), `paraglide-adapter-test-${Date.now()}`);
+
+  it('reads a message resource', async () => {
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(join(testDir, 'en.json'), JSON.stringify({ greeting: 'Hello' }));
+
+    const adapter = paraglide({ messagesDir: testDir, scanPaths: [testDir] });
+    const program = adapter.readResource('en', { key: 'messages', label: 'messages' }).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual({ greeting: 'Hello' });
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('lists locales from filenames', async () => {
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(join(testDir, 'en.json'), '{}');
+    writeFileSync(join(testDir, 'de.json'), '{}');
+
+    const adapter = paraglide({ messagesDir: testDir });
+    const program = adapter.listLocales().pipe(Effect.provide(NodePlatformLayer));
+    const result = await Effect.runPromise(program);
+    expect(result).toContain('en');
+    expect(result).toContain('de');
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('lists exactly one resource', async () => {
+    const adapter = paraglide({ messagesDir: testDir });
+    const program = adapter.listResources('en').pipe(Effect.provide(NodePlatformLayer));
+    const result = await Effect.runPromise(program);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ key: 'messages', label: 'messages' });
+  });
+
+  it('round-trips write and read preserving meta', async () => {
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(
+      join(testDir, 'de.json'),
+      JSON.stringify({ $schema: 'https://inlang.com/schema', greeting: 'Hallo' }),
+    );
+
+    const adapter = paraglide({ messagesDir: testDir });
+    const writeProgram = adapter
+      .writeResource('de', { key: 'messages', label: 'messages' }, { greeting: 'Hallo!', farewell: 'Tschüss' })
+      .pipe(Effect.provide(NodePlatformLayer));
+    await Effect.runPromise(writeProgram);
+
+    const readProgram = adapter.readResource('de', { key: 'messages', label: 'messages' }).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
+    const result = await Effect.runPromise(readProgram);
+    expect(result).toEqual({ greeting: 'Hallo!', farewell: 'Tschüss' });
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('finds unused keys', async () => {
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(join(testDir, 'en.json'), JSON.stringify({ greeting: 'Hello', farewell: 'Goodbye' }));
+    mkdirSync(join(testDir, 'src'), { recursive: true });
+    writeFileSync(join(testDir, 'src', 'page.ts'), 'm.greeting();');
+
+    const adapter = paraglide({ messagesDir: testDir, scanPaths: [join(testDir, 'src')] });
+    const program = adapter
+      .findUnusedKeys!('en', { key: 'messages', label: 'messages' })
+      .pipe(Effect.provide(NodePlatformLayer));
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual(['farewell']);
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('returns empty for missing locale file', async () => {
+    mkdirSync(testDir, { recursive: true });
+
+    const adapter = paraglide({ messagesDir: testDir });
+    const program = adapter.readResource('missing', { key: 'messages', label: 'messages' }).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual({});
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('handles empty messages directory', async () => {
+    mkdirSync(testDir, { recursive: true });
+
+    const adapter = paraglide({ messagesDir: testDir });
+    const program = adapter.listLocales().pipe(Effect.provide(NodePlatformLayer));
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual([]);
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('handles capabilities flags', () => {
+    const adapter = paraglide({ messagesDir: testDir });
+    expect(adapter.capabilities.canCreateResource).toBe(true);
+    expect(adapter.capabilities.unusedKeyDetection).toBe(true);
+  });
+
+  it('reports adapter name', () => {
+    const adapter = paraglide({ messagesDir: testDir });
+    expect(adapter.name).toBe('paraglide');
+  });
+
+  it('ignores non-JSON files', async () => {
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(join(testDir, 'README.md'), '# Messages');
+    writeFileSync(join(testDir, 'en.json'), '{}');
+
+    const adapter = paraglide({ messagesDir: testDir });
+    const program = adapter.listLocales().pipe(Effect.provide(NodePlatformLayer));
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual(['en']);
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('preserves meta keys on write', async () => {
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(
+      join(testDir, 'de.json'),
+      JSON.stringify({ $schema: 'https://inlang.com/schema', module: 'messages' }),
+    );
+
+    const adapter = paraglide({ messagesDir: testDir });
+    const writeProgram = adapter
+      .writeResource('de', { key: 'messages', label: 'messages' }, { hello: 'Hallo' })
+      .pipe(Effect.provide(NodePlatformLayer));
+    await Effect.runPromise(writeProgram);
+
+    const readProgram = adapter.readResource('de', { key: 'messages', label: 'messages' }).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
+    const result = await Effect.runPromise(readProgram);
+    expect(result).toEqual({ hello: 'Hallo' });
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+});

package/src/adapter.ts

@@ -0,0 +1,116 @@
+import { Effect } from 'effect';
+import { Path } from '@effect/platform/Path';
+import { FileSystem } from '@effect/platform/FileSystem';
+import type {
+  ResourceRef,
+  TranslationAdapter,
+  AdapterReadError,
+  AdapterWriteError,
+} from 'dialekt';
+import {
+  AdapterReadError as AdapterReadErrorClass,
+  AdapterWriteError as AdapterWriteErrorClass,
+  NodePlatformLayer,
+} from 'dialekt';
+import { readMessageFile, writeMessageFile } from './message-file.js';
+import { findUnusedParaglideKeys } from './unused-keys.js';
+
+export interface ParaglideAdapterOptions {
+  readonly messagesDir: string;
+  readonly scanPaths?: readonly string[];
+}
+
+export function paraglide(options: ParaglideAdapterOptions): TranslationAdapter {
+  const { messagesDir, scanPaths = [] } = options;
+
+  return {
+    name: 'paraglide',
+    capabilities: {
+      canCreateResource: true,
+      unusedKeyDetection: true,
+    },
+
+    listLocales: () =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem;
+        const path = yield* Path;
+        const exists = yield* fs.exists(messagesDir).pipe(Effect.orElseSucceed(() => false));
+        if (!exists) return [];
+        const entries = yield* fs.readDirectory(messagesDir).pipe(
+          Effect.orElseSucceed(() => [] as string[]),
+        );
+        const locales: string[] = [];
+        for (const entry of entries) {
+          if (entry.endsWith('.json')) {
+            locales.push(entry.replace(/\.json$/, ''));
+          }
+        }
+        return locales;
+      }).pipe(
+        Effect.mapError(
+          (cause) =>
+            new AdapterReadErrorClass({
+              adapter: 'paraglide',
+              locale: '',
+              resource: '',
+              cause,
+            }) as AdapterReadError,
+        ),
+        Effect.provide([NodePlatformLayer]),
+      ) as Effect.Effect<readonly string[], AdapterReadError, never>,
+
+    listResources: () =>
+      Effect.succeed([{ key: 'messages', label: 'messages' }]),
+
+    readResource: (locale, resource) =>
+      Effect.gen(function* () {
+        const path = yield* Path;
+        const filePath = path.join(messagesDir, `${locale}.json`);
+        const result = yield* readMessageFile(filePath).pipe(
+          Effect.mapError(
+            (cause) =>
+              new AdapterReadErrorClass({
+                adapter: 'paraglide',
+                locale,
+                resource: resource.key,
+                cause,
+              }) as AdapterReadError,
+          ),
+        );
+        return result.translations;
+      }).pipe(Effect.provide([NodePlatformLayer])) as Effect.Effect<Record<string, string>, AdapterReadError, never>,
+
+    writeResource: (locale, resource, entries) =>
+      Effect.gen(function* () {
+        const path = yield* Path;
+        const filePath = path.join(messagesDir, `${locale}.json`);
+        const existing = yield* readMessageFile(filePath).pipe(Effect.orElseSucceed(() => ({
+          translations: {},
+          meta: {},
+        })));
+        yield* writeMessageFile(filePath, entries, existing.meta).pipe(
+          Effect.mapError(
+            (cause) =>
+              new AdapterWriteErrorClass({
+                adapter: 'paraglide',
+                locale,
+                resource: resource.key,
+                cause,
+              }) as AdapterWriteError,
+          ),
+        );
+      }).pipe(Effect.provide([NodePlatformLayer])) as Effect.Effect<void, AdapterWriteError, never>,
+
+    findUnusedKeys: (locale, resource) =>
+      Effect.gen(function* () {
+        const path = yield* Path;
+        const adapterScanPaths =
+          scanPaths.length > 0 ? scanPaths : [path.resolve(messagesDir, '..')];
+        const keys = yield* Effect.gen(function* () {
+          const map = yield* paraglide(options).readResource(locale, resource);
+          return Object.keys(map);
+        });
+        return yield* findUnusedParaglideKeys(adapterScanPaths, keys);
+      }).pipe(Effect.provide([NodePlatformLayer])) as Effect.Effect<readonly string[], AdapterReadError, never>,
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { paraglide } from './adapter.js';
+export type { ParaglideAdapterOptions } from './adapter.js';

package/src/message-file.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { Effect, Layer } from 'effect';
+import { FileSystem, Path } from '@effect/platform';
+import { readMessageFile, writeMessageFile } from './message-file.js';
+
+function makeFsLayer(files: Record<string, string>) {
+  const stub = FileSystem.makeNoop({
+    exists: (path) => Effect.succeed(path in files),
+    readFileString: (path) =>
+      path in files ? Effect.succeed(files[path]!) : Effect.fail(new Error('ENOENT') as never),
+    writeFileString: (path, content) => {
+      files[path] = content;
+      return Effect.void;
+    },
+    makeDirectory: () => Effect.void,
+  });
+  return Layer.succeed(FileSystem.FileSystem, stub);
+}
+
+describe('readMessageFile', () => {
+  it('reads flat translations and preserves meta keys', async () => {
+    const files = {
+      '/messages/en.json': JSON.stringify({
+        $schema: 'https://inlang.com/schema',
+        greeting: 'Hello',
+        farewell: 'Goodbye',
+      }),
+    };
+    const program = readMessageFile('/messages/en.json').pipe(Effect.provide(makeFsLayer(files)));
+    const result = await Effect.runPromise(program);
+    expect(result.translations).toEqual({ greeting: 'Hello', farewell: 'Goodbye' });
+    expect(result.meta).toEqual({ $schema: 'https://inlang.com/schema' });
+  });
+
+  it('returns empty for missing file', async () => {
+    const program = readMessageFile('/messages/missing.json').pipe(Effect.provide(makeFsLayer({})));
+    const result = await Effect.runPromise(program);
+    expect(result.translations).toEqual({});
+    expect(result.meta).toEqual({});
+  });
+
+  it('flattens nested objects', async () => {
+    const files = {
+      '/messages/en.json': JSON.stringify({
+        nav: { home: 'Home', about: 'About' },
+      }),
+    };
+    const program = readMessageFile('/messages/en.json').pipe(Effect.provide(makeFsLayer(files)));
+    const result = await Effect.runPromise(program);
+    expect(result.translations).toEqual({ 'nav.home': 'Home', 'nav.about': 'About' });
+  });
+});
+
+describe('writeMessageFile', () => {
+  it('round-trips translations and meta', async () => {
+    const files: Record<string, string> = {};
+    const program = writeMessageFile(
+      '/messages/de.json',
+      { greeting: 'Hallo' },
+      { $schema: 'https://inlang.com/schema' },
+    ).pipe(Effect.provide(makeFsLayer(files)), Effect.provide(Path.layer));
+    await Effect.runPromise(program);
+    expect(files['/messages/de.json']).toContain('Hallo');
+    expect(files['/messages/de.json']).toContain('$schema');
+  });
+});

package/src/message-file.ts

@@ -0,0 +1,68 @@
+import { FileSystem, Path } from '@effect/platform';
+import { Effect } from 'effect';
+import { flattenObject, unflattenObject } from 'dialekt';
+
+export interface MessageFileResult {
+  readonly translations: Record<string, string>;
+  readonly meta: Record<string, unknown>;
+}
+
+export function readMessageFile(
+  path: string,
+): Effect.Effect<MessageFileResult, never, FileSystem.FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const exists = yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false));
+    if (!exists) {
+      return { translations: {}, meta: {} };
+    }
+    const content = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => '{}'));
+    const parsed = yield* Effect.try({
+      try: () => JSON.parse(content) as Record<string, unknown>,
+      catch: () => ({}),
+    }).pipe(Effect.orElseSucceed(() => ({})));
+
+    const meta: Record<string, unknown> = {};
+    const translations: Record<string, string> = {};
+
+    for (const [key, value] of Object.entries(parsed)) {
+      if (key.startsWith('$')) {
+        meta[key] = value;
+      } else if (typeof value === 'string') {
+        translations[key] = value;
+      } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        const flattened = flattenObject(value as Record<string, unknown>);
+        for (const [flatKey, flatValue] of Object.entries(flattened)) {
+          if (typeof flatValue === 'string') {
+            translations[`${key}.${flatKey}`] = flatValue;
+          }
+        }
+      }
+    }
+
+    return { translations, meta };
+  });
+}
+
+export function writeMessageFile(
+  path: string,
+  translations: Record<string, string>,
+  meta: Record<string, unknown>,
+): Effect.Effect<void, never, FileSystem.FileSystem | Path.Path> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path_ = yield* Path.Path;
+    const dir = path_.dirname(path);
+    yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect.orElseSucceed(() => undefined));
+
+    const unflattened = unflattenObject(translations);
+    const output: Record<string, unknown> = { ...meta };
+    for (const [key, value] of Object.entries(unflattened)) {
+      output[key] = value;
+    }
+
+    yield* fs.writeFileString(path, JSON.stringify(output, null, 2) + '\n').pipe(
+      Effect.orElseSucceed(() => undefined),
+    );
+  });
+}

package/src/unused-keys.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import { Effect } from 'effect';
+import { NodePlatformLayer } from 'dialekt';
+import { findUnusedParaglideKeys } from './unused-keys.js';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('findUnusedParaglideKeys', () => {
+  it('finds keys not referenced in source files', async () => {
+    const dir = join(tmpdir(), `paraglide-unused-${Date.now()}`);
+    mkdirSync(join(dir, 'src'), { recursive: true });
+    writeFileSync(join(dir, 'src', 'page.tsx'), "const t = m.greeting({ name: 'x' });");
+
+    const program = findUnusedParaglideKeys([join(dir, 'src')], ['greeting', 'farewell']).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual(['farewell']);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('finds m.key reference without call parens', async () => {
+    const dir = join(tmpdir(), `paraglide-unused-ref-${Date.now()}`);
+    mkdirSync(join(dir, 'src'), { recursive: true });
+    writeFileSync(join(dir, 'src', 'util.ts'), 'export const msg = m.greeting;');
+
+    const program = findUnusedParaglideKeys([join(dir, 'src')], ['greeting']).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual([]);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('does not treat prefixes as matches', async () => {
+    const dir = join(tmpdir(), `paraglide-unused-prefix-${Date.now()}`);
+    mkdirSync(join(dir, 'src'), { recursive: true });
+    writeFileSync(join(dir, 'src', 'page.ts'), 'm.greeting();');
+
+    const program = findUnusedParaglideKeys([join(dir, 'src')], ['greet', 'greeting']).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual(['greet']);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+});