effect-start 0.27.0 → 0.29.0

package/src/FileSystem.ts

@@ -12,108 +12,93 @@ import * as Option from "effect/Option"
 import * as Sink from "effect/Sink"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import * as PlatformError from "./PlatformError.ts"
+import * as System from "./System.ts"
 
 export interface FileSystem {
   readonly access: (
     path: string,
     options?: AccessFileOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly copy: (
     fromPath: string,
     toPath: string,
     options?: CopyOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly copyFile: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly copyFile: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
+  readonly chmod: (path: string, mode: number) => Effect.Effect<void, System.SystemError>
   readonly chown: (
     path: string,
     uid: number,
     gid: number,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly exists: (path: string) => Effect.Effect<boolean, PlatformError.PlatformError>
-  readonly link: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly exists: (path: string) => Effect.Effect<boolean, System.SystemError>
+  readonly link: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
   readonly makeDirectory: (
     path: string,
     options?: MakeDirectoryOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly makeTempDirectory: (
     options?: MakeTempDirectoryOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
   readonly makeTempDirectoryScoped: (
     options?: MakeTempDirectoryOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<string, System.SystemError, Scope.Scope>
   readonly makeTempFile: (
     options?: MakeTempFileOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
   readonly makeTempFileScoped: (
     options?: MakeTempFileOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<string, System.SystemError, Scope.Scope>
   readonly open: (
     path: string,
     options?: OpenFileOptions,
-  ) => Effect.Effect<File, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<File, System.SystemError, Scope.Scope>
   readonly readDirectory: (
     path: string,
     options?: ReadDirectoryOptions,
-  ) => Effect.Effect<Array<string>, PlatformError.PlatformError>
-  readonly readFile: (path: string) => Effect.Effect<Uint8Array, PlatformError.PlatformError>
+  ) => Effect.Effect<Array<string>, System.SystemError>
+  readonly readFile: (path: string) => Effect.Effect<Uint8Array, System.SystemError>
   readonly readFileString: (
     path: string,
     encoding?: string,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly readLink: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly realPath: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
+  readonly readLink: (path: string) => Effect.Effect<string, System.SystemError>
+  readonly realPath: (path: string) => Effect.Effect<string, System.SystemError>
   readonly remove: (
     path: string,
     options?: RemoveOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly rename: (
-    oldPath: string,
-    newPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, System.SystemError>
   readonly sink: (
     path: string,
     options?: SinkOptions,
-  ) => Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
-  readonly stat: (path: string) => Effect.Effect<File.Info, PlatformError.PlatformError>
+  ) => Sink.Sink<void, Uint8Array, never, System.SystemError>
+  readonly stat: (path: string) => Effect.Effect<File.Info, System.SystemError>
   readonly stream: (
     path: string,
     options?: StreamOptions,
-  ) => Stream.Stream<Uint8Array, PlatformError.PlatformError>
-  readonly symlink: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly truncate: (
-    path: string,
-    length?: SizeInput,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Stream.Stream<Uint8Array, System.SystemError>
+  readonly symlink: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
+  readonly truncate: (path: string, length?: SizeInput) => Effect.Effect<void, System.SystemError>
   readonly utimes: (
     path: string,
     atime: Date | number,
     mtime: Date | number,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly watch: (
     path: string,
     options?: WatchOptions,
-  ) => Stream.Stream<WatchEvent, PlatformError.PlatformError>
+  ) => Stream.Stream<WatchEvent, System.SystemError>
   readonly writeFile: (
     path: string,
     data: Uint8Array,
     options?: WriteFileOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly writeFileString: (
     path: string,
     data: string,
     options?: WriteFileStringOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
 }
 
 export const FileSystem: Context.Tag<FileSystem, FileSystem> = Context.GenericTag<FileSystem>(
@@ -202,16 +187,16 @@ export type FileTypeId = typeof FileTypeId
 export interface File {
   readonly [FileTypeId]: FileTypeId
   readonly fd: File.Descriptor
-  readonly stat: Effect.Effect<File.Info, PlatformError.PlatformError>
+  readonly stat: Effect.Effect<File.Info, System.SystemError>
   readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
-  readonly sync: Effect.Effect<void, PlatformError.PlatformError>
-  readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
+  readonly sync: Effect.Effect<void, System.SystemError>
+  readonly read: (buffer: Uint8Array) => Effect.Effect<Size, System.SystemError>
   readonly readAlloc: (
     size: SizeInput,
-  ) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>
-  readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
-  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<Option.Option<Uint8Array>, System.SystemError>
+  readonly truncate: (length?: SizeInput) => Effect.Effect<void, System.SystemError>
+  readonly write: (buffer: Uint8Array) => Effect.Effect<Size, System.SystemError>
+  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, System.SystemError>
 }
 
 export declare namespace File {
@@ -282,7 +267,7 @@ export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/Watch
       path: string,
       stat: File.Info,
       options?: WatchOptions,
-    ) => Option.Option<Stream.Stream<WatchEvent, PlatformError.PlatformError>>
+    ) => Option.Option<Stream.Stream<WatchEvent, System.SystemError>>
   }
 >() {}
 
@@ -303,7 +288,8 @@ export const make = (
       Effect.tryMap(impl.readFile(path), {
         try: (_) => new TextDecoder(encoding).decode(_),
         catch: (cause) =>
-          new PlatformError.BadArgument({
+          new System.SystemError({
+            reason: "BadArgument",
             module: "FileSystem",
             method: "readFileString",
             description: "invalid encoding",
@@ -330,7 +316,8 @@ export const make = (
         Effect.try({
           try: () => new TextEncoder().encode(data),
           catch: (cause) =>
-            new PlatformError.BadArgument({
+            new System.SystemError({
+              reason: "BadArgument",
               module: "FileSystem",
               method: "writeFileString",
               description: "could not encode string",
@@ -342,23 +329,13 @@ export const make = (
   })
 }
 
-const fileStream = (
-  file: File,
-  options: StreamOptions = {},
-) => {
+const fileStream = (file: File, options: StreamOptions = {}) => {
   const bytesToRead = options.bytesToRead !== undefined ? Size(options.bytesToRead) : undefined
   const chunkSize = Size(options.chunkSize ?? 64 * 1024)
 
   function loop(
     totalBytesRead: bigint,
-  ): Channel.Channel<
-    Chunk.Chunk<Uint8Array>,
-    unknown,
-    PlatformError.PlatformError,
-    unknown,
-    void,
-    unknown
-  > {
+  ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, System.SystemError, unknown, void, unknown> {
     if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
       return Channel.void
     }

package/src/GlobalLayer.ts

@@ -0,0 +1,85 @@
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import type * as Fiber from "effect/Fiber"
+import * as GlobalValue from "effect/GlobalValue"
+import * as HashMap from "effect/HashMap"
+import * as Layer from "effect/Layer"
+import * as MutableRef from "effect/MutableRef"
+import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
+
+import * as ChildProcess from "./_ChildProcess.ts"
+
+interface CacheEntry {
+  readonly context: Context.Context<any>
+  readonly fiber: Fiber.RuntimeFiber<void>
+}
+
+const cache = GlobalValue.globalValue(Symbol.for("effect-start/GlobalLayer/cache"), () =>
+  MutableRef.make(HashMap.empty<string, CacheEntry>()),
+)
+
+export const globalLayer =
+  (key: string) =>
+  <A, E>(
+    layer: Layer.Layer<A, E> | Layer.Layer<A, E, ChildProcess.ChildProcessSpawner>,
+  ): Layer.Layer<A, E> => {
+    const existing = HashMap.get(MutableRef.get(cache), key)
+    if (existing._tag === "Some") {
+      return Layer.succeedContext(existing.value.context) as Layer.Layer<A, E>
+    }
+
+    return Layer.scopedContext(
+      Effect.gen(function* () {
+        const cached = HashMap.get(MutableRef.get(cache), key)
+        if (cached._tag === "Some") {
+          return cached.value.context as Context.Context<A>
+        }
+
+        const spawner = yield* Effect.serviceOption(ChildProcess.ChildProcessSpawner)
+        const deferred = yield* Deferred.make<Context.Context<A>, E>()
+
+        const parentRuntime = yield* Effect.runtime<never>()
+
+        const defaultRuntime = Runtime.make({
+          // Empty service context — no custom services leak into the forked fiber
+          context: Context.empty(),
+
+          // Bit flags for runtime behavior (interruption, cooperative yielding, etc.)
+          runtimeFlags: parentRuntime.runtimeFlags,
+
+          // Per-fiber state like logger config, tracer settings, span annotations.
+          // Default services are wired through FiberRefs, not the service context.
+          fiberRefs: parentRuntime.fiberRefs,
+        })
+
+        const fiber = Runtime.runFork(defaultRuntime)(
+          Effect.scoped(
+            Effect.gen(function* () {
+              const scope = yield* Effect.scope
+              const memoMap = yield* Layer.makeMemoMap
+              const ctx = yield* (layer as Layer.Layer<A, E>).pipe(
+                Layer.buildWithMemoMap(memoMap, scope),
+                Option.isSome(spawner)
+                  ? Effect.provideService(ChildProcess.ChildProcessSpawner, spawner.value)
+                  : (a) => a,
+              )
+              yield* Deferred.succeed(deferred, ctx)
+              yield* Effect.never
+            }),
+          ),
+        ) as Fiber.RuntimeFiber<void>
+
+        const ctx = yield* Deferred.await(deferred)
+
+        MutableRef.update(cache, HashMap.set(key, { context: ctx, fiber } as CacheEntry))
+
+        fiber.addObserver(() => {
+          MutableRef.update(cache, HashMap.remove(key))
+        })
+
+        return ctx
+      }),
+    )
+  }

package/src/PlatformRuntime.ts

@@ -6,8 +6,15 @@ import type * as FiberId from "effect/FiberId"
 import * as FiberRef from "effect/FiberRef"
 import * as FiberRefs from "effect/FiberRefs"
 import * as Function from "effect/Function"
+import * as GlobalValue from "effect/GlobalValue"
 import * as HashSet from "effect/HashSet"
 import * as Logger from "effect/Logger"
+import * as MutableRef from "effect/MutableRef"
+
+export const mainFiber = GlobalValue.globalValue(
+  Symbol.for("effect-start/PlatformRuntime/mainFiber"),
+  () => MutableRef.make<Fiber.RuntimeFiber<unknown, unknown> | undefined>(undefined),
+)
 
 export interface Teardown {
   <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void
@@ -95,6 +102,6 @@ export function isAgentHarness() {
   return (
     typeof process !== "undefined" &&
     !process.stdout.isTTY &&
-    (process.env.CLAUDECODE || process.env.CURSOR_AGENT)
+    (process.env.CLAUDECODE || process.env.CURSOR_AGENT || process.env.CODEX_THREAD_ID)
   )
 }

package/src/Route.ts

@@ -6,14 +6,14 @@ import * as Predicate from "effect/Predicate"
 import * as Entity from "./Entity.ts"
 import * as RouteBody from "./RouteBody.ts"
 import * as RouteTree from "./RouteTree.ts"
-import type * as Values from "./Values.ts"
+import type * as Values from "./_Values.ts"
 
 export const RouteItems: unique symbol = Symbol()
 export const RouteDescriptor: unique symbol = Symbol()
 // only for structural type matching
 export const RouteBindings: unique symbol = Symbol()
 
-export const TypeId: unique symbol = Symbol.for("effect-start/RouteSet")
+export const TypeId = "~effect-start/RouteSet" as const
 
 export namespace RouteDescriptor {
   export type Any = {

package/src/RouteBody.ts

@@ -3,7 +3,7 @@ import type * as Stream from "effect/Stream"
 import type * as Utils from "effect/Utils"
 import * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
-import type * as Values from "./Values.ts"
+import type * as Values from "./_Values.ts"
 
 export type Format = "text" | "html" | "json" | "bytes" | "*"
 

package/src/RouteHook.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import type * as Utils from "effect/Utils"
-import * as Entity from "./Entity.ts"
+import type * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
 
 export type FilterResult<BOut, E, R> = { context: BOut } | Effect.Effect<{ context: BOut }, E, R>