effect-start 0.23.0 → 0.25.0

package/src/bun/BunServer.ts

@@ -15,6 +15,7 @@ import * as PathPattern from "../PathPattern.ts"
 import * as PlataformRuntime from "../PlatformRuntime.ts"
 import * as Route from "../Route.ts"
 import * as RouteHttp from "../RouteHttp.ts"
+import * as StartApp from "../StartApp.ts"
 import type * as RouteMount from "../RouteMount.ts"
 import * as RouteTree from "../RouteTree.ts"
 import * as BunRoute from "./BunRoute.ts"
@@ -52,12 +53,11 @@ export type BunServer = {
 
 export const BunServer = Context.GenericTag<BunServer>("effect-start/BunServer")
 
-export const make = (options: BunServeOptions): Effect.Effect<BunServer, never, Scope.Scope> =>
+export const make = (
+  options: BunServeOptions,
+  tree?: RouteTree.RouteTree,
+): Effect.Effect<BunServer, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const routes = yield* Effect.serviceOption(Route.Routes).pipe(
-      Effect.andThen(Option.getOrUndefined),
-    )
-
     const port = yield* Config.number("PORT").pipe(
       Effect.catchTag("ConfigError", () => {
         return PlataformRuntime.isAgentHarness()
@@ -66,7 +66,7 @@ export const make = (options: BunServeOptions): Effect.Effect<BunServer, never,
       }),
     )
     const hostFlag = process.argv.includes("--host")
-    const hostname = yield* Config.string("HOSTNAME").pipe(
+    const hostname = yield* Config.string("HOST").pipe(
       Effect.catchTag("ConfigError", () => Effect.succeed(hostFlag ? "0.0.0.0" : undefined)),
     )
 
@@ -98,7 +98,7 @@ export const make = (options: BunServeOptions): Effect.Effect<BunServer, never,
       Effect.andThen(Runtime.provideService(BunServer, service)),
     )
 
-    let currentRoutes: BunRoute.BunRoutes = routes ? yield* walkBunRoutes(runtime, routes) : {}
+    let currentRoutes: BunRoute.BunRoutes = tree ? yield* walkBunRoutes(runtime, tree) : {}
 
     const websocket: Bun.WebSocketHandler<WebSocketContext> = {
       open(ws) {
@@ -170,16 +170,56 @@ export const make = (options: BunServeOptions): Effect.Effect<BunServer, never,
 export const layer = (options?: BunServeOptions): Layer.Layer<BunServer> =>
   Layer.scoped(BunServer, make(options ?? {}))
 
+export const layerRoutes = (
+  options?: BunServeOptions,
+): Layer.Layer<BunServer, never, Route.Routes> =>
+  Layer.scoped(
+    BunServer,
+    Effect.gen(function* () {
+      const routes = yield* Route.Routes
+      return yield* make(options ?? {}, routes)
+    }),
+  )
+
+/**
+ * Resolves the Bun server in one place for Start.serve so routes are available:
+ * 1) Reuse a user-provided BunServer when one already exists in context.
+ * 2) Otherwise create the server from Route.Routes when routes are available.
+ * 3) Otherwise create a fallback server with the default 404 handler.
+ */
+export const layerStart = (
+  options?: BunServeOptions,
+): Layer.Layer<BunServer, never, StartApp.StartApp> =>
+  Layer.scoped(
+    BunServer,
+    Effect.gen(function* () {
+      const app = yield* StartApp.StartApp
+      const existing = yield* Effect.serviceOption(BunServer)
+      if (Option.isSome(existing)) {
+        yield* Deferred.succeed(app.server, existing.value)
+        return existing.value
+      }
+      const routes = yield* Effect.serviceOption(Route.Routes)
+      if (Option.isSome(routes)) {
+        const server = yield* make(options ?? {}, routes.value)
+        yield* Deferred.succeed(app.server, server)
+        return server
+      }
+      const server = yield* make(options ?? {})
+      yield* Deferred.succeed(app.server, server)
+      return server
+    }),
+  )
+
 export const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
   Layer.effectDiscard(
-    BunServer.pipe(
-      Effect.andThen((server) => {
-        const { hostname, port } = server.server
-        const addr = hostname === "0.0.0.0" ? getLocalIp() : "localhost"
+    Effect.gen(function* () {
+      const { server } = yield* BunServer
+      const { hostname, port } = server
+      const addr = hostname === "0.0.0.0" ? getLocalIp() : "localhost"
 
-        return Effect.log(`Listening on http://${addr}:${port}`)
-      }),
-    ),
+      yield* Effect.log(`Listening on http://${addr}:${port}`)
+    }),
   ).pipe(Layer.provideMerge(layer))
 
 function walkBunRoutes(runtime: Runtime.Runtime<BunServer>, tree: RouteTree.RouteTree) {
@@ -220,8 +260,10 @@ function registerPrebuiltBundle(prefix: string, bundle: any, bunRoutes: BunRoute
   const mainDir = NPath.dirname(Bun.main)
   const indexPath = NPath.resolve(mainDir, bundle.index)
 
-  bunRoutes[`${prefix}/*`] = () =>
-    new Response(Bun.file(indexPath), { headers: { "content-type": "text/html;charset=utf-8" } })
+  const htmlPromise = rewriteRelativeAssetPaths(Bun.file(indexPath).text())
+
+  bunRoutes[`${prefix}/*`] = async () =>
+    new Response(await htmlPromise, { headers: { "content-type": "text/html;charset=utf-8" } })
 
   for (const file of bundle.files ?? []) {
     if (file.loader === "html") continue
@@ -232,6 +274,37 @@ function registerPrebuiltBundle(prefix: string, bundle: any, bunRoutes: BunRoute
   }
 }
 
+function rewriteRelativeAssetPaths(html: string | Promise<string>): Promise<string> {
+  const rewriter = new HTMLRewriter()
+    .on("link[href]", {
+      element(el) {
+        const href = el.getAttribute("href")
+        if (href && isRelativePath(href)) {
+          el.setAttribute("href", "/" + assetBasename(href))
+        }
+      },
+    })
+    .on("script[src]", {
+      element(el) {
+        const src = el.getAttribute("src")
+        if (src && isRelativePath(src)) {
+          el.setAttribute("src", "/" + assetBasename(src))
+        }
+      },
+    })
+
+  return Promise.resolve(html).then((h) => rewriter.transform(new Response(h)).text())
+}
+
+function isRelativePath(path: string): boolean {
+  return path.startsWith("./") || path.startsWith("../")
+}
+
+function assetBasename(path: string): string {
+  const i = path.lastIndexOf("/")
+  return i === -1 ? path : path.slice(i + 1)
+}
+
 function getLocalIp(): string | undefined {
   return Object.values(NOs.networkInterfaces())
     .flatMap((addresses) => addresses ?? [])

package/src/hyper/HyperHtml.ts

@@ -140,7 +140,6 @@ export function renderToString(
       if (!EMPTY_TAGS.includes(type)) {
         stack.push(`</${type}>`)
 
-        // React-specific
         const html = props.dangerouslySetInnerHTML?.__html ?? props.innerHTML
 
         if (html) {

package/src/sql/bun/index.ts

@@ -4,7 +4,7 @@ import * as FiberRef from "effect/FiberRef"
 import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
-import * as Sql from "../../Sql.ts"
+import * as Sql from "../Sql.ts"
 
 const errorCode = (error: unknown): string => {
   const e = error as any

package/src/sql/index.ts

@@ -0,0 +1 @@
+export * as Sql from "./Sql.ts"

package/src/sql/libsql/index.ts

@@ -0,0 +1,173 @@
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberRef from "effect/FiberRef"
+import * as GlobalValue from "effect/GlobalValue"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import type * as Libsql from "@libsql/client"
+import * as Sql from "../Sql.ts"
+
+export interface LibsqlConfig {
+  readonly url: string
+  readonly authToken?: string
+  readonly syncUrl?: string
+  readonly syncInterval?: number
+  readonly encryptionKey?: string
+}
+
+const wrapError = (error: unknown): Sql.SqlError =>
+  new Sql.SqlError({
+    code: (error as any)?.code ?? "UNKNOWN",
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+  })
+
+const wrap = <T>(fn: () => PromiseLike<T>): Effect.Effect<T, Sql.SqlError> =>
+  Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError })
+
+const makeValues: Sql.SqlQuery["values"] = (obj: any, ...columns: Array<string>) => {
+  const items = Array.isArray(obj) ? obj : [obj]
+  const cols = columns.length > 0 ? columns : Object.keys(items[0])
+  return { value: items, columns: cols }
+}
+
+const resultSetToRows = <T>(result: Libsql.ResultSet): ReadonlyArray<T> => {
+  const { columns, rows } = result
+  return rows.map((row) => {
+    const obj: any = {}
+    for (let i = 0; i < columns.length; i++) obj[columns[i]] = row[i]
+    return obj
+  })
+}
+
+const buildQuery = (strings: TemplateStringsArray, values: Array<unknown>) => {
+  let sql = strings[0]
+  for (let i = 0; i < values.length; i++) sql += "?" + strings[i + 1]
+  return { sql, args: values }
+}
+
+interface TxState {
+  readonly depth: number
+}
+
+type LibsqlModule = {
+  createClient: (config: Libsql.Config) => Libsql.Client
+}
+
+const loadLibsql = () => import("@libsql/client") as Promise<LibsqlModule>
+
+const currentTransaction = GlobalValue.globalValue(
+  Symbol.for("effect-start/sql/libsql/currentTransaction"),
+  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+)
+
+const executeQuery = <T>(
+  client: Libsql.Client,
+  sql: string,
+  args: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+  wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
+
+const runQuery = <T>(
+  client: Libsql.Client,
+  strings: TemplateStringsArray,
+  values: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
+  const { sql, args } = buildQuery(strings, values)
+  return executeQuery(client, sql, args)
+}
+
+const runUnsafe = <T>(
+  client: Libsql.Client,
+  query: string,
+  values?: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+  executeQuery(client, query, values ?? [])
+
+const exec = (client: Libsql.Client, sql: string) =>
+  wrap(() => client.execute(sql))
+
+const makeWithTransaction =
+  (client: Libsql.Client) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Sql.SqlError | E, R> =>
+    Effect.uninterruptibleMask((restore) =>
+      Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+        if (Option.isSome(txOpt)) {
+          const { depth } = txOpt.value
+          const name = `sp_${depth}`
+          return Effect.gen(function* () {
+            yield* exec(client, `SAVEPOINT ${name}`)
+            const exit = yield* Effect.exit(
+              restore(
+                Effect.locally(self, currentTransaction, Option.some({ depth: depth + 1 })),
+              ),
+            )
+            if (Exit.isSuccess(exit)) {
+              yield* exec(client, `RELEASE SAVEPOINT ${name}`)
+              return exit.value
+            }
+            yield* exec(client, `ROLLBACK TO SAVEPOINT ${name}`).pipe(Effect.orDie)
+            return yield* exit
+          })
+        }
+
+        return Effect.gen(function* () {
+          yield* exec(client, "BEGIN")
+          const exit = yield* Effect.exit(
+            restore(Effect.locally(self, currentTransaction, Option.some({ depth: 1 }))),
+          )
+          if (Exit.isSuccess(exit)) {
+            yield* exec(client, "COMMIT")
+            return exit.value
+          }
+          yield* exec(client, "ROLLBACK").pipe(Effect.orDie)
+          return yield* exit
+        })
+      }),
+    )
+
+export const layer = (config: LibsqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+  Layer.scoped(
+    Sql.SqlClient,
+    Effect.acquireRelease(
+      wrap(() => loadLibsql()).pipe(
+        Effect.map((libsql) => {
+          const client = libsql.createClient(config)
+          const use: Sql.SqlClient["use"] = (fn) =>
+            Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
+          return Object.assign(
+            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
+              runQuery<T>(client, strings, values),
+            {
+              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
+                runUnsafe<T>(client, query, values),
+              values: makeValues,
+              withTransaction: makeWithTransaction(client),
+              reserve: Effect.acquireRelease(
+                wrap(() => loadLibsql()).pipe(
+                  Effect.map((m) => m.createClient(config)),
+                ),
+                (reserved: Libsql.Client) => Effect.sync(() => reserved.close()),
+              ).pipe(
+                Effect.map(
+                  (reserved): Sql.SqlQuery =>
+                    Object.assign(
+                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
+                        runQuery<T>(reserved, strings, values),
+                      {
+                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
+                          runUnsafe<T>(reserved, query, values),
+                        values: makeValues,
+                      },
+                    ),
+                ),
+              ),
+              close: () => Effect.sync(() => client.close()),
+              use,
+            },
+          ) satisfies Sql.SqlClient
+        }),
+      ),
+      (client) => client.close().pipe(Effect.orDie),
+    ),
+  )

package/src/sql/libsql/libsql.d.ts

@@ -0,0 +1,39 @@
+declare module "@libsql/client" {
+  export interface Config {
+    readonly url: string
+    readonly authToken?: string
+    readonly syncUrl?: string
+    readonly syncInterval?: number
+    readonly encryptionKey?: string
+  }
+
+  export interface ResultSet {
+    readonly columns: ReadonlyArray<string>
+    readonly rows: ReadonlyArray<ReadonlyArray<unknown>>
+    readonly rowsAffected: number
+    readonly lastInsertRowid?: bigint
+  }
+
+  export interface InStatement {
+    readonly sql: string
+    readonly args?: ReadonlyArray<unknown> | Record<string, unknown>
+  }
+
+  export interface Client {
+    execute(stmt: InStatement | string): Promise<ResultSet>
+    batch(stmts: ReadonlyArray<InStatement | string>, mode?: TransactionMode): Promise<ReadonlyArray<ResultSet>>
+    transaction(mode?: TransactionMode): Promise<Transaction>
+    close(): void
+  }
+
+  export interface Transaction {
+    execute(stmt: InStatement | string): Promise<ResultSet>
+    commit(): Promise<void>
+    rollback(): Promise<void>
+    close(): void
+  }
+
+  export type TransactionMode = "write" | "read" | "deferred"
+
+  export function createClient(config: Config): Client
+}

package/src/sql/mssql/index.ts

@@ -5,7 +5,7 @@ import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Mssql from "mssql"
-import * as Sql from "../../Sql.ts"
+import * as Sql from "../Sql.ts"
 
 export interface MssqlConfig {
   readonly server: string

package/src/x/tailscale/TailscaleTunnel.ts

@@ -1,6 +1,7 @@
-import * as BunServer from "../../bun/BunServer.ts"
 import * as PlatformError from "../../PlatformError.ts"
+import * as StartApp from "../../StartApp.ts"
 import * as System from "../../System.ts"
+import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as LogLevel from "effect/LogLevel"
@@ -86,12 +87,13 @@ export const start = (opts: {
 export const layer = (opts?: { public?: boolean }) =>
   Layer.scopedDiscard(
     Effect.gen(function* () {
-      const { server } = yield* BunServer.BunServer
-      const port = server.port!
-      const command = "tailscale"
-
       yield* Effect.forkScoped(
         Effect.gen(function* () {
+          const app = yield* StartApp.StartApp
+          const { server } = yield* Deferred.await(app.server)
+          const port = server.port!
+          const command = "tailscale"
+
           yield* System.which(command)
           const status = yield* getStatus(command)
           const dnsName = status.Self?.DNSName?.replace(/\.$/, "")

package/dist/BlobStore.d.ts

@@ -1,80 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import type * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-import type * as PlatformError from "./PlatformError.ts";
-export interface BlobInfo {
-    readonly size: number;
-    readonly lastModified: Option.Option<Date>;
-    readonly etag: Option.Option<string>;
-    readonly type: Option.Option<string>;
-}
-export interface BlobRef {
-    readonly key: string;
-    readonly bytes: Effect.Effect<Uint8Array, PlatformError.PlatformError>;
-    readonly text: Effect.Effect<string, PlatformError.PlatformError>;
-    readonly json: Effect.Effect<unknown, PlatformError.PlatformError>;
-    readonly stat: Effect.Effect<BlobInfo, PlatformError.PlatformError>;
-    readonly exists: Effect.Effect<boolean, PlatformError.PlatformError>;
-    readonly delete: Effect.Effect<void, PlatformError.PlatformError>;
-    readonly stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
-    readonly write: (data: string | Uint8Array | ArrayBuffer) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly slice: (begin?: number, end?: number) => BlobRef;
-}
-export interface ListEntry {
-    readonly key: string;
-    readonly size: Option.Option<number>;
-    readonly lastModified: Option.Option<Date>;
-    readonly etag: Option.Option<string>;
-}
-export interface ListOptions {
-    readonly prefix?: string;
-}
-export interface PresignOptions {
-    readonly expiresIn?: number;
-    readonly method?: "GET" | "PUT" | "DELETE" | "HEAD";
-}
-declare const BlobStore_base: Context.TagClass<BlobStore, "effect-start/BlobStore", {
-    readonly ref: (key: string) => Effect.Effect<BlobRef, PlatformError.PlatformError>;
-    readonly list: (options?: ListOptions) => Stream.Stream<ListEntry, PlatformError.PlatformError>;
-    readonly presign: (key: string, options?: PresignOptions) => Effect.Effect<string, PlatformError.PlatformError>;
-}>;
-export declare class BlobStore extends BlobStore_base {
-}
-declare const WatchEventCreated_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
-    readonly _tag: "Created";
-};
-export declare class WatchEventCreated extends WatchEventCreated_base<{
-    readonly key: string;
-}> {
-}
-declare const WatchEventUpdated_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
-    readonly _tag: "Updated";
-};
-export declare class WatchEventUpdated extends WatchEventUpdated_base<{
-    readonly key: string;
-}> {
-}
-declare const WatchEventDeleted_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
-    readonly _tag: "Deleted";
-};
-export declare class WatchEventDeleted extends WatchEventDeleted_base<{
-    readonly key: string;
-}> {
-}
-export type WatchEvent = WatchEventCreated | WatchEventUpdated | WatchEventDeleted;
-export interface WatchOptions {
-    readonly prefix?: string;
-}
-declare const BlobWatcher_base: Context.TagClass<BlobWatcher, "effect-start/BlobWatcher", {
-    readonly watch: (options?: WatchOptions) => Stream.Stream<WatchEvent, PlatformError.PlatformError>;
-    readonly notify: (event: WatchEvent) => Effect.Effect<boolean, PlatformError.PlatformError>;
-}>;
-export declare class BlobWatcher extends BlobWatcher_base {
-}
-export declare const watch: (options?: WatchOptions) => Stream.Stream<WatchEvent, PlatformError.PlatformError, BlobWatcher>;
-export declare const notify: (event: WatchEvent) => Effect.Effect<boolean, PlatformError.PlatformError, BlobWatcher>;
-export declare const ref: (key: string) => Effect.Effect<BlobRef, PlatformError.PlatformError, BlobStore>;
-export declare const list: (options?: ListOptions) => Stream.Stream<ListEntry, PlatformError.PlatformError, BlobStore>;
-export declare const presign: (key: string, options?: PresignOptions) => Effect.Effect<string, PlatformError.PlatformError, BlobStore>;
-export {};

package/dist/BlobStore.js

@@ -1,19 +0,0 @@
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
-export class BlobStore extends Context.Tag("effect-start/BlobStore")() {
-}
-export class WatchEventCreated extends Data.TaggedClass("Created") {
-}
-export class WatchEventUpdated extends Data.TaggedClass("Updated") {
-}
-export class WatchEventDeleted extends Data.TaggedClass("Deleted") {
-}
-export class BlobWatcher extends Context.Tag("effect-start/BlobWatcher")() {
-}
-export const watch = (options) => Stream.unwrap(Effect.map(BlobWatcher, (watcher) => watcher.watch(options)));
-export const notify = (event) => Effect.flatMap(BlobWatcher, (watcher) => watcher.notify(event));
-export const ref = (key) => Effect.flatMap(BlobStore, (store) => store.ref(key));
-export const list = (options) => Stream.unwrap(Effect.map(BlobStore, (store) => store.list(options)));
-export const presign = (key, options) => Effect.flatMap(BlobStore, (store) => store.presign(key, options));

package/dist/ChildProcess.d.ts

@@ -1,60 +0,0 @@
-/**
- * Adapted from upcomnig Effect 4 aka effect-smol.
- *
- * Kept a minimal interface without tempaltes and file descirptor
- * to keep it compatible if it lands in the core (ie. not in seperate platform package.)
- */
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Pipeable from "effect/Pipeable";
-import type * as Scope from "effect/Scope";
-import type * as Sink from "effect/Sink";
-import type * as Stream from "effect/Stream";
-import type * as PlatformError from "./PlatformError.ts";
-declare const TypeId: unique symbol;
-type TypeId = typeof TypeId;
-type Stdio = "pipe" | "inherit" | "ignore";
-export interface Command extends Pipeable.Pipeable {
-    readonly [TypeId]: TypeId;
-    readonly command: string;
-    readonly args: ReadonlyArray<string>;
-    readonly cwd?: string;
-    readonly env?: Record<string, string>;
-    readonly stdin?: Stdio;
-    readonly stdout?: Stdio;
-    readonly stderr?: Stdio;
-    readonly detached?: boolean;
-    [Symbol.iterator](): Effect.EffectGenerator<Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, ChildProcessSpawner | Scope.Scope>>;
-}
-export declare namespace Command {
-    interface Options {
-        readonly cwd?: string;
-        readonly env?: Record<string, string>;
-        readonly stdin?: Stdio;
-        readonly stdout?: Stdio;
-        readonly stderr?: Stdio;
-        readonly detached?: boolean;
-    }
-}
-export declare const isCommand: (u: unknown) => u is Command;
-export declare const make: (command: string, args?: ReadonlyArray<string>, options?: Command.Options) => Command;
-export type Signal = "SIGABRT" | "SIGALRM" | "SIGBUS" | "SIGCHLD" | "SIGCONT" | "SIGFPE" | "SIGHUP" | "SIGILL" | "SIGINT" | "SIGIO" | "SIGIOT" | "SIGKILL" | "SIGPIPE" | "SIGPOLL" | "SIGPROF" | "SIGPWR" | "SIGQUIT" | "SIGSEGV" | "SIGSTKFLT" | "SIGSTOP" | "SIGSYS" | "SIGTERM" | "SIGTRAP" | "SIGTSTP" | "SIGTTIN" | "SIGTTOU" | "SIGUNUSED" | "SIGURG" | "SIGUSR1" | "SIGUSR2" | "SIGVTALRM" | "SIGWINCH" | "SIGXCPU" | "SIGXFSZ" | "SIGBREAK" | "SIGLOST" | "SIGINFO";
-export interface KillOptions {
-    readonly killSignal?: Signal | undefined;
-}
-export interface ChildProcessHandle {
-    readonly pid: number;
-    readonly exitCode: Effect.Effect<number, PlatformError.PlatformError>;
-    readonly isRunning: Effect.Effect<boolean, PlatformError.PlatformError>;
-    readonly kill: (options?: KillOptions) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly stdin: Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>;
-    readonly stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
-    readonly stderr: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
-}
-declare const ChildProcessSpawner_base: Context.TagClass<ChildProcessSpawner, "effect-start/ChildProcessSpawner", {
-    readonly spawn: (command: Command) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>;
-}>;
-export declare class ChildProcessSpawner extends ChildProcessSpawner_base {
-}
-export declare const spawn: (command: Command) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, ChildProcessSpawner | Scope.Scope>;
-export {};