effect-start 0.22.1 → 0.23.0

package/dist/SqlIntrospect.d.ts

@@ -0,0 +1,91 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Sql from "./Sql.ts";
+export interface Column {
+    readonly tableSchema: string;
+    readonly tableName: string;
+    readonly columnName: string;
+    readonly ordinalPosition: number;
+    readonly columnDefault: string | null;
+    readonly isNullable: boolean;
+    readonly dataType: string;
+    readonly maxLength: number | null;
+    readonly isPrimaryKey: boolean;
+    readonly isAutoIncrement: boolean;
+    readonly isSortable: boolean;
+}
+export interface ForeignKey {
+    readonly constraintName: string;
+    readonly tableSchema: string;
+    readonly tableName: string;
+    readonly columnName: string;
+    readonly referencedSchema: string;
+    readonly referencedTable: string;
+    readonly referencedColumn: string;
+    readonly updateRule: string;
+    readonly deleteRule: string;
+}
+export interface Index {
+    readonly tableSchema: string;
+    readonly tableName: string;
+    readonly indexName: string;
+    readonly columnName: string;
+    readonly isUnique: boolean;
+    readonly ordinalPosition: number;
+}
+export interface Table {
+    readonly tableSchema: string;
+    readonly tableName: string;
+    readonly columns: ReadonlyArray<Column>;
+    readonly foreignKeys: ReadonlyArray<ForeignKey>;
+    readonly indexes: ReadonlyArray<Index>;
+}
+export interface DatabaseSchema {
+    readonly tables: ReadonlyArray<Table>;
+}
+export interface IntrospectOptions {
+    readonly foreignKeys?: boolean;
+    readonly indexes?: boolean;
+}
+export type Dialect = "sqlite" | "postgres" | "mssql";
+export declare const introspect: (dialect: Dialect, options?: IntrospectOptions) => Effect.Effect<DatabaseSchema, Sql.SqlError, Sql.SqlClient>;
+export interface TableSchema {
+    readonly tableName: string;
+    readonly tableSchema: string;
+    readonly schema: Schema.Schema<any, any, never>;
+    readonly columns: ReadonlyArray<Column>;
+}
+export declare const tableToSchema: (table: Table) => TableSchema | null;
+export declare const toSchemas: (db: DatabaseSchema) => ReadonlyArray<TableSchema>;
+export interface SortOrder {
+    readonly column: string;
+    readonly reverse?: boolean;
+}
+export interface Filter {
+    readonly column: string;
+    readonly op: "eq" | "neq";
+    readonly value: unknown;
+}
+export interface FindAllOptions {
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly sort?: ReadonlyArray<SortOrder>;
+    readonly filters?: ReadonlyArray<Filter>;
+}
+export interface TableReader {
+    readonly tableName: string;
+    readonly tableSchema: string;
+    readonly schema: Schema.Schema<any, any, never>;
+    readonly columns: ReadonlyArray<Column>;
+    readonly sortableColumns: ReadonlyArray<string>;
+    readonly findAll: (options?: FindAllOptions) => Effect.Effect<ReadonlyArray<unknown>, Sql.SqlError, Sql.SqlClient>;
+    readonly findById: (id: unknown) => Effect.Effect<unknown | null, Sql.SqlError, Sql.SqlClient>;
+    readonly count: (options?: {
+        readonly filters?: ReadonlyArray<Filter>;
+    }) => Effect.Effect<number, Sql.SqlError, Sql.SqlClient>;
+}
+export interface DatabaseReader {
+    readonly tables: ReadonlyArray<TableReader>;
+    readonly table: (name: string) => TableReader | undefined;
+}
+export declare const makeDatabaseReader: (db: DatabaseSchema) => DatabaseReader;

package/dist/SqlIntrospect.js

@@ -0,0 +1,466 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Sql from "./Sql.js";
+// ---------------------------------------------------------------------------
+// SQLite
+// ---------------------------------------------------------------------------
+const sqliteColumns = `
+  SELECT
+    '' as tableSchema,
+    m.name as tableName,
+    p.name as columnName,
+    p.cid + 1 as ordinalPosition,
+    p.dflt_value as columnDefault,
+    CASE WHEN p."notnull" = 0 THEN 1 ELSE 0 END as isNullable,
+    p.type as dataType,
+    NULL as maxLength,
+    p.pk as isPrimaryKey,
+    CASE WHEN p.pk = 1 AND lower(p.type) = 'integer' THEN 1 ELSE 0 END as isAutoIncrement
+  FROM sqlite_master m
+  JOIN pragma_table_info(m.name) p
+  WHERE m.type = 'table'
+    AND m.name NOT LIKE 'sqlite_%'
+  ORDER BY m.name, p.cid
+`;
+const sqliteForeignKeys = `
+  SELECT
+    '' as constraintName,
+    '' as tableSchema,
+    m.name as tableName,
+    fk."from" as columnName,
+    '' as referencedSchema,
+    fk."table" as referencedTable,
+    fk."to" as referencedColumn,
+    fk.on_update as updateRule,
+    fk.on_delete as deleteRule
+  FROM sqlite_master m
+  JOIN pragma_foreign_key_list(m.name) fk
+  WHERE m.type = 'table'
+    AND m.name NOT LIKE 'sqlite_%'
+  ORDER BY m.name, fk.seq
+`;
+const sqliteIndexes = `
+  SELECT
+    '' as tableSchema,
+    m.name as tableName,
+    il.name as indexName,
+    ii.name as columnName,
+    il."unique" as isUnique,
+    ii.seqno + 1 as ordinalPosition
+  FROM sqlite_master m
+  JOIN pragma_index_list(m.name) il
+  JOIN pragma_index_info(il.name) ii
+  WHERE m.type = 'table'
+    AND m.name NOT LIKE 'sqlite_%'
+  ORDER BY m.name, il.name, ii.seqno
+`;
+// ---------------------------------------------------------------------------
+// PostgreSQL
+// ---------------------------------------------------------------------------
+const postgresColumns = `
+  SELECT
+    c.table_schema as "tableSchema",
+    c.table_name as "tableName",
+    c.column_name as "columnName",
+    c.ordinal_position as "ordinalPosition",
+    c.column_default as "columnDefault",
+    CASE WHEN c.is_nullable = 'YES' THEN true ELSE false END as "isNullable",
+    c.data_type as "dataType",
+    c.character_maximum_length as "maxLength",
+    CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false END as "isPrimaryKey",
+    CASE WHEN c.column_default LIKE 'nextval(%' THEN true ELSE false END as "isAutoIncrement"
+  FROM information_schema.columns c
+  LEFT JOIN (
+    SELECT kcu.table_schema, kcu.table_name, kcu.column_name
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name
+      AND tc.table_schema = kcu.table_schema
+    WHERE tc.constraint_type = 'PRIMARY KEY'
+  ) pk
+    ON c.table_schema = pk.table_schema
+    AND c.table_name = pk.table_name
+    AND c.column_name = pk.column_name
+  WHERE c.table_schema NOT IN ('information_schema', 'pg_catalog')
+  ORDER BY c.table_schema, c.table_name, c.ordinal_position
+`;
+const postgresForeignKeys = `
+  SELECT
+    tc.constraint_name as "constraintName",
+    tc.table_schema as "tableSchema",
+    tc.table_name as "tableName",
+    kcu.column_name as "columnName",
+    ccu.table_schema as "referencedSchema",
+    ccu.table_name as "referencedTable",
+    ccu.column_name as "referencedColumn",
+    rc.update_rule as "updateRule",
+    rc.delete_rule as "deleteRule"
+  FROM information_schema.table_constraints tc
+  JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+    AND tc.table_schema = kcu.table_schema
+  JOIN information_schema.constraint_column_usage ccu
+    ON tc.constraint_name = ccu.constraint_name
+    AND tc.table_schema = ccu.table_schema
+  JOIN information_schema.referential_constraints rc
+    ON tc.constraint_name = rc.constraint_name
+    AND tc.table_schema = rc.constraint_schema
+  WHERE tc.constraint_type = 'FOREIGN KEY'
+    AND tc.table_schema NOT IN ('information_schema', 'pg_catalog')
+  ORDER BY tc.table_schema, tc.table_name, kcu.ordinal_position
+`;
+const postgresIndexes = `
+  SELECT
+    n.nspname as "tableSchema",
+    t.relname as "tableName",
+    i.relname as "indexName",
+    a.attname as "columnName",
+    ix.indisunique as "isUnique",
+    array_position(ix.indkey, a.attnum) as "ordinalPosition"
+  FROM pg_index ix
+  JOIN pg_class t ON t.oid = ix.indrelid
+  JOIN pg_class i ON i.oid = ix.indexrelid
+  JOIN pg_namespace n ON n.oid = t.relnamespace
+  JOIN pg_attribute a ON a.attrelid = t.oid
+    AND a.attnum = ANY(ix.indkey)
+  WHERE n.nspname NOT IN ('information_schema', 'pg_catalog')
+  ORDER BY n.nspname, t.relname, i.relname, array_position(ix.indkey, a.attnum)
+`;
+// ---------------------------------------------------------------------------
+// SQL Server (MSSQL)
+// ---------------------------------------------------------------------------
+const mssqlColumns = `
+  SELECT
+    s.name as tableSchema,
+    t.name as tableName,
+    c.name as columnName,
+    c.column_id as ordinalPosition,
+    dc.definition as columnDefault,
+    c.is_nullable as isNullable,
+    tp.name as dataType,
+    c.max_length as maxLength,
+    CASE WHEN pk.column_id IS NOT NULL THEN 1 ELSE 0 END as isPrimaryKey,
+    c.is_identity as isAutoIncrement
+  FROM sys.tables t
+  JOIN sys.schemas s ON t.schema_id = s.schema_id
+  JOIN sys.columns c ON t.object_id = c.object_id
+  JOIN sys.types tp ON c.user_type_id = tp.user_type_id
+  LEFT JOIN sys.default_constraints dc ON c.default_object_id = dc.object_id
+  LEFT JOIN (
+    SELECT ic.object_id, ic.column_id
+    FROM sys.index_columns ic
+    JOIN sys.indexes i ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+    WHERE i.is_primary_key = 1
+  ) pk ON c.object_id = pk.object_id AND c.column_id = pk.column_id
+  WHERE t.is_ms_shipped = 0
+  ORDER BY s.name, t.name, c.column_id
+`;
+const mssqlForeignKeys = `
+  SELECT
+    fk.name as constraintName,
+    s.name as tableSchema,
+    t.name as tableName,
+    c.name as columnName,
+    rs.name as referencedSchema,
+    rt.name as referencedTable,
+    rc.name as referencedColumn,
+    fk.update_referential_action_desc as updateRule,
+    fk.delete_referential_action_desc as deleteRule
+  FROM sys.foreign_keys fk
+  JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
+  JOIN sys.tables t ON fkc.parent_object_id = t.object_id
+  JOIN sys.schemas s ON t.schema_id = s.schema_id
+  JOIN sys.columns c ON fkc.parent_object_id = c.object_id AND fkc.parent_column_id = c.column_id
+  JOIN sys.tables rt ON fkc.referenced_object_id = rt.object_id
+  JOIN sys.schemas rs ON rt.schema_id = rs.schema_id
+  JOIN sys.columns rc ON fkc.referenced_object_id = rc.object_id AND fkc.referenced_column_id = rc.column_id
+  WHERE t.is_ms_shipped = 0
+  ORDER BY s.name, t.name, fkc.constraint_column_id
+`;
+const mssqlIndexes = `
+  SELECT
+    s.name as tableSchema,
+    t.name as tableName,
+    i.name as indexName,
+    c.name as columnName,
+    i.is_unique as isUnique,
+    ic.key_ordinal as ordinalPosition
+  FROM sys.indexes i
+  JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+  JOIN sys.tables t ON i.object_id = t.object_id
+  JOIN sys.schemas s ON t.schema_id = s.schema_id
+  JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+  WHERE t.is_ms_shipped = 0
+    AND i.name IS NOT NULL
+    AND i.is_primary_key = 0
+    AND ic.is_included_column = 0
+  ORDER BY s.name, t.name, i.name, ic.key_ordinal
+`;
+const dialectQueries = {
+    sqlite: { columns: sqliteColumns, foreignKeys: sqliteForeignKeys, indexes: sqliteIndexes },
+    postgres: {
+        columns: postgresColumns,
+        foreignKeys: postgresForeignKeys,
+        indexes: postgresIndexes,
+    },
+    mssql: { columns: mssqlColumns, foreignKeys: mssqlForeignKeys, indexes: mssqlIndexes },
+};
+// ---------------------------------------------------------------------------
+// Introspect
+// ---------------------------------------------------------------------------
+const singleColumnIndexes = (indexes) => {
+    const countByIndex = new Map();
+    for (const idx of indexes) {
+        const key = `${idx.tableSchema}.${idx.tableName}.${idx.indexName}`;
+        const existing = countByIndex.get(key);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            countByIndex.set(key, { count: 1, columnName: idx.columnName });
+        }
+    }
+    const result = new Set();
+    for (const [key, entry] of countByIndex) {
+        if (entry.count === 1) {
+            const tableKey = key.substring(0, key.lastIndexOf("."));
+            result.add(`${tableKey}.${entry.columnName}`);
+        }
+    }
+    return result;
+};
+const groupByTable = (columns, foreignKeys, indexes) => {
+    const sortable = singleColumnIndexes(indexes);
+    const tableMap = new Map();
+    for (const col of columns) {
+        const key = `${col.tableSchema}.${col.tableName}`;
+        const fullCol = {
+            ...col,
+            isSortable: col.isPrimaryKey || sortable.has(`${key}.${col.columnName}`),
+        };
+        const existing = tableMap.get(key);
+        if (existing) {
+            ;
+            existing.columns.push(fullCol);
+        }
+        else {
+            tableMap.set(key, {
+                tableSchema: col.tableSchema,
+                tableName: col.tableName,
+                columns: [fullCol],
+                foreignKeys: [],
+                indexes: [],
+            });
+        }
+    }
+    for (const fk of foreignKeys) {
+        const key = `${fk.tableSchema}.${fk.tableName}`;
+        const table = tableMap.get(key);
+        if (table) {
+            ;
+            table.foreignKeys.push(fk);
+        }
+    }
+    for (const idx of indexes) {
+        const key = `${idx.tableSchema}.${idx.tableName}`;
+        const table = tableMap.get(key);
+        if (table) {
+            ;
+            table.indexes.push(idx);
+        }
+    }
+    return Array.from(tableMap.values());
+};
+const normalizeBooleans = (columns) => columns.map((c) => ({
+    ...c,
+    isNullable: Boolean(c.isNullable),
+    isPrimaryKey: Boolean(c.isPrimaryKey),
+    isAutoIncrement: Boolean(c.isAutoIncrement),
+}));
+export const introspect = (dialect, options) => Effect.gen(function* () {
+    const sql = yield* Sql.SqlClient;
+    const q = dialectQueries[dialect];
+    const columns = normalizeBooleans(yield* sql.unsafe(q.columns));
+    const foreignKeys = options?.foreignKeys !== false ? yield* sql.unsafe(q.foreignKeys) : [];
+    const indexes = options?.indexes !== false
+        ? (yield* sql.unsafe(q.indexes)).map((i) => ({
+            ...i,
+            isUnique: Boolean(i.isUnique),
+        }))
+        : [];
+    return { tables: groupByTable(columns, foreignKeys, indexes) };
+});
+// ---------------------------------------------------------------------------
+// Column → Schema mapping
+// ---------------------------------------------------------------------------
+const dataTypeToSchema = (dataType) => {
+    const t = dataType.toLowerCase();
+    if (t === "integer" ||
+        t === "int" ||
+        t === "int4" ||
+        t === "int8" ||
+        t === "smallint" ||
+        t === "tinyint" ||
+        t === "mediumint" ||
+        t === "bigint" ||
+        t === "int2")
+        return Schema.Number;
+    if (t === "real" ||
+        t === "double" ||
+        t === "double precision" ||
+        t === "float" ||
+        t === "float4" ||
+        t === "float8" ||
+        t === "numeric" ||
+        t === "decimal" ||
+        t === "money" ||
+        t === "smallmoney")
+        return Schema.Number;
+    if (t === "text" ||
+        t === "varchar" ||
+        t === "char" ||
+        t === "nchar" ||
+        t === "nvarchar" ||
+        t === "ntext" ||
+        t === "character varying" ||
+        t === "character" ||
+        t === "bpchar" ||
+        t === "uuid" ||
+        t === "citext" ||
+        t === "name" ||
+        t === "xml")
+        return Schema.String;
+    if (t === "boolean" || t === "bool" || t === "bit")
+        return Schema.Union(Schema.Boolean, Schema.Number);
+    if (t === "timestamp" ||
+        t === "timestamptz" ||
+        t === "timestamp with time zone" ||
+        t === "timestamp without time zone" ||
+        t === "date" ||
+        t === "datetime" ||
+        t === "datetime2" ||
+        t === "smalldatetime" ||
+        t === "datetimeoffset" ||
+        t === "time")
+        return Schema.String;
+    if (t === "json" || t === "jsonb")
+        return Schema.Unknown;
+    if (t === "blob" || t === "bytea" || t === "varbinary" || t === "binary" || t === "image")
+        return null;
+    return null;
+};
+const columnToSchema = (col) => {
+    const base = dataTypeToSchema(col.dataType);
+    if (base === null)
+        return null;
+    if (col.isNullable)
+        return Schema.NullOr(base);
+    return base;
+};
+export const tableToSchema = (table) => {
+    const fields = {};
+    let hasFields = false;
+    for (const col of table.columns) {
+        const s = columnToSchema(col);
+        if (s === null)
+            continue;
+        fields[col.columnName] = s;
+        hasFields = true;
+    }
+    if (!hasFields)
+        return null;
+    return {
+        tableName: table.tableName,
+        tableSchema: table.tableSchema,
+        schema: Schema.Struct(fields),
+        columns: table.columns.filter((c) => columnToSchema(c) !== null),
+    };
+};
+export const toSchemas = (db) => db.tables.flatMap((t) => {
+    const s = tableToSchema(t);
+    return s ? [s] : [];
+});
+const escapeIdentifier = (id) => `"${id.replace(/"/g, '""')}"`;
+const buildWhereClause = (filters, columnSet, paramOffset) => {
+    const conditions = [];
+    const values = [];
+    for (const f of filters) {
+        if (!columnSet.has(f.column))
+            continue;
+        const col = escapeIdentifier(f.column);
+        const paramIndex = paramOffset + values.length + 1;
+        if (f.value === null) {
+            conditions.push(f.op === "eq" ? `${col} IS NULL` : `${col} IS NOT NULL`);
+        }
+        else {
+            conditions.push(`${col} ${f.op === "eq" ? "=" : "!="} $${paramIndex}`);
+            values.push(f.value);
+        }
+    }
+    return {
+        clause: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
+        values,
+    };
+};
+const makeTableReader = (ts) => {
+    const qualifiedName = ts.tableSchema
+        ? `${escapeIdentifier(ts.tableSchema)}.${escapeIdentifier(ts.tableName)}`
+        : escapeIdentifier(ts.tableName);
+    const primaryKey = ts.columns.find((c) => c.isPrimaryKey);
+    const selectCols = ts.columns.map((c) => escapeIdentifier(c.columnName)).join(", ");
+    const columnSet = new Set(ts.columns.map((c) => c.columnName));
+    const sortableSet = new Set(ts.columns.filter((c) => c.isSortable).map((c) => c.columnName));
+    return {
+        tableName: ts.tableName,
+        tableSchema: ts.tableSchema,
+        schema: ts.schema,
+        columns: ts.columns,
+        sortableColumns: Array.from(sortableSet),
+        findAll: (options) => Effect.gen(function* () {
+            const sql = yield* Sql.SqlClient;
+            let query = `SELECT ${selectCols} FROM ${qualifiedName}`;
+            const where = options?.filters
+                ? buildWhereClause(options.filters, columnSet, 0)
+                : { clause: "", values: [] };
+            query += where.clause;
+            if (options?.sort && options.sort.length > 0) {
+                const sortClauses = options.sort
+                    .filter((s) => sortableSet.has(s.column))
+                    .map((s) => `${escapeIdentifier(s.column)} ${s.reverse ? "DESC" : "ASC"}`);
+                if (sortClauses.length > 0)
+                    query += ` ORDER BY ${sortClauses.join(", ")}`;
+            }
+            if (options?.limit !== undefined)
+                query += ` LIMIT ${Number(options.limit)}`;
+            if (options?.offset !== undefined)
+                query += ` OFFSET ${Number(options.offset)}`;
+            return yield* sql.unsafe(query, where.values);
+        }),
+        findById: (id) => Effect.gen(function* () {
+            if (!primaryKey)
+                return null;
+            const sql = yield* Sql.SqlClient;
+            const query = `SELECT ${selectCols} FROM ${qualifiedName} WHERE ${escapeIdentifier(primaryKey.columnName)} = $1`;
+            const rows = yield* sql.unsafe(query, [id]);
+            return rows[0] ?? null;
+        }),
+        count: (options) => Effect.gen(function* () {
+            const sql = yield* Sql.SqlClient;
+            let query = `SELECT COUNT(*) as count FROM ${qualifiedName}`;
+            const where = options?.filters
+                ? buildWhereClause(options.filters, columnSet, 0)
+                : { clause: "", values: [] };
+            query += where.clause;
+            const rows = yield* sql.unsafe(query, where.values);
+            return Number(rows[0].count);
+        }),
+    };
+};
+export const makeDatabaseReader = (db) => {
+    const schemas = toSchemas(db);
+    const readers = schemas.map(makeTableReader);
+    return {
+        tables: readers,
+        table: (name) => readers.find((r) => r.tableName === name),
+    };
+};

package/dist/Start.d.ts

@@ -1,10 +1,8 @@
-import * as FileSystem from "@effect/platform/FileSystem";
+import type * as FileSystem from "./FileSystem.ts";
 import * as Layer from "effect/Layer";
+import type * as ChildProcess from "./ChildProcess.ts";
 import * as BunServer from "./bun/BunServer.ts";
-export declare function layer<Layers extends [
-    Layer.Layer<never, any, any>,
-    ...Array<Layer.Layer<never, any, any>>
-]>(...layers: Layers): Layer.Layer<{
+export declare function layer<Layers extends [Layer.Layer<never, any, any>, ...Array<Layer.Layer<never, any, any>>]>(...layers: Layers): Layer.Layer<{
     [k in keyof Layers]: Layer.Layer.Success<Layers[k]>;
 }[number], {
     [k in keyof Layers]: Layer.Layer.Error<Layers[k]>;
@@ -41,6 +39,6 @@ export declare function pack<const Layers extends readonly [Layer.Layer.Any, ...
 }[number], {
     [K in keyof Layers]: Layer.Layer.Success<Layers[K]>;
 }[number]>>;
-export declare function serve<ROut, E, RIn extends BunServer.BunServer | FileSystem.FileSystem>(load: () => Promise<{
+export declare function serve<ROut, E, RIn extends BunServer.BunServer | FileSystem.FileSystem | ChildProcess.ChildProcessSpawner>(load: () => Promise<{
     default: Layer.Layer<ROut, E, RIn>;
 }>): void;

package/dist/Start.js

@@ -2,9 +2,11 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as BunRuntime from "./bun/BunRuntime.js";
 import * as BunServer from "./bun/BunServer.js";
 import * as NodeFileSystem from "./node/NodeFileSystem.js";
+import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.js";
 export function layer(...layers) {
     return Layer.mergeAll(...layers);
 }
@@ -35,7 +37,13 @@ export function pack(...layers) {
     return result;
 }
 export function serve(load) {
-    const appLayer = Function.pipe(Effect.tryPromise(load), Effect.map(v => v.default), Effect.orDie, Layer.unwrapEffect);
-    const composed = Function.pipe(BunServer.layer(), BunServer.withLogAddress, Layer.provide(appLayer), Layer.provide(NodeFileSystem.layer), Layer.provide(BunServer.layer()));
+    const appLayer = Function.pipe(Effect.tryPromise(load), Effect.map((v) => v.default), Effect.orDie, Layer.unwrapEffect);
+    const serverLayer = Layer.scoped(BunServer.BunServer, Effect.gen(function* () {
+        const existing = yield* Effect.serviceOption(BunServer.BunServer);
+        if (Option.isSome(existing))
+            return existing.value;
+        return yield* BunServer.make({});
+    }));
+    const composed = Function.pipe(serverLayer, BunServer.withLogAddress, Layer.provide(appLayer), Layer.provide(NodeFileSystem.layer), Layer.provide(BunChildProcessSpawner.layer));
     return Function.pipe(composed, Layer.launch, BunRuntime.runMain);
 }

package/dist/StreamExtra.d.ts

@@ -1,5 +1,5 @@
 import * as Runtime from "effect/Runtime";
-import type * as Stream from "effect/Stream";
+import * as Stream from "effect/Stream";
 export declare const isStream: (u: unknown) => u is Stream.Stream<unknown, unknown, unknown>;
 export type IsStream<T> = T extends Stream.Stream<infer _A, infer _E, infer _R> ? true : false;
 export type Chunk<T> = T extends Stream.Stream<infer A, infer _E, infer _R> ? A : never;

package/dist/StreamExtra.js

@@ -1,11 +1,11 @@
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
-import { dual } from "effect/Function";
+import * as Function from "effect/Function";
 import * as Predicate from "effect/Predicate";
 import * as Runtime from "effect/Runtime";
-import { runForEachChunk, StreamTypeId, } from "effect/Stream";
-export const isStream = (u) => Predicate.hasProperty(u, StreamTypeId);
+import * as Stream from "effect/Stream";
+export const isStream = (u) => Predicate.hasProperty(u, Stream.StreamTypeId);
 /**
  * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to
  * fix an issue in Bun when native stream controller stops working when request
@@ -17,14 +17,14 @@ export const isStream = (u) => Predicate.hasProperty(u, StreamTypeId);
  * https://github.com/Effect-TS/effect/issues/4538
  * https://github.com/oven-sh/bun/issues/17837
  */
-export const toReadableStreamRuntimePatched = dual((args) => Predicate.hasProperty(args[0], StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
+export const toReadableStreamRuntimePatched = Function.dual((args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
     const runFork = Runtime.runFork(runtime);
     let currentResolve = undefined;
     let fiber = undefined;
     const latch = Effect.unsafeMakeLatch(false);
     return new ReadableStream({
         start(controller) {
-            fiber = runFork(runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
+            fiber = runFork(Stream.runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
                 latch.unsafeClose();
                 try {
                     for (const item of chunk) {
@@ -32,8 +32,8 @@ export const toReadableStreamRuntimePatched = dual((args) => Predicate.hasProper
                     }
                 }
                 catch (e) {
-                    if (e.message
-                        === `Value of "this" must be of type ReadableStreamDefaultController`) {
+                    if (e.message ===
+                        `Value of "this" must be of type ReadableStreamDefaultController`) {
                         // Do nothing when this happens in Bun.
                     }
                     else {
@@ -60,7 +60,7 @@ export const toReadableStreamRuntimePatched = dual((args) => Predicate.hasProper
         },
     }, options?.strategy);
 });
-export const toReadableStreamRuntimePatched2 = dual((args) => Predicate.hasProperty(args[0], StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
+export const toReadableStreamRuntimePatched2 = Function.dual((args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
     const runSync = Runtime.runSync(runtime);
     const runFork = Runtime.runFork(runtime);
     let currentResolve = undefined;
@@ -68,7 +68,7 @@ export const toReadableStreamRuntimePatched2 = dual((args) => Predicate.hasPrope
     const latch = Effect.unsafeMakeLatch(false);
     return new ReadableStream({
         start(controller) {
-            fiber = runFork(runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
+            fiber = runFork(Stream.runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
                 latch.unsafeClose();
                 for (const item of chunk) {
                     controller.enqueue(item);

package/dist/System.d.ts

@@ -0,0 +1,7 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import * as ChildProcess from "./ChildProcess.ts";
+import * as PlatformError from "./PlatformError.ts";
+export declare const cwd: Effect.Effect<string>;
+export declare const which: (name: string) => Effect.Effect<string, PlatformError.SystemError>;
+export declare const spawn: (command: string, args?: ReadonlyArray<string>, options?: ChildProcess.Command.Options) => Effect.Effect<ChildProcess.ChildProcessHandle, PlatformError.PlatformError, ChildProcess.ChildProcessSpawner | Scope.Scope>;