effect-start 0.23.1 → 0.26.0

package/dist/StreamExtra.js

@@ -1,100 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import * as Function from "effect/Function";
-import * as Predicate from "effect/Predicate";
-import * as Runtime from "effect/Runtime";
-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
- * 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 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(Stream.runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
-                latch.unsafeClose();
-                try {
-                    for (const item of chunk) {
-                        controller.enqueue(item);
-                    }
-                }
-                catch (e) {
-                    if (e.message ===
-                        `Value of "this" must be of type ReadableStreamDefaultController`) {
-                        // Do nothing when this happens in Bun.
-                    }
-                    else {
-                        throw e;
-                    }
-                }
-                currentResolve();
-                currentResolve = undefined;
-            }))));
-            // --- CHANGES HERE ---
-            // In original code, we had fiber.addObserver here that called
-            // error() or close() on controller. This patched version removes it.
-        },
-        pull() {
-            return new Promise((resolve) => {
-                currentResolve = resolve;
-                Effect.runSync(latch.open);
-            });
-        },
-        cancel() {
-            if (!fiber)
-                return;
-            return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)));
-        },
-    }, options?.strategy);
-});
-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;
-    let fiber = undefined;
-    const latch = Effect.unsafeMakeLatch(false);
-    return new ReadableStream({
-        start(controller) {
-            fiber = runFork(Stream.runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
-                latch.unsafeClose();
-                for (const item of chunk) {
-                    controller.enqueue(item);
-                }
-                currentResolve();
-                currentResolve = undefined;
-            }))));
-            fiber.addObserver((exit) => {
-                if (exit._tag === "Failure") {
-                    controller.error(Cause.squash(exit.cause));
-                }
-                else {
-                    controller.close();
-                }
-            });
-        },
-        pull() {
-            return new Promise((resolve) => {
-                currentResolve = resolve;
-                Effect.runSync(latch.open);
-            });
-        },
-        cancel() {
-            if (!fiber)
-                return;
-            return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)));
-        },
-    }, options?.strategy);
-});

package/dist/System.d.ts

@@ -1,7 +0,0 @@
-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>;

package/dist/System.js

@@ -1,22 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as ChildProcess from "./ChildProcess.js";
-import * as PlatformError from "./PlatformError.js";
-export const cwd = Effect.sync(() => process.cwd());
-export const which = (name) => Effect.flatMap(Effect.try({
-    try: () => Bun.which(name),
-    catch: (err) => new PlatformError.SystemError({
-        reason: "Unknown",
-        module: "System",
-        method: "which",
-        description: err instanceof Error ? err.message : `Failed to look up "${name}"`,
-        cause: err,
-    }),
-}), (path) => path === null
-    ? Effect.fail(new PlatformError.SystemError({
-        reason: "NotFound",
-        module: "System",
-        method: "which",
-        description: `Executable not found: "${name}"`,
-    }))
-    : Effect.succeed(path));
-export const spawn = (command, args, options) => ChildProcess.spawn(ChildProcess.make(command, args, options));

package/dist/TuplePathPattern.d.ts

@@ -1,9 +0,0 @@
-export type PathTuple = ReadonlyArray<string | [string, string?, string?] | [[string]]>;
-export declare function format(tuple: PathTuple): `/${string}`;
-export declare function toColon(tuple: PathTuple): string;
-export declare const toHono: typeof toColon;
-export declare function toExpress(tuple: PathTuple): string;
-export declare const toEffect: typeof toColon;
-export declare function toURLPattern(tuple: PathTuple): string;
-export declare function toRemix(tuple: PathTuple): string;
-export declare const toBun: typeof toColon;

package/dist/TuplePathPattern.js

@@ -1,68 +0,0 @@
-export function format(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "[[" + el[0][0] + "]]";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + "[" + name + "]" + (suffix ?? "");
-        })
-            .join("/"));
-}
-export function toColon(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "*";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + ":" + name + (suffix ?? "");
-        })
-            .join("/"));
-}
-export const toHono = toColon;
-export function toExpress(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "*" + el[0][0];
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + ":" + name + (suffix ?? "");
-        })
-            .join("/"));
-}
-export const toEffect = toColon;
-export function toURLPattern(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return ":" + el[0][0] + "+";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + ":" + name + (suffix ?? "");
-        })
-            .join("/"));
-}
-export function toRemix(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "$";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + "$" + name + (suffix ?? "");
-        })
-            .join("/"));
-}
-export const toBun = toColon;

package/dist/Unique.d.ts

@@ -1,50 +0,0 @@
-export declare const ALPHABET_BASE32_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export declare const ALPHABET_BASE32_RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-export declare const ALPHABET_BASE64_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-export declare const ALPHABET_HEX = "0123456789abcdef";
-/**
- * Generate a random string for ids, session tokens, and API keys.
- * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
- *
- * Minimal recommended length:
- * - public ids: 16 chars (~80 bits)
- * - API keys: 32 chars (~160 bits)
- * - session tokens: 32-40 chars (~160-200 bits)
- */
-export declare function token(length?: number): string;
-export declare function bytes(length: number): Uint8Array;
-export declare const UUID_NIL = "00000000-0000-0000-0000-000000000000";
-export declare function uuid4(): string;
-export declare function uuid7(time?: number): string;
-/**
- * Decode a 48-bit Unix timestamp (ms) from UUID7 or ULID.
- *
- * @example
- * const bytes = Unique.uuid7Bytes()
- * const timestamp = Unique.toTimestamp(bytes)
- *
- * @example
- * const bytes = Unique.ulidBytes()
- * const timestamp = Unique.toTimestamp(bytes)
- */
-export declare function toTimestamp(bytes: Uint8Array): number;
-export declare function uuid7Bytes(time?: number): Uint8Array;
-/**
- * Convert UUID bytes to canonical (RFC9562) representation.
- *
- * @example
- * Unique.formatUuid(new Uint8Array(16))
- */
-export declare function formatUuid(bytes: Uint8Array): string;
-export declare function ulid(time?: number): string;
-export declare function ulidBytes(time?: number): Uint8Array;
-/**
- * Generate a nanoid-style random string.
- *
- * FUN_FACT: Original nanoid implementation uses base64url alphabet
- * with non-standard custom order where charater form common words found
- * in source code (like use, random, strict) to make gzip/brotli more efficient.
- * It's qt lil opt from the times where web developers
- * were competing to have the smallest possible bundle size.
- */
-export declare function nanoid(size?: number, alphabet?: string): string;

package/dist/Unique.js

@@ -1,187 +0,0 @@
-export const ALPHABET_BASE32_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export const ALPHABET_BASE32_RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-export const ALPHABET_BASE64_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-export const ALPHABET_HEX = "0123456789abcdef";
-/**
- * Generate a random string for ids, session tokens, and API keys.
- * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
- *
- * Minimal recommended length:
- * - public ids: 16 chars (~80 bits)
- * - API keys: 32 chars (~160 bits)
- * - session tokens: 32-40 chars (~160-200 bits)
- */
-export function token(length = 32) {
-    if (length <= 0)
-        return "";
-    const buf = new Uint8Array(length);
-    crypto.getRandomValues(buf);
-    let result = "";
-    for (let i = 0; i < buf.length; i++) {
-        result += ALPHABET_BASE32_CROCKFORD[buf[i] & 31];
-    }
-    return result;
-}
-export function bytes(length) {
-    const buf = new Uint8Array(length);
-    crypto.getRandomValues(buf);
-    return buf;
-}
-export const UUID_NIL = "00000000-0000-0000-0000-000000000000";
-export function uuid4() {
-    return formatUuid(uuid4bytes());
-}
-export function uuid7(time = Date.now()) {
-    return formatUuid(uuid7Bytes(time));
-}
-function uuid4bytes() {
-    const buf = bytes(16);
-    buf[6] = (buf[6] & 0x0f) | 0x40; // version 4
-    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
-    return buf;
-}
-/**
- * Decode a 48-bit Unix timestamp (ms) from UUID7 or ULID.
- *
- * @example
- * const bytes = Unique.uuid7Bytes()
- * const timestamp = Unique.toTimestamp(bytes)
- *
- * @example
- * const bytes = Unique.ulidBytes()
- * const timestamp = Unique.toTimestamp(bytes)
- */
-export function toTimestamp(bytes) {
-    if (bytes.length < 6)
-        return 0;
-    return (bytes[0] * 0x10000000000 +
-        bytes[1] * 0x100000000 +
-        bytes[2] * 0x1000000 +
-        bytes[3] * 0x10000 +
-        bytes[4] * 0x100 +
-        bytes[5]);
-}
-export function uuid7Bytes(time = Date.now()) {
-    const buf = new Uint8Array(16);
-    const timestamp = BigInt(toSafeTime(time));
-    // 48-bit timestamp (6 bytes)
-    buf[0] = Number((timestamp >> 40n) & 0xffn);
-    buf[1] = Number((timestamp >> 32n) & 0xffn);
-    buf[2] = Number((timestamp >> 24n) & 0xffn);
-    buf[3] = Number((timestamp >> 16n) & 0xffn);
-    buf[4] = Number((timestamp >> 8n) & 0xffn);
-    buf[5] = Number(timestamp & 0xffn);
-    // 12-bit random A (1.5 bytes)
-    crypto.getRandomValues(buf.subarray(6, 8));
-    buf[6] = (buf[6] & 0x0f) | 0x70; // version 7
-    // 2-bit variant + 62-bit random B (8 bytes)
-    crypto.getRandomValues(buf.subarray(8, 16));
-    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
-    return buf;
-}
-/**
- * Convert UUID bytes to canonical (RFC9562) representation.
- *
- * @example
- * Unique.formatUuid(new Uint8Array(16))
- */
-export function formatUuid(bytes) {
-    if (bytes.length === 0)
-        return "";
-    let result = "";
-    for (let i = 0; i < bytes.length; i++) {
-        const byte = bytes[i];
-        result += ALPHABET_HEX[(byte >> 4) & 0x0f];
-        result += ALPHABET_HEX[byte & 0x0f];
-        if (i === 3 || i === 5 || i === 7 || i === 9)
-            result += "-";
-    }
-    return result;
-}
-export function ulid(time = Date.now()) {
-    const bytes = ulidBytes(time);
-    return formatUlid(bytes);
-}
-export function ulidBytes(time = Date.now()) {
-    const buf = new Uint8Array(16);
-    const timestamp = BigInt(toSafeTime(time));
-    buf[0] = Number((timestamp >> 40n) & 0xffn);
-    buf[1] = Number((timestamp >> 32n) & 0xffn);
-    buf[2] = Number((timestamp >> 24n) & 0xffn);
-    buf[3] = Number((timestamp >> 16n) & 0xffn);
-    buf[4] = Number((timestamp >> 8n) & 0xffn);
-    buf[5] = Number(timestamp & 0xffn);
-    crypto.getRandomValues(buf.subarray(6, 16));
-    return buf;
-}
-function formatUlid(bytes) {
-    if (bytes.length !== 16)
-        return "";
-    const timestamp = toTimestamp(bytes);
-    const timePart = encodeUlidTime(timestamp);
-    const randomPart = toBase32(bytes.subarray(6, 16));
-    return `${timePart}${randomPart}`;
-}
-function encodeUlidTime(time) {
-    let value = BigInt(time);
-    const result = Array.from({ length: 10 });
-    for (let i = 9; i >= 0; i--) {
-        result[i] = ALPHABET_BASE32_CROCKFORD[Number(value & 31n)];
-        value >>= 5n;
-    }
-    return result.join("");
-}
-function toSafeTime(time) {
-    if (!Number.isFinite(time))
-        return 0;
-    return Math.max(0, Math.trunc(time));
-}
-/**
- * Generate a nanoid-style random string.
- *
- * FUN_FACT: Original nanoid implementation uses base64url alphabet
- * with non-standard custom order where charater form common words found
- * in source code (like use, random, strict) to make gzip/brotli more efficient.
- * It's qt lil opt from the times where web developers
- * were competing to have the smallest possible bundle size.
- */
-export function nanoid(size = 21, alphabet = ALPHABET_BASE64_URL) {
-    if (size <= 0 || alphabet.length === 0)
-        return "";
-    const length = alphabet.length;
-    const mask = (2 << Math.floor(Math.log2(length - 1))) - 1;
-    const step = Math.ceil((1.6 * mask * size) / length);
-    let id = "";
-    while (id.length < size) {
-        const bytes = new Uint8Array(step);
-        crypto.getRandomValues(bytes);
-        for (let i = 0; i < step && id.length < size; i++) {
-            const index = bytes[i] & mask;
-            if (index < length)
-                id += alphabet[index];
-        }
-    }
-    return id;
-}
-function toBase32(bytes, alphabet = ALPHABET_BASE32_CROCKFORD) {
-    if (bytes.length === 0)
-        return "";
-    let result = "";
-    let buffer = 0;
-    let bits = 0;
-    for (const byte of bytes) {
-        buffer = (buffer << 8) | byte;
-        bits += 8;
-        while (bits >= 5) {
-            bits -= 5;
-            const index = (buffer >> bits) & 31;
-            result += alphabet[index];
-            buffer &= (1 << bits) - 1;
-        }
-    }
-    if (bits > 0) {
-        const index = (buffer << (5 - bits)) & 31;
-        result += alphabet[index];
-    }
-    return result;
-}

package/dist/Values.d.ts

@@ -1,27 +0,0 @@
-type JsonPrimitives = string | number | boolean | null;
-export type JsonObject = {
-    [key: string]: Json | undefined;
-};
-export type Json = JsonPrimitives | Json[] | JsonObject;
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-/**
- * Type helper that returns `true` if type T has any method properties,
- * otherwise returns `never`.
- *
- * Used internally by IsPlainObject to distinguish plain objects from
- * class instances or objects with methods.
- */
-type HasMethod<T> = {
-    [K in keyof T]: T[K] extends (...args: Array<any>) => any ? true : never;
-}[keyof T];
-export type IsPlainObject<T> = T extends object ? T extends Function ? false : HasMethod<T> extends never ? true : false : false;
-export type Simplify<T> = {
-    -readonly [K in keyof T]: IsPlainObject<T[K]> extends true ? {
-        -readonly [P in keyof T[K]]: T[K][P];
-    } : T[K];
-} extends infer U ? {
-    [K in keyof U]: U[K];
-} : never;
-export declare const firstValue: <T>(record: Record<string, T>) => T | undefined;
-export declare const concatBytes: (a: Uint8Array, b: Uint8Array) => Uint8Array;
-export {};

package/dist/Values.js

@@ -1,36 +0,0 @@
-export function isPlainObject(value) {
-    if (value === null || typeof value !== "object") {
-        return false;
-    }
-    // Check for built-in types and web APIs
-    if (ArrayBuffer.isView(value) ||
-        value instanceof ArrayBuffer ||
-        value instanceof Blob ||
-        value instanceof FormData ||
-        value instanceof URLSearchParams ||
-        value instanceof ReadableStream ||
-        value instanceof Date ||
-        value instanceof Map ||
-        value instanceof Set ||
-        value instanceof RegExp ||
-        value instanceof Error ||
-        value instanceof Promise ||
-        Array.isArray(value)) {
-        return false;
-    }
-    // Check if it's a plain object (Object.prototype or null prototype)
-    const proto = Object.getPrototypeOf(value);
-    return proto === null || proto === Object.prototype;
-}
-export const firstValue = (record) => {
-    for (const key in record) {
-        return record[key];
-    }
-    return undefined;
-};
-export const concatBytes = (a, b) => {
-    const result = new Uint8Array(a.byteLength + b.byteLength);
-    result.set(a);
-    result.set(b, a.byteLength);
-    return result;
-};

package/dist/bun/BunBlobStoreDisk.d.ts

@@ -1,6 +0,0 @@
-import * as Layer from "effect/Layer";
-import { BlobStore as BlobStoreTag } from "../BlobStore.ts";
-export interface DiskConfig {
-    readonly directory?: string;
-}
-export declare const layer: (config?: DiskConfig) => Layer.Layer<BlobStoreTag>;

package/dist/bun/BunBlobStoreDisk.js

@@ -1,116 +0,0 @@
-import * as Chunk from "effect/Chunk";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-import * as NFS from "node:fs";
-import * as NPath from "node:path";
-import { BlobStore as BlobStoreTag } from "../BlobStore.js";
-import * as PlatformError from "../PlatformError.js";
-import { handleErrnoException } from "../node/NodeFileSystem.js";
-const handleBadArgument = (method) => (cause) => new PlatformError.BadArgument({
-    module: "BlobStore",
-    method,
-    cause,
-});
-const handleErrno = (method) => handleErrnoException("BlobStore", method);
-const tryPromise = (method, path, promise) => Effect.tryPromise({
-    try: promise,
-    catch: (err) => {
-        if (err instanceof Error && "code" in err) {
-            return handleErrno(method)(err, [path]);
-        }
-        return handleBadArgument(method)(err);
-    },
-});
-const validatePath = (directory, key) => {
-    const resolved = NPath.resolve(directory, key);
-    const root = NPath.resolve(directory);
-    if (resolved !== root && !resolved.startsWith(root + NPath.sep)) {
-        return Effect.fail(new PlatformError.BadArgument({
-            module: "BlobStore",
-            method: "ref",
-            description: `Path traversal: key "${key}" escapes directory "${directory}"`,
-        }));
-    }
-    return Effect.succeed(resolved);
-};
-const makeRef = (directory, path, key, begin, end) => {
-    const getFile = () => {
-        const f = Bun.file(path);
-        return begin !== undefined || end !== undefined ? f.slice(begin, end) : f;
-    };
-    return {
-        key,
-        bytes: tryPromise("bytes", path, () => getFile().bytes()),
-        text: tryPromise("text", path, () => getFile().text()),
-        json: tryPromise("json", path, () => getFile().json()),
-        stat: Effect.flatMap(tryPromise("stat", path, () => Bun.file(path).stat()), (s) => Effect.succeed({
-            size: s.size,
-            lastModified: Option.fromNullable(s.mtime),
-            etag: Option.none(),
-            type: Option.fromNullable(Bun.file(path).type || null),
-        })),
-        exists: tryPromise("exists", path, () => Bun.file(path).exists()),
-        delete: tryPromise("delete", path, () => NFS.promises.unlink(path)),
-        stream: Stream.fromReadableStream(() => getFile().stream(), (err) => {
-            if (err instanceof Error && "code" in err) {
-                return handleErrno("stream")(err, [path]);
-            }
-            return handleBadArgument("stream")(err);
-        }),
-        write: (data) => tryPromise("write", path, () => Bun.write(path, data, { createPath: true }).then(() => undefined)),
-        slice: (b, e) => makeRef(directory, path, key, b, e),
-    };
-};
-const listEntries = (directory, options) => {
-    const baseDir = options?.prefix
-        ? NPath.join(directory, options.prefix)
-        : directory;
-    return Stream.fromEffect(Effect.tryPromise({
-        try: async () => {
-            try {
-                const entries = await NFS.promises.readdir(baseDir, {
-                    recursive: true,
-                    withFileTypes: true,
-                });
-                return entries
-                    .filter((e) => e.isFile())
-                    .map((e) => {
-                    const rel = NPath.join(e.parentPath, e.name);
-                    const key = NPath.relative(directory, rel);
-                    return {
-                        key,
-                        size: Option.none(),
-                        lastModified: Option.none(),
-                        etag: Option.none(),
-                    };
-                });
-            }
-            catch (err) {
-                if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-                    return [];
-                }
-                throw err;
-            }
-        },
-        catch: (err) => {
-            if (err instanceof Error && "code" in err) {
-                return handleErrno("list")(err, [baseDir]);
-            }
-            return handleBadArgument("list")(err);
-        },
-    })).pipe(Stream.flatMap((entries) => Stream.fromChunk(Chunk.fromIterable(entries))));
-};
-export const layer = (config) => {
-    const directory = config?.directory ?? "/";
-    return Layer.succeed(BlobStoreTag, {
-        ref: (key) => Effect.map(validatePath(directory, key), (path) => makeRef(directory, path, key)),
-        list: (options) => listEntries(directory, options),
-        presign: (_key, _options) => Effect.fail(new PlatformError.BadArgument({
-            module: "BlobStore",
-            method: "presign",
-            description: "Presigned URLs are not supported for disk storage",
-        })),
-    });
-};

package/dist/bun/BunBlobStoreS3.d.ts

@@ -1,11 +0,0 @@
-import * as Layer from "effect/Layer";
-import { BlobStore as BlobStoreTag } from "../BlobStore.ts";
-export interface S3Config {
-    readonly bucket?: string;
-    readonly endpoint?: string;
-    readonly region?: string;
-    readonly accessKeyId?: string;
-    readonly secretAccessKey?: string;
-    readonly sessionToken?: string;
-}
-export declare const layer: (config?: S3Config) => Layer.Layer<BlobStoreTag>;