polen 0.11.0-next.2 → 0.11.0-next.21

package/src/lib/semver/$.test.ts

@@ -0,0 +1,179 @@
+import { Effect } from 'effect'
+import { describe, expect, test } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
+import { Semver } from './$.js'
+
+// dprint-ignore
+Test.suite<{ input: string; sync: boolean; shouldSucceed: boolean; major?: number; minor?: number; patch?: number; prerelease?: (string | number)[]; build?: string[] }>('decoding', [
+  { name: 'creates a valid semver from string',         input: '1.2.3',                    sync: false, shouldSucceed: true,  major: 1, minor: 2, patch: 3 },
+  { name: 'fails on invalid semver string',             input: 'invalid',                  sync: false, shouldSucceed: false },
+  { name: 'creates a valid semver synchronously',       input: '1.2.3-beta.1+build.123',   sync: true,  shouldSucceed: true,  major: 1, minor: 2, patch: 3, prerelease: ['beta', 1], build: ['build', '123'] },
+], async ({ input, sync, shouldSucceed, major, minor, patch, prerelease, build }) => {
+  if (sync) {
+    const version = Semver.decodeSync(input)
+    expect(Semver.getMajor(version)).toBe(major)
+    expect(Semver.getMinor(version)).toBe(minor)
+    expect(Semver.getPatch(version)).toBe(patch)
+    if (prerelease) {
+      expect(Semver.getPrerelease(version)).toEqual(prerelease)
+    }
+    if (build) {
+      expect(Semver.getBuild(version)).toEqual(build)
+    }
+  } else {
+    if (shouldSucceed) {
+      const version = Semver.decodeSync(input)
+      expect(Semver.getMajor(version)).toBe(major)
+      expect(Semver.getMinor(version)).toBe(minor)
+      expect(Semver.getPatch(version)).toBe(patch)
+    } else {
+      await expect(Effect.runPromise(Semver.decode(input))).rejects.toThrow()
+    }
+  }
+})
+
+// dprint-ignore
+Test.suite<{ version: string; expectedTag: string; isOfficial: boolean; isPreRelease: boolean; build?: string[] }>('discriminated union', [
+  { name: 'correctly identifies official releases',                                                    version: '1.2.3',                                                                                  expectedTag: 'SemverOfficialRelease', isOfficial: true,  isPreRelease: false },
+  { name: 'correctly identifies pre-releases',                                                         version: '1.2.3-beta',                                                                             expectedTag: 'SemverPreRelease',      isOfficial: false, isPreRelease: true },
+  { name: 'handles build metadata on official release',                                                version: '1.2.3+build.123',                                                                        expectedTag: 'SemverOfficialRelease', isOfficial: true,  isPreRelease: false, build: ['build', '123'] },
+  { name: 'handles build metadata on pre-release',                                                     version: '1.2.3-beta+build.123',                                                                   expectedTag: 'SemverPreRelease',      isOfficial: false, isPreRelease: true,  build: ['build', '123'] },
+], ({ version, expectedTag, isOfficial, isPreRelease, build }) => {
+  const semver = Semver.decodeSync(version)
+  expect(semver._tag).toBe(expectedTag)
+  expect(Semver.OfficialRelease.is(semver)).toBe(isOfficial)
+  expect(Semver.PreRelease.is(semver)).toBe(isPreRelease)
+  if (build) {
+    expect(Semver.getBuild(semver)).toEqual(build)
+  }
+})
+
+// dprint-ignore
+Test.suite<{ version: string; expected: string }>('pattern matching', [
+  { name: 'matches on official release',                                                               version: '1.2.3',                                                                                  expected: 'Official: 1.2.3' },
+  { name: 'matches on pre-release',                                                                    version: '1.2.3-beta.1',                                                                           expected: 'Pre-release: 1.2.3-beta.1' },
+], ({ version, expected }) => {
+  const semver = Semver.decodeSync(version)
+  const result = Semver.match(
+    (official) => `Official: ${official.major}.${official.minor}.${official.patch}`,
+    (prerelease) =>
+      `Pre-release: ${prerelease.major}.${prerelease.minor}.${prerelease.patch}-${prerelease.prerelease.join('.')}`,
+  )(semver)
+  expect(result).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ method: 'order' | 'greaterThan' | 'lessThan' | 'equivalence'; v1: string; v2: string; expected: number | boolean }>('comparisons', [
+  { name: 'compares versions correctly (v1 < v2)',      method: 'order',        v1: '1.0.0', v2: '2.0.0', expected: -1 },
+  { name: 'compares versions correctly (v1 > v2)',      method: 'order',        v1: '2.0.0', v2: '1.0.0', expected: 1 },
+  { name: 'compares versions correctly (v1 = v2)',      method: 'order',        v1: '1.0.0', v2: '1.0.0', expected: 0 },
+  { name: 'checks greater than (v1 < v2)',              method: 'greaterThan',  v1: '1.0.0', v2: '2.0.0', expected: true },
+  { name: 'checks greater than (v1 > v2)',              method: 'greaterThan',  v1: '2.0.0', v2: '1.0.0', expected: false },
+  { name: 'checks less than (v1 < v2)',                 method: 'lessThan',     v1: '2.0.0', v2: '1.0.0', expected: true },
+  { name: 'checks less than (v1 > v2)',                 method: 'lessThan',     v1: '1.0.0', v2: '2.0.0', expected: false },
+  { name: 'checks equality (equal)',                    method: 'equivalence',  v1: '1.0.0', v2: '1.0.0', expected: true },
+  { name: 'checks equality (not equal)',                method: 'equivalence',  v1: '1.0.0', v2: '2.0.0', expected: false },
+], ({ method, v1, v2, expected }) => {
+  const version1 = Semver.decodeSync(v1)
+  const version2 = Semver.decodeSync(v2)
+  
+  switch (method) {
+    case 'order':
+      expect(Semver.order(version1, version2)).toBe(expected)
+      break
+    case 'greaterThan':
+      expect(Semver.greaterThan(version1)(version2)).toBe(expected)
+      break
+    case 'lessThan':
+      expect(Semver.lessThan(version1)(version2)).toBe(expected)
+      break
+    case 'equivalence':
+      expect(Semver.equivalence(version1, version2)).toBe(expected)
+      break
+  }
+})
+
+// dprint-ignore
+Test.suite<{ value: unknown; expected: boolean }>('validation', [
+  { name: 'validates 1.2.3',                                                                           value: Semver.decodeSync('1.2.3'),                                                                expected: true },
+  { name: 'validates 0.0.0',                                                                           value: Semver.decodeSync('0.0.0'),                                                                expected: true },
+  { name: 'validates 1.2.3-beta',                                                                      value: Semver.decodeSync('1.2.3-beta'),                                                           expected: true },
+  { name: 'validates 1.2.3+build',                                                                     value: Semver.decodeSync('1.2.3+build'),                                                          expected: true },
+  { name: 'rejects plain object',                                                                      value: { major: 1, minor: 2, patch: 3 },                                                          expected: false },
+  { name: 'rejects string',                                                                            value: '1.2.3',                                                                                    expected: false },
+  { name: 'rejects null',                                                                              value: null,                                                                                       expected: false },
+], ({ value, expected }) => {
+  expect(Semver.is(value)).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ level: 'major' | 'minor' | 'patch'; expected: string }>('utilities', [
+  { name: 'increments major version',                                                                  level: 'major',                                                                                    expected: '2.0.0' },
+  { name: 'increments minor version',                                                                  level: 'minor',                                                                                    expected: '1.3.0' },
+  { name: 'increments patch version',                                                                  level: 'patch',                                                                                    expected: '1.2.4' },
+], ({ level, expected }) => {
+  const v = Semver.decodeSync('1.2.3')
+  const incremented = Semver.increment(v, level)
+  expect(incremented.version.toString()).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ test: 'sort' | 'min' | 'max' | 'equivalence'; versions?: string[]; v1?: string; v2?: string; expected: string[] | string | boolean }>('ordering and equivalence', [
+  { name: 'provides correct ordering',                   test: 'sort',        versions: ['2.0.0', '1.0.0', '1.5.0'],         expected: ['1.0.0', '1.5.0', '2.0.0'] },
+  { name: 'finds min',                                   test: 'min',         v1: '1.0.0', v2: '2.0.0',                      expected: '1.0.0' },
+  { name: 'finds max',                                   test: 'max',         v1: '1.0.0', v2: '2.0.0',                      expected: '2.0.0' },
+  { name: 'checks structural equality (equal)',          test: 'equivalence', v1: '1.0.0', v2: '1.0.0',                      expected: true },
+  { name: 'checks structural equality (not equal)',      test: 'equivalence', v1: '1.0.0', v2: '2.0.0',                      expected: false },
+], ({ test, versions, v1, v2, expected }) => {
+  switch (test) {
+    case 'sort': {
+      const versionObjs = versions!.map(v => Semver.decodeSync(v))
+      const sorted = [...versionObjs].sort(Semver.order)
+      expect(sorted.map(v => v.version.toString())).toEqual(expected)
+      break
+    }
+    case 'min': {
+      const version1 = Semver.decodeSync(v1!)
+      const version2 = Semver.decodeSync(v2!)
+      const result = Semver.min(version1, version2)
+      expect(result.version.toString()).toBe(expected)
+      break
+    }
+    case 'max': {
+      const version1 = Semver.decodeSync(v1!)
+      const version2 = Semver.decodeSync(v2!)
+      const result = Semver.max(version1, version2)
+      expect(result.version.toString()).toBe(expected)
+      break
+    }
+    case 'equivalence': {
+      const version1 = Semver.decodeSync(v1!)
+      const version2 = Semver.decodeSync(v2!)
+      expect(Semver.equivalence(version1, version2)).toBe(expected)
+      break
+    }
+  }
+})
+
+// dprint-ignore
+Test.suite<{ major: number; minor: number; patch: number; prerelease?: string | undefined; build?: string | undefined; expected: string | undefined }>('fromParts', [
+  { name: 'creates version from basic parts',                                                          major: 1, minor: 2, patch: 3,                                                                      expected: '1.2.3' },
+  { name: 'creates version with prerelease',                                                           major: 1, minor: 2, patch: 3, prerelease: 'beta.1',                                               expected: '1.2.3-beta.1' },
+  { name: 'creates version with prerelease and build',                                                 major: 1, minor: 2, patch: 3, prerelease: 'beta.1', build: 'build.123',                           expected: '1.2.3-beta.1+build.123' },
+  { name: 'creates version with build only',                                                           major: 1, minor: 2, patch: 3, prerelease: undefined, build: 'build.123',                          expected: '1.2.3+build.123' },
+], ({ major, minor, patch, prerelease, build, expected }) => {
+  const version = Semver.fromParts(major, minor, patch, prerelease, build)
+  expect(version.version.toString()).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ range: string; expected: boolean }>('satisfies', [
+  { name: 'satisfies >=1.0.0',                                                                         range: '>=1.0.0',                                                                                  expected: true },
+  { name: 'satisfies ^1.0.0',                                                                          range: '^1.0.0',                                                                                   expected: true },
+  { name: 'satisfies ~1.2.0',                                                                          range: '~1.2.0',                                                                                   expected: true },
+  { name: 'does not satisfy 2.x',                                                                      range: '2.x',                                                                                      expected: false },
+  { name: 'invalid range returns false',                                                               range: 'invalid range',                                                                            expected: false },
+], ({ range, expected }) => {
+  const v = Semver.decodeSync('1.2.3')
+  expect(Semver.satisfies(v, range)).toBe(expected)
+})

package/src/lib/semver/$.ts

@@ -0,0 +1 @@
+export * as Semver from './semver.js'

package/src/lib/semver/official-release.ts

@@ -0,0 +1,50 @@
+import { S } from '#lib/kit-temp/effect'
+import { Version as VltVersion } from '@vltpkg/semver'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const OfficialRelease = S.TaggedStruct('SemverOfficialRelease', {
+  major: S.Number,
+  minor: S.Number,
+  patch: S.Number,
+  build: S.optional(S.Array(S.String)),
+  version: S.instanceOf(VltVersion),
+}).annotations({
+  identifier: 'OfficialRelease',
+  title: 'Official Release',
+  description: 'A semantic version that is an official release (no pre-release identifiers)',
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type OfficialRelease = typeof OfficialRelease.Type
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = OfficialRelease.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(OfficialRelease)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(OfficialRelease)
+export const decodeSync = S.decodeSync(OfficialRelease)
+export const encode = S.encode(OfficialRelease)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(OfficialRelease)

package/src/lib/semver/pre-release.ts

@@ -0,0 +1,51 @@
+import { S } from '#lib/kit-temp/effect'
+import { Version as VltVersion } from '@vltpkg/semver'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const PreRelease = S.TaggedStruct('SemverPreRelease', {
+  major: S.Number,
+  minor: S.Number,
+  patch: S.Number,
+  prerelease: S.NonEmptyArray(S.Union(S.String, S.Number)),
+  build: S.optional(S.Array(S.String)),
+  version: S.instanceOf(VltVersion),
+}).annotations({
+  identifier: 'PreRelease',
+  title: 'Pre-Release',
+  description: 'A semantic version with pre-release identifiers',
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type PreRelease = typeof PreRelease.Type
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = PreRelease.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(PreRelease)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(PreRelease)
+export const decodeSync = S.decodeSync(PreRelease)
+export const encode = S.encode(PreRelease)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(PreRelease)

package/src/lib/semver/semver.ts

@@ -0,0 +1,200 @@
+import { S } from '#lib/kit-temp/effect'
+import { Range as VltRange, Version as VltVersion } from '@vltpkg/semver'
+import { Effect, Equivalence, Order, ParseResult } from 'effect'
+import * as OfficialRelease from './official-release.js'
+import * as PreRelease from './pre-release.js'
+
+// Re-export member modules as namespaces
+export { OfficialRelease, PreRelease }
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+const SemverUnion = S.Union(OfficialRelease.OfficialRelease, PreRelease.PreRelease).annotations({
+  identifier: 'Semver',
+  title: 'Semantic Version',
+  description: 'A semantic version following SemVer specification',
+})
+
+/**
+ * Schema for semantic version strings using @vltpkg/semver for validation
+ */
+export const Semver = S.transformOrFail(
+  S.String,
+  SemverUnion,
+  {
+    strict: true,
+    decode: (value, _, ast) => {
+      try {
+        const version = VltVersion.parse(value)
+        const base = {
+          major: version.major,
+          minor: version.minor,
+          patch: version.patch,
+          build: version.build && version.build.length > 0 ? version.build : undefined,
+          version,
+        }
+
+        if (version.prerelease && version.prerelease.length > 0) {
+          return ParseResult.succeed({
+            _tag: 'SemverPreRelease' as const,
+            ...base,
+            prerelease: version.prerelease as [string | number, ...(string | number)[]],
+          })
+        } else {
+          return ParseResult.succeed({
+            _tag: 'SemverOfficialRelease' as const,
+            ...base,
+          })
+        }
+      } catch (error) {
+        return ParseResult.fail(
+          new ParseResult.Type(ast, value, `Invalid semver: ${error}`),
+        )
+      }
+    },
+    encode: (semver) => ParseResult.succeed(semver.version.toString()),
+  },
+)
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type Semver = typeof Semver.Type
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+// Note: No make constructor for transform schemas - use fromString or fromParts instead
+
+// ============================================================================
+// Ordering
+// ============================================================================
+
+export const order: Order.Order<Semver> = Order.make((a, b) => a.version.compare(b.version))
+
+export const min = Order.min(order)
+
+export const max = Order.max(order)
+
+export const lessThan = Order.lessThan(order)
+
+export const greaterThan = Order.greaterThan(order)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence: Equivalence.Equivalence<Semver> = Equivalence.make((a, b) =>
+  a.version.compare(b.version) === 0
+)
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Semver)
+
+// ============================================================================
+// State Predicates
+// ============================================================================
+
+// Note: isPreRelease is now handled by checking the _tag or using PreRelease.is
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Semver)
+export const decodeSync = S.decodeSync(Semver)
+export const encode = S.encode(Semver)
+
+// ============================================================================
+// Importers
+// ============================================================================
+
+export const fromString = S.decodeSync(Semver)
+
+/**
+ * Create semver from parts
+ */
+export const fromParts = (
+  major: number,
+  minor: number = 0,
+  patch: number = 0,
+  prerelease?: string,
+  build?: string,
+): Semver => {
+  const prereleaseStr = prerelease ? `-${prerelease}` : ''
+  const buildStr = build ? `+${build}` : ''
+  const version = `${major}.${minor}.${patch}${prereleaseStr}${buildStr}`
+  return fromString(version)
+}
+
+// ============================================================================
+// Domain Logic
+// ============================================================================
+
+/**
+ * Get the major version number
+ */
+export const getMajor = (version: Semver): number => version.major
+
+/**
+ * Get the minor version number
+ */
+export const getMinor = (version: Semver): number => version.minor
+
+/**
+ * Get the patch version number
+ */
+export const getPatch = (version: Semver): number => version.patch
+
+/**
+ * Get the prerelease identifiers
+ */
+export const getPrerelease = (version: Semver): ReadonlyArray<string | number> | undefined =>
+  version._tag === 'SemverPreRelease' ? version.prerelease : undefined
+
+/**
+ * Get the build metadata
+ */
+export const getBuild = (version: Semver): ReadonlyArray<string> | undefined => version.build
+
+/**
+ * Increment a version
+ */
+export const increment = (
+  version: Semver,
+  release: 'major' | 'minor' | 'patch' | 'premajor' | 'preminor' | 'prepatch' | 'prerelease',
+  identifier?: string,
+): Semver => {
+  // Create a copy since inc modifies in place
+  const copy = VltVersion.parse(version.version.toString())
+  const incremented = copy.inc(release, identifier)
+  return fromString(incremented.toString())
+}
+
+/**
+ * Check if version satisfies a range
+ */
+export const satisfies = (version: Semver, range: string): boolean => {
+  try {
+    const vltRange = new VltRange(range)
+    return version.version.satisfies(vltRange)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Pattern match on Semver variants
+ */
+export const match = <$A>(
+  onOfficialRelease: (release: OfficialRelease.OfficialRelease) => $A,
+  onPreRelease: (preRelease: PreRelease.PreRelease) => $A,
+) =>
+(semver: Semver): $A => semver._tag === 'SemverOfficialRelease' ? onOfficialRelease(semver) : onPreRelease(semver)

package/src/lib/services-crud/$$.ts

@@ -0,0 +1,4 @@
+export * from './browser-ro.js'
+export * from './filesystem.js'
+export * from './memory.js'
+export * from './service.js'

package/src/lib/services-crud/$.ts

@@ -0,0 +1 @@
+export * as ServicesCrud from './$$.js'

package/src/lib/services-crud/browser-ro.ts

@@ -0,0 +1,98 @@
+import { Data, Effect, Layer } from 'effect'
+import { CrudService } from './service.js'
+
+/**
+ * Structured error types for browser read-only operations
+ */
+export class FetchError extends Data.TaggedError('FetchError')<{
+  readonly url: string
+  readonly status: number
+  readonly statusText: string
+}> {}
+
+export class NetworkError extends Data.TaggedError('NetworkError')<{
+  readonly relativePath: string
+  readonly cause: unknown
+}> {}
+
+export class UnsupportedOperationError extends Data.TaggedError('UnsupportedOperationError')<{
+  readonly operation: string
+  readonly message: string
+}> {}
+
+/**
+ * Create a read-only CRUD service layer for browser environments.
+ *
+ * This service uses the fetch API to read files from a remote server.
+ * Write, list, and remove operations are not supported and will fail
+ * with descriptive error messages.
+ *
+ * This is ideal for:
+ * - Loading static data from a CDN or static server
+ * - Reading configuration files in browser applications
+ * - Fetching pre-generated data exports
+ *
+ * For write operations in browser environments, implement a custom
+ * service that uses your API endpoints.
+ *
+ * @param baseUrl - Base URL for all fetch operations
+ * @returns Layer providing read-only CrudService backed by HTTP fetch
+ */
+export const browserReadOnly = (baseUrl: string) => {
+  const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/'
+
+  return Layer.succeed(CrudService, {
+    read: (relativePath: string) =>
+      Effect.gen(function*() {
+        const url = new URL(relativePath, normalizedBaseUrl).toString()
+
+        const response = yield* Effect.tryPromise({
+          try: () => fetch(url),
+          catch: (cause) => new NetworkError({ relativePath, cause }),
+        })
+
+        if (!response.ok) {
+          return yield* Effect.fail(
+            new FetchError({
+              url,
+              status: response.status,
+              statusText: response.statusText,
+            }),
+          )
+        }
+
+        return yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (cause) => new NetworkError({ relativePath, cause }),
+        })
+      }),
+
+    write: (_relativePath: string, _data: string) =>
+      Effect.fail(
+        new UnsupportedOperationError({
+          operation: 'write',
+          message: 'Write operations not supported by Browser Read-Only service. '
+            + 'Use a server-side CRUD service or implement a custom browser service for your API.',
+        }),
+      ),
+
+    list: (_relativePath: string) =>
+      Effect.fail(
+        new UnsupportedOperationError({
+          operation: 'list',
+          message: 'List operations not supported by Browser Read-Only service. '
+            + 'Browser environments cannot list remote directories. '
+            + 'Consider using a manifest file or selection-based loading.',
+        }),
+      ),
+
+    remove: (_relativePath: string) =>
+      Effect.fail(
+        new UnsupportedOperationError({
+          operation: 'remove',
+          message: 'Remove operations not supported by Browser Read-Only service. '
+            + 'Use a server-side CRUD service or implement a custom browser service for your API.',
+        }),
+      ),
+  })
+}

package/src/lib/services-crud/filesystem.ts

@@ -0,0 +1,63 @@
+import { FileSystem, Path } from '@effect/platform'
+import { NodeFileSystem, NodePath } from '@effect/platform-node'
+import { Effect, Layer } from 'effect'
+import { CrudService } from './service.js'
+
+/**
+ * Create a CRUD service layer that adapts Effect Platform FileSystem service.
+ *
+ * This adapter bridges the gap between the generic CRUD service interface and
+ * the rich FileSystem service from Effect Platform. It handles:
+ * - Auto-creation of parent directories on write
+ * - Path resolution relative to the base path
+ * - Error mapping from PlatformError to generic Error
+ * - Graceful handling of missing files/directories
+ *
+ * @param basePath - Base directory path for all operations
+ * @returns Layer providing CrudService backed by FileSystem
+ */
+export const fromFileSystem = (basePath: string) =>
+  Layer.effect(
+    CrudService,
+    Effect.gen(function*() {
+      const fs = yield* FileSystem.FileSystem
+      const path = yield* Path.Path
+
+      return {
+        read: (relativePath: string) =>
+          fs.readFileString(path.join(basePath, relativePath))
+            .pipe(Effect.mapError(error => new Error(`Failed to read ${relativePath}: ${error}`))),
+
+        write: (relativePath: string, data: string) =>
+          Effect.gen(function*() {
+            const fullPath = path.join(basePath, relativePath)
+            const dir = path.dirname(fullPath)
+            yield* fs.makeDirectory(dir, { recursive: true })
+            yield* fs.writeFileString(fullPath, data)
+          }).pipe(Effect.mapError(error => new Error(`Failed to write ${relativePath}: ${error}`))),
+
+        list: (relativePath: string) =>
+          fs.readDirectory(path.join(basePath, relativePath))
+            .pipe(
+              Effect.catchTag(
+                'SystemError',
+                error => error.reason === 'NotFound' ? Effect.succeed([]) : Effect.fail(error),
+              ),
+              Effect.mapError(error => new Error(`Failed to list ${relativePath}: ${error}`)),
+            ),
+
+        remove: (relativePath: string) =>
+          fs.remove(path.join(basePath, relativePath))
+            .pipe(
+              Effect.catchTag(
+                'SystemError',
+                error => error.reason === 'NotFound' ? Effect.succeed(undefined) : Effect.fail(error),
+              ),
+              Effect.mapError(error => new Error(`Failed to remove ${relativePath}: ${error}`)),
+            ),
+      }
+    }),
+  ).pipe(
+    Layer.provide(NodeFileSystem.layer),
+    Layer.provide(NodePath.layer),
+  )