effect-start 0.23.1 → 0.26.0

package/dist/SqlIntrospect.js

@@ -1,466 +0,0 @@
-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,44 +0,0 @@
-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<{
-    [k in keyof Layers]: Layer.Layer.Success<Layers[k]>;
-}[number], {
-    [k in keyof Layers]: Layer.Layer.Error<Layers[k]>;
-}[number], {
-    [k in keyof Layers]: Layer.Layer.Context<Layers[k]>;
-}[number]>;
-/**
- * Bundles layers together, wiring their dependencies automatically.
- *
- * Equivalent to chaining `Layer.provide` calls, but more concise.
- *
- * **Ordering: dependents first, dependencies last.**
- *
- * @example
- * ```ts
- * // UserRepo needs Database, Database needs Logger
- * const AppLayer = Start.pack(
- *   UserRepoLive,   // needs Database, Logger
- *   DatabaseLive,   // needs Logger
- *   LoggerLive,     // no deps
- * )
- * // Result: Layer<UserRepo | Database | Logger, never, never>
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
-export declare function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(...layers: Layers): Layer.Layer<{
-    [K in keyof Layers]: Layer.Layer.Success<Layers[K]>;
-}[number], {
-    [K in keyof Layers]: Layer.Layer.Error<Layers[K]>;
-}[number], Exclude<{
-    [K in keyof Layers]: Layer.Layer.Context<Layers[K]>;
-}[number], {
-    [K in keyof Layers]: Layer.Layer.Success<Layers[K]>;
-}[number]>>;
-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

@@ -1,49 +0,0 @@
-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);
-}
-/**
- * Bundles layers together, wiring their dependencies automatically.
- *
- * Equivalent to chaining `Layer.provide` calls, but more concise.
- *
- * **Ordering: dependents first, dependencies last.**
- *
- * @example
- * ```ts
- * // UserRepo needs Database, Database needs Logger
- * const AppLayer = Start.pack(
- *   UserRepoLive,   // needs Database, Logger
- *   DatabaseLive,   // needs Logger
- *   LoggerLive,     // no deps
- * )
- * // Result: Layer<UserRepo | Database | Logger, never, never>
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
-export function pack(...layers) {
-    const layerArray = layers;
-    const result = layerArray.reduce((acc, layer) => Layer.provideMerge(acc, layer), Layer.succeedContext(Context.empty()));
-    return result;
-}
-export function serve(load) {
-    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/StartApp.d.ts

@@ -1,19 +0,0 @@
-import * as HttpApp from "@effect/platform/HttpApp";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as PubSub from "effect/PubSub";
-import * as Ref from "effect/Ref";
-type StartMiddleware = <E, R>(self: HttpApp.Default<E, R>) => HttpApp.Default<never, never>;
-declare const StartApp_base: Context.TagClass<StartApp, "effect-start/StartApp", {
-    readonly env: "development" | "production" | string;
-    readonly addMiddleware: (middleware: StartMiddleware) => Effect.Effect<void>;
-    readonly middleware: Ref.Ref<StartMiddleware>;
-    readonly events: PubSub.PubSub<any>;
-}>;
-export declare class StartApp extends StartApp_base {
-}
-export declare function layer(options?: {
-    env?: string;
-}): Layer.Layer<StartApp, never, never>;
-export {};

package/dist/StartApp.js

@@ -1,21 +0,0 @@
-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 PubSub from "effect/PubSub";
-import * as Ref from "effect/Ref";
-export class StartApp extends Context.Tag("effect-start/StartApp")() {
-}
-export function layer(options) {
-    return Layer.effect(StartApp, Effect.gen(function* () {
-        const env = options?.env ?? process.env.NODE_ENV ?? "development";
-        const middleware = yield* Ref.make(Function.identity);
-        const events = yield* PubSub.unbounded();
-        return StartApp.of({
-            env,
-            middleware,
-            addMiddleware: (f) => Ref.update(middleware, (prev) => (app) => f(prev(app))),
-            events,
-        });
-    }));
-}

package/dist/StreamExtra.d.ts

@@ -1,28 +0,0 @@
-import * as Runtime from "effect/Runtime";
-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;
-export type StreamError<T> = T extends Stream.Stream<infer _A, infer E, infer _R> ? E : never;
-export type Context<T> = T extends Stream.Stream<infer _A, infer _E, infer R> ? R : never;
-/**
- * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to
- * fix an issue in Bun when native stream controller stops working when request
- * is terminated by the client:
- *
- *  TypeError: Value of "this" must be of type ReadableStreamDefaultController
- *
- * See related issues:
- * https://github.com/Effect-TS/effect/issues/4538
- * https://github.com/oven-sh/bun/issues/17837
- */
-export declare const toReadableStreamRuntimePatched: (<A, XR>(runtime: Runtime.Runtime<XR>, options?: {
-    readonly strategy?: QueuingStrategy<A> | undefined;
-}) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>, options?: {
-    readonly strategy?: QueuingStrategy<A> | undefined;
-}) => ReadableStream<A>);
-export declare const toReadableStreamRuntimePatched2: (<A, XR>(runtime: Runtime.Runtime<XR>, options?: {
-    readonly strategy?: QueuingStrategy<A> | undefined;
-}) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>, options?: {
-    readonly strategy?: QueuingStrategy<A> | undefined;
-}) => ReadableStream<A>);