@uploadista/core 0.0.2 → 0.0.3

package/dist/streams/stream-limiter.js

@@ -1,49 +0,0 @@
-import { Effect, Ref, Stream } from "effect";
-import { UploadistaError } from "../errors/uploadista-error";
-export function streamLimiter({ maxSize, onData, }) {
-    let currentSize = 0;
-    return new TransformStream({
-        transform(chunk, controller) {
-            currentSize += chunk.length;
-            onData?.(chunk.byteLength);
-            if (currentSize > maxSize) {
-                controller.error(UploadistaError.fromCode("ERR_MAX_SIZE_EXCEEDED"));
-            }
-            else {
-                controller.enqueue(chunk);
-            }
-        },
-    });
-}
-/**
- * Effect-based stream limiter that restricts stream size
- */
-export const StreamLimiterEffect = {
-    /**
-     * Creates an Effect-based stream limiter
-     * @param maxSize - Maximum allowed stream size in bytes
-     * @param onData - Optional callback for data progress tracking
-     * @returns Effect stream transformation that enforces size limits
-     */
-    limit: ({ maxSize, onData }) => (stream) => {
-        return Effect.gen(function* () {
-            const currentSize = yield* Ref.make(0);
-            return stream.pipe(Stream.mapEffect((chunk) => Effect.gen(function* () {
-                const chunkSize = chunk instanceof Uint8Array ? chunk.byteLength : 0;
-                yield* Ref.update(currentSize, (size) => size + chunkSize);
-                onData?.(chunkSize);
-                const size = yield* Ref.get(currentSize);
-                if (size > maxSize) {
-                    yield* UploadistaError.fromCode("ERR_MAX_SIZE_EXCEEDED").toEffect();
-                }
-                return chunk;
-            })));
-        }).pipe(Stream.unwrap);
-    },
-    /**
-     * Creates a legacy TransformStream-based limiter
-     * @param options - Stream limiter options
-     * @returns TransformStream that enforces size limits
-     */
-    createTransformStream: (options) => streamLimiter(options),
-};

package/dist/streams/stream-splitter.cjs

@@ -1 +0,0 @@
-const e=require(`../chunk-CUT6urMc.cjs`),t=require(`../uploadista-error-BB-Wdiz9.cjs`);let n=require(`effect`);n=e.__toESM(n);function r(e){let t=new Uint8Array(e.reduce((e,t)=>e+t.length,0)),n=0;for(let r of e)t.set(r,n),n+=r.length;return t}async function i(e,{onData:t,onChunkError:n,onChunkStarted:i,onChunkCompleted:a,options:{chunkSize:o}}){let s=e.getReader(),c=1,l=[],u=0;try{for(;;){let{done:e,value:n}=await s.read();if(t?.(n?.byteLength??0),e){if(u>0){i(c);let e=r(l);a({partNumber:c,stream:e,size:e.length})}break}let d=n;for(;d.length>0;){let e=o-u;if(d.length<=e){l.push(d),u+=d.length;break}else{let t=d.slice(0,e);l.push(t),u+=t.length,i(c);let n=r(l);a({partNumber:c,stream:n,size:n.length}),c+=1,l=[],u=0,d=d.slice(e)}}}}catch(e){throw n(c,e),e}finally{s.releaseLock()}}const a={split:({chunkSize:e,onChunkStarted:i,onChunkCompleted:a,onChunkError:o,onData:s})=>c=>n.Effect.gen(function*(){let l=yield*n.Ref.make({partNumber:1,buffer:[],bufferSize:0});return c.pipe(n.Stream.mapEffect(t=>n.Effect.gen(function*(){s&&(yield*n.Effect.sync(()=>s(t.byteLength)));let o=t,c=[];for(;o.length>0;){let t=yield*n.Ref.get(l),s=e-t.bufferSize;if(o.length<=s){yield*n.Ref.update(l,e=>({...e,buffer:[...e.buffer,o],bufferSize:e.bufferSize+o.length}));break}else{let e=o.slice(0,s),u=[...t.buffer,e];yield*n.Effect.sync(()=>i(t.partNumber));let d=r(u),f={partNumber:t.partNumber,stream:d,size:d.length};yield*n.Effect.sync(()=>a(f)),c.push(f),yield*n.Ref.set(l,{partNumber:t.partNumber+1,buffer:[],bufferSize:0}),o=o.slice(s)}}return c})),n.Stream.flatMap(e=>n.Stream.fromIterable(e)),n.Stream.concat(n.Stream.fromEffect((()=>n.Effect.gen(function*(){let e=yield*n.Ref.get(l);if(e.bufferSize===0)return[];yield*n.Effect.sync(()=>i(e.partNumber));let t=r(e.buffer),o={partNumber:e.partNumber,stream:t,size:t.length};return yield*n.Effect.sync(()=>a(o)),[o]}))()).pipe(n.Stream.flatMap(e=>n.Stream.fromIterable(e)))),n.Stream.tapError(e=>n.Effect.sync(()=>o(1,e))),n.Stream.mapError(e=>new t.UploadistaError({code:`UNKNOWN_ERROR`,status:500,body:`Stream splitting failed`,details:`Stream splitting failed: ${String(e)}`})))}).pipe(n.Stream.unwrap),fromReadableStream:(e,r)=>n.Effect.tryPromise({try:()=>i(e,r),catch:e=>new t.UploadistaError({code:`UNKNOWN_ERROR`,status:500,body:`Stream splitter failed`,details:`Stream splitter failed: ${String(e)}`})})};exports.StreamSplitterEffect=a,exports.streamSplitter=i;

package/dist/streams/stream-splitter.d.cts

@@ -1,68 +0,0 @@
-import { UploadistaError } from "../uploadista-error-kKlhLRhY.cjs";
-import { Effect, Stream } from "effect";
-
-//#region src/streams/stream-splitter.d.ts
-type Options = {
-  chunkSize: number;
-};
-type ChunkInfo = {
-  partNumber: number;
-  stream: Uint8Array;
-  size: number;
-};
-type EventHandlers = {
-  onData?: (chunkSize: number) => void;
-  onChunkStarted: (partNumber: number) => void;
-  onChunkCompleted: (chunkInfo: ChunkInfo) => void;
-  onChunkError: (partNumber: number, error: unknown) => void;
-};
-declare function streamSplitter(readStream: ReadableStream<Uint8Array>, {
-  onData,
-  onChunkError,
-  onChunkStarted,
-  onChunkCompleted,
-  options: {
-    chunkSize
-  }
-}: EventHandlers & {
-  options: Options;
-}): Promise<void>;
-/**
- * Effect-based stream splitter that splits a stream into chunks of specified size
- */
-declare const StreamSplitterEffect: {
-  /**
-   * Splits an Effect stream into chunks of specified size using idiomatic Effect-TS patterns
-   * @param chunkSize - Maximum size for each chunk in bytes
-   * @param onChunkStarted - Callback when a new chunk starts processing
-   * @param onChunkCompleted - Callback when a chunk is completed
-   * @param onChunkError - Callback when a chunk encounters an error
-   * @param onData - Optional callback for data progress
-   * @returns Effect that splits the input stream
-   */
-  split: ({
-    chunkSize,
-    onChunkStarted,
-    onChunkCompleted,
-    onChunkError,
-    onData
-  }: {
-    chunkSize: number;
-    onChunkStarted: (partNumber: number) => void;
-    onChunkCompleted: (chunkInfo: ChunkInfo) => void;
-    onChunkError: (partNumber: number, error: unknown) => void;
-    onData?: (chunkSize: number) => void;
-  }) => <E>(stream: Stream.Stream<Uint8Array, E>) => Stream.Stream<ChunkInfo, E | UploadistaError>;
-  /**
-   * Creates a legacy stream splitter effect from ReadableStream
-   * @param readStream - Input ReadableStream
-   * @param handlers - Event handlers for chunk processing
-   * @returns Effect that processes the stream
-   */
-  fromReadableStream: (readStream: ReadableStream<Uint8Array>, handlers: EventHandlers & {
-    options: Options;
-  }) => Effect.Effect<void, UploadistaError>;
-};
-//#endregion
-export { ChunkInfo, StreamSplitterEffect, streamSplitter };
-//# sourceMappingURL=stream-splitter.d.cts.map

package/dist/streams/stream-splitter.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-splitter.d.cts","names":[],"sources":["../../src/streams/stream-splitter.ts"],"sourcesContent":[],"mappings":";;;;KAGK,OAAA;;AAFwD,CAAA;AAMjD,KAAA,SAAA,GAAS;EAMhB,UAAA,EAAA,MAAa;EAiBI,MAAA,EArBZ,UAqB0B;EAAA,IAAA,EAAA,MAAA;;KAjB/B,aAAA,GAkBS;QAEV,CAAA,EAAA,CAAA,SAAA,EAAA,MAAA,EAAA,GAAA,IAAA;gBACA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,GAAA,IAAA;kBACA,EAAA,CAAA,SAAA,EAnB4B,SAmB5B,EAAA,GAAA,IAAA;cACA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;;AAEC,iBARiB,cAAA,CAQjB,UAAA,EAPS,cAOT,CAPwB,UAOxB,CAAA,EAAA;EAAA,MAAA;EAAA,YAAA;EAAA,cAAA;EAAA,gBAAA;EAAA,OAAA,EAAA;IAAA;EAAA;CAAA,EAAA,aAAA,GAAA;SAA2B,EAAA,OAAA;IAC7B,OAAA,CAAA,IAAA,CAAA;;AAyEH;;cAAa;;;;;;;;;;OA0BmB,EAAA,CAAA;IAAA,SAAA;IAAA,cAAA;IAAA,gBAAA;IAAA,YAAA;IAAA;GAAA,EAAA;IAAI,SAAA,EAAA,MAAA;IAA7B,cAAO,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,GAAA,IAAA;IAmHiB,gBAAA,EAAA,CAAA,SAAA,EAzHK,SAyHL,EAAA,GAAA,IAAA;IAAf,YAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;IACF,MAAA,CAAA,EAAA,CAAA,SAAA,EAAA,MAAA,EAAA,GAAA,IAAA;KAA2B,GAAA,CAAA,CAAA,CAAA,CAAA,MAAA,EArH3B,MAAA,CAAO,MAqHoB,CArHb,UAqHa,EArHD,CAqHC,CAAA,EAAA,GApHlC,MAAA,CAAO,MAoH2B,CApHpB,SAoHoB,EApHT,CAoHS,GApHL,eAoHK,CAAA;;;;;;;mCADzB,eAAe,uBACjB;aAA2B;QACpC,MAAA,CAAO,aAAa"}

package/dist/streams/stream-splitter.d.ts

@@ -1,51 +0,0 @@
-import { Effect, Stream } from "effect";
-import { UploadistaError } from "../errors/uploadista-error";
-type Options = {
-    chunkSize: number;
-};
-export type ChunkInfo = {
-    partNumber: number;
-    stream: Uint8Array;
-    size: number;
-};
-type EventHandlers = {
-    onData?: (chunkSize: number) => void;
-    onChunkStarted: (partNumber: number) => void;
-    onChunkCompleted: (chunkInfo: ChunkInfo) => void;
-    onChunkError: (partNumber: number, error: unknown) => void;
-};
-export declare function streamSplitter(readStream: ReadableStream<Uint8Array>, { onData, onChunkError, onChunkStarted, onChunkCompleted, options: { chunkSize }, }: EventHandlers & {
-    options: Options;
-}): Promise<void>;
-/**
- * Effect-based stream splitter that splits a stream into chunks of specified size
- */
-export declare const StreamSplitterEffect: {
-    /**
-     * Splits an Effect stream into chunks of specified size using idiomatic Effect-TS patterns
-     * @param chunkSize - Maximum size for each chunk in bytes
-     * @param onChunkStarted - Callback when a new chunk starts processing
-     * @param onChunkCompleted - Callback when a chunk is completed
-     * @param onChunkError - Callback when a chunk encounters an error
-     * @param onData - Optional callback for data progress
-     * @returns Effect that splits the input stream
-     */
-    split: ({ chunkSize, onChunkStarted, onChunkCompleted, onChunkError, onData, }: {
-        chunkSize: number;
-        onChunkStarted: (partNumber: number) => void;
-        onChunkCompleted: (chunkInfo: ChunkInfo) => void;
-        onChunkError: (partNumber: number, error: unknown) => void;
-        onData?: (chunkSize: number) => void;
-    }) => <E>(stream: Stream.Stream<Uint8Array, E>) => Stream.Stream<ChunkInfo, E | UploadistaError>;
-    /**
-     * Creates a legacy stream splitter effect from ReadableStream
-     * @param readStream - Input ReadableStream
-     * @param handlers - Event handlers for chunk processing
-     * @returns Effect that processes the stream
-     */
-    fromReadableStream: (readStream: ReadableStream<Uint8Array>, handlers: EventHandlers & {
-        options: Options;
-    }) => Effect.Effect<void, UploadistaError>;
-};
-export {};
-//# sourceMappingURL=stream-splitter.d.ts.map

package/dist/streams/stream-splitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-splitter.d.ts","sourceRoot":"","sources":["../../src/streams/stream-splitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAO,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,cAAc,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,gBAAgB,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;IACjD,YAAY,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC5D,CAAC;AAYF,wBAAsB,cAAc,CAClC,UAAU,EAAE,cAAc,CAAC,UAAU,CAAC,EACtC,EACE,MAAM,EACN,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,OAAO,EAAE,EAAE,SAAS,EAAE,GACvB,EAAE,aAAa,GAAG;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACtC,OAAO,CAAC,IAAI,CAAC,CAoEf;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;;;OAQG;oFAQE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;QAC7C,gBAAgB,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;QACjD,YAAY,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;QAC3D,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;KACtC,MACA,CAAC,EACA,QAAQ,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,KACnC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,GAAG,eAAe,CAAC;IA4GlD;;;;;OAKG;qCAEW,cAAc,CAAC,UAAU,CAAC,YAC5B,aAAa,GAAG;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAC7C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC;CAWxC,CAAC"}

package/dist/streams/stream-splitter.js

@@ -1,175 +0,0 @@
-import { Effect, Ref, Stream } from "effect";
-import { UploadistaError } from "../errors/uploadista-error";
-function concatArrayBuffers(chunks) {
-    const result = new Uint8Array(chunks.reduce((a, c) => a + c.length, 0));
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return result;
-}
-export async function streamSplitter(readStream, { onData, onChunkError, onChunkStarted, onChunkCompleted, options: { chunkSize }, }) {
-    const reader = readStream.getReader();
-    let part = 1;
-    let currentPartChunks = [];
-    let currentPartSize = 0;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            onData?.(value?.byteLength ?? 0);
-            if (done) {
-                // Process any remaining data
-                if (currentPartSize > 0) {
-                    onChunkStarted(part);
-                    const stream = concatArrayBuffers(currentPartChunks);
-                    onChunkCompleted({
-                        partNumber: part,
-                        stream,
-                        size: stream.length,
-                    });
-                }
-                break;
-            }
-            let remaining = value;
-            while (remaining.length > 0) {
-                const spaceInCurrentPart = chunkSize - currentPartSize;
-                if (remaining.length <= spaceInCurrentPart) {
-                    // All remaining data fits in current part
-                    currentPartChunks.push(remaining);
-                    currentPartSize += remaining.length;
-                    break;
-                }
-                else {
-                    // Need to split the data
-                    const partToTake = remaining.slice(0, spaceInCurrentPart);
-                    currentPartChunks.push(partToTake);
-                    currentPartSize += partToTake.length;
-                    // Complete current part
-                    onChunkStarted(part);
-                    const stream = concatArrayBuffers(currentPartChunks);
-                    onChunkCompleted({
-                        partNumber: part,
-                        stream,
-                        size: stream.length,
-                    });
-                    // Start new part
-                    part += 1;
-                    currentPartChunks = [];
-                    currentPartSize = 0;
-                    remaining = remaining.slice(spaceInCurrentPart);
-                }
-            }
-        }
-    }
-    catch (error) {
-        onChunkError(part, error);
-        throw error;
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
-/**
- * Effect-based stream splitter that splits a stream into chunks of specified size
- */
-export const StreamSplitterEffect = {
-    /**
-     * Splits an Effect stream into chunks of specified size using idiomatic Effect-TS patterns
-     * @param chunkSize - Maximum size for each chunk in bytes
-     * @param onChunkStarted - Callback when a new chunk starts processing
-     * @param onChunkCompleted - Callback when a chunk is completed
-     * @param onChunkError - Callback when a chunk encounters an error
-     * @param onData - Optional callback for data progress
-     * @returns Effect that splits the input stream
-     */
-    split: ({ chunkSize, onChunkStarted, onChunkCompleted, onChunkError, onData, }) => (stream) => {
-        return Effect.gen(function* () {
-            const stateRef = yield* Ref.make({
-                partNumber: 1,
-                buffer: [],
-                bufferSize: 0,
-            });
-            const processChunkAndEmitCompleted = (chunk) => Effect.gen(function* () {
-                // Report data progress
-                if (onData) {
-                    yield* Effect.sync(() => onData(chunk.byteLength));
-                }
-                let remaining = chunk;
-                const results = [];
-                while (remaining.length > 0) {
-                    const state = yield* Ref.get(stateRef);
-                    const spaceAvailable = chunkSize - state.bufferSize;
-                    if (remaining.length <= spaceAvailable) {
-                        // All remaining data fits in current part
-                        yield* Ref.update(stateRef, (s) => ({
-                            ...s,
-                            buffer: [...s.buffer, remaining],
-                            bufferSize: s.bufferSize + remaining.length,
-                        }));
-                        break;
-                    }
-                    else {
-                        // Need to split the data - complete current part
-                        const partToTake = remaining.slice(0, spaceAvailable);
-                        const completeBuffer = [...state.buffer, partToTake];
-                        // Execute side effects in Effect context
-                        yield* Effect.sync(() => onChunkStarted(state.partNumber));
-                        const concatenatedStream = concatArrayBuffers(completeBuffer);
-                        const chunkInfo = {
-                            partNumber: state.partNumber,
-                            stream: concatenatedStream,
-                            size: concatenatedStream.length,
-                        };
-                        yield* Effect.sync(() => onChunkCompleted(chunkInfo));
-                        results.push(chunkInfo);
-                        // Start new part
-                        yield* Ref.set(stateRef, {
-                            partNumber: state.partNumber + 1,
-                            buffer: [],
-                            bufferSize: 0,
-                        });
-                        remaining = remaining.slice(spaceAvailable);
-                    }
-                }
-                return results;
-            });
-            const emitFinalChunk = () => Effect.gen(function* () {
-                const finalState = yield* Ref.get(stateRef);
-                if (finalState.bufferSize === 0) {
-                    return [];
-                }
-                yield* Effect.sync(() => onChunkStarted(finalState.partNumber));
-                const concatenatedStream = concatArrayBuffers(finalState.buffer);
-                const chunkInfo = {
-                    partNumber: finalState.partNumber,
-                    stream: concatenatedStream,
-                    size: concatenatedStream.length,
-                };
-                yield* Effect.sync(() => onChunkCompleted(chunkInfo));
-                return [chunkInfo];
-            });
-            return stream.pipe(Stream.mapEffect(processChunkAndEmitCompleted), Stream.flatMap((chunkInfos) => Stream.fromIterable(chunkInfos)), Stream.concat(Stream.fromEffect(emitFinalChunk()).pipe(Stream.flatMap((chunkInfos) => Stream.fromIterable(chunkInfos)))), Stream.tapError((error) => Effect.sync(() => onChunkError(1, error))), Stream.mapError((error) => new UploadistaError({
-                code: "UNKNOWN_ERROR",
-                status: 500,
-                body: "Stream splitting failed",
-                details: `Stream splitting failed: ${String(error)}`,
-            })));
-        }).pipe(Stream.unwrap);
-    },
-    /**
-     * Creates a legacy stream splitter effect from ReadableStream
-     * @param readStream - Input ReadableStream
-     * @param handlers - Event handlers for chunk processing
-     * @returns Effect that processes the stream
-     */
-    fromReadableStream: (readStream, handlers) => Effect.tryPromise({
-        try: () => streamSplitter(readStream, handlers),
-        catch: (error) => new UploadistaError({
-            code: "UNKNOWN_ERROR",
-            status: 500,
-            body: "Stream splitter failed",
-            details: `Stream splitter failed: ${String(error)}`,
-        }),
-    }),
-};

package/dist/streams/stream-splitter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-splitter.js","names":["currentPartChunks: Uint8Array[]","results: ChunkInfo[]","chunkInfo: ChunkInfo"],"sources":["../../src/streams/stream-splitter.ts"],"sourcesContent":["import { Effect, Ref, Stream } from \"effect\";\nimport { UploadistaError } from \"../errors/uploadista-error\";\n\ntype Options = {\n  chunkSize: number;\n};\n\nexport type ChunkInfo = {\n  partNumber: number;\n  stream: Uint8Array;\n  size: number;\n};\n\ntype EventHandlers = {\n  onData?: (chunkSize: number) => void;\n  onChunkStarted: (partNumber: number) => void;\n  onChunkCompleted: (chunkInfo: ChunkInfo) => void;\n  onChunkError: (partNumber: number, error: unknown) => void;\n};\n\nfunction concatArrayBuffers(chunks: Uint8Array[]): Uint8Array {\n  const result = new Uint8Array(chunks.reduce((a, c) => a + c.length, 0));\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\n\nexport async function streamSplitter(\n  readStream: ReadableStream<Uint8Array>,\n  {\n    onData,\n    onChunkError,\n    onChunkStarted,\n    onChunkCompleted,\n    options: { chunkSize },\n  }: EventHandlers & { options: Options },\n): Promise<void> {\n  const reader = readStream.getReader();\n\n  let part = 1;\n  let currentPartChunks: Uint8Array[] = [];\n  let currentPartSize = 0;\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n\n      onData?.(value?.byteLength ?? 0);\n\n      if (done) {\n        // Process any remaining data\n        if (currentPartSize > 0) {\n          onChunkStarted(part);\n\n          const stream = concatArrayBuffers(currentPartChunks);\n\n          onChunkCompleted({\n            partNumber: part,\n            stream,\n            size: stream.length,\n          });\n        }\n        break;\n      }\n\n      let remaining = value;\n\n      while (remaining.length > 0) {\n        const spaceInCurrentPart = chunkSize - currentPartSize;\n\n        if (remaining.length <= spaceInCurrentPart) {\n          // All remaining data fits in current part\n          currentPartChunks.push(remaining);\n          currentPartSize += remaining.length;\n          break;\n        } else {\n          // Need to split the data\n          const partToTake = remaining.slice(0, spaceInCurrentPart);\n          currentPartChunks.push(partToTake);\n          currentPartSize += partToTake.length;\n\n          // Complete current part\n          onChunkStarted(part);\n          const stream = concatArrayBuffers(currentPartChunks);\n          onChunkCompleted({\n            partNumber: part,\n            stream,\n            size: stream.length,\n          });\n\n          // Start new part\n          part += 1;\n          currentPartChunks = [];\n          currentPartSize = 0;\n          remaining = remaining.slice(spaceInCurrentPart);\n        }\n      }\n    }\n  } catch (error) {\n    onChunkError(part, error);\n    throw error;\n  } finally {\n    reader.releaseLock();\n  }\n}\n\n/**\n * Effect-based stream splitter that splits a stream into chunks of specified size\n */\nexport const StreamSplitterEffect = {\n  /**\n   * Splits an Effect stream into chunks of specified size using idiomatic Effect-TS patterns\n   * @param chunkSize - Maximum size for each chunk in bytes\n   * @param onChunkStarted - Callback when a new chunk starts processing\n   * @param onChunkCompleted - Callback when a chunk is completed\n   * @param onChunkError - Callback when a chunk encounters an error\n   * @param onData - Optional callback for data progress\n   * @returns Effect that splits the input stream\n   */\n  split:\n    ({\n      chunkSize,\n      onChunkStarted,\n      onChunkCompleted,\n      onChunkError,\n      onData,\n    }: {\n      chunkSize: number;\n      onChunkStarted: (partNumber: number) => void;\n      onChunkCompleted: (chunkInfo: ChunkInfo) => void;\n      onChunkError: (partNumber: number, error: unknown) => void;\n      onData?: (chunkSize: number) => void;\n    }) =>\n    <E>(\n      stream: Stream.Stream<Uint8Array, E>,\n    ): Stream.Stream<ChunkInfo, E | UploadistaError> => {\n      return Effect.gen(function* () {\n        const stateRef = yield* Ref.make({\n          partNumber: 1,\n          buffer: [] as Uint8Array[],\n          bufferSize: 0,\n        });\n\n        const processChunkAndEmitCompleted = (\n          chunk: Uint8Array,\n        ): Effect.Effect<ChunkInfo[], UploadistaError> =>\n          Effect.gen(function* () {\n            // Report data progress\n            if (onData) {\n              yield* Effect.sync(() => onData(chunk.byteLength));\n            }\n\n            let remaining = chunk;\n            const results: ChunkInfo[] = [];\n\n            while (remaining.length > 0) {\n              const state = yield* Ref.get(stateRef);\n              const spaceAvailable = chunkSize - state.bufferSize;\n\n              if (remaining.length <= spaceAvailable) {\n                // All remaining data fits in current part\n                yield* Ref.update(stateRef, (s) => ({\n                  ...s,\n                  buffer: [...s.buffer, remaining],\n                  bufferSize: s.bufferSize + remaining.length,\n                }));\n                break;\n              } else {\n                // Need to split the data - complete current part\n                const partToTake = remaining.slice(0, spaceAvailable);\n                const completeBuffer = [...state.buffer, partToTake];\n\n                // Execute side effects in Effect context\n                yield* Effect.sync(() => onChunkStarted(state.partNumber));\n\n                const concatenatedStream = concatArrayBuffers(completeBuffer);\n                const chunkInfo: ChunkInfo = {\n                  partNumber: state.partNumber,\n                  stream: concatenatedStream,\n                  size: concatenatedStream.length,\n                };\n\n                yield* Effect.sync(() => onChunkCompleted(chunkInfo));\n                results.push(chunkInfo);\n\n                // Start new part\n                yield* Ref.set(stateRef, {\n                  partNumber: state.partNumber + 1,\n                  buffer: [],\n                  bufferSize: 0,\n                });\n                remaining = remaining.slice(spaceAvailable);\n              }\n            }\n\n            return results;\n          });\n\n        const emitFinalChunk = (): Effect.Effect<\n          ChunkInfo[],\n          UploadistaError\n        > =>\n          Effect.gen(function* () {\n            const finalState = yield* Ref.get(stateRef);\n            if (finalState.bufferSize === 0) {\n              return [];\n            }\n\n            yield* Effect.sync(() => onChunkStarted(finalState.partNumber));\n\n            const concatenatedStream = concatArrayBuffers(finalState.buffer);\n            const chunkInfo: ChunkInfo = {\n              partNumber: finalState.partNumber,\n              stream: concatenatedStream,\n              size: concatenatedStream.length,\n            };\n\n            yield* Effect.sync(() => onChunkCompleted(chunkInfo));\n            return [chunkInfo];\n          });\n\n        return stream.pipe(\n          Stream.mapEffect(processChunkAndEmitCompleted),\n          Stream.flatMap((chunkInfos) => Stream.fromIterable(chunkInfos)),\n          Stream.concat(\n            Stream.fromEffect(emitFinalChunk()).pipe(\n              Stream.flatMap((chunkInfos) => Stream.fromIterable(chunkInfos)),\n            ),\n          ),\n          Stream.tapError((error) => Effect.sync(() => onChunkError(1, error))),\n          Stream.mapError(\n            (error) =>\n              new UploadistaError({\n                code: \"UNKNOWN_ERROR\",\n                status: 500,\n                body: \"Stream splitting failed\",\n                details: `Stream splitting failed: ${String(error)}`,\n              }),\n          ),\n        );\n      }).pipe(Stream.unwrap);\n    },\n\n  /**\n   * Creates a legacy stream splitter effect from ReadableStream\n   * @param readStream - Input ReadableStream\n   * @param handlers - Event handlers for chunk processing\n   * @returns Effect that processes the stream\n   */\n  fromReadableStream: (\n    readStream: ReadableStream<Uint8Array>,\n    handlers: EventHandlers & { options: Options },\n  ): Effect.Effect<void, UploadistaError> =>\n    Effect.tryPromise({\n      try: () => streamSplitter(readStream, handlers),\n      catch: (error) =>\n        new UploadistaError({\n          code: \"UNKNOWN_ERROR\",\n          status: 500,\n          body: \"Stream splitter failed\",\n          details: `Stream splitter failed: ${String(error)}`,\n        }),\n    }),\n};\n"],"mappings":"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"}

package/dist/types/data-store-registry.d.ts

@@ -1,13 +0,0 @@
-import { Context, type Effect } from "effect";
-import type { UploadistaError } from "../errors";
-import type { DataStore } from "./data-store";
-import type { UploadFile } from "./upload-file";
-declare const DataStoreRegistry_base: Context.TagClass<DataStoreRegistry, "DataStoreRegistry", {
-    readonly register: <T extends DataStore<UploadFile>>(id: string, store: Effect.Effect<T, UploadistaError>) => Effect.Effect<void, never>;
-    readonly get: (id: string) => Effect.Effect<DataStore<UploadFile>, UploadistaError>;
-    readonly list: () => Effect.Effect<Array<string>, never>;
-}>;
-export declare class DataStoreRegistry extends DataStoreRegistry_base {
-}
-export {};
-//# sourceMappingURL=data-store-registry.d.ts.map

package/dist/types/data-store-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-store-registry.d.ts","sourceRoot":"","sources":["../../src/types/data-store-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;uBAMzB,CAAC,CAAC,SAAS,SAAS,CAAC,UAAU,CAAC,EACjD,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,CAAC,KACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;kBACjB,CACZ,EAAE,EAAE,MAAM,KACP,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;mBAC3C,MAAM,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC;;AAV5D,qBAAa,iBAAkB,SAAQ,sBAYpC;CAAG"}

package/dist/types/data-store-registry.js

@@ -1,4 +0,0 @@
-import { Context } from "effect";
-// Data Store Registry service for managing multiple data stores
-export class DataStoreRegistry extends Context.Tag("DataStoreRegistry")() {
-}