@uploadista/core 0.0.2

package/dist/streams/stream-limiter.cjs

@@ -0,0 +1 @@
+require(`../uploadista-error-BB-Wdiz9.cjs`);const e=require(`../stream-limiter-JgOwmkMa.cjs`);exports.StreamLimiterEffect=e.StreamLimiterEffect,exports.streamLimiter=e.streamLimiter;

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

@@ -0,0 +1,36 @@
+import { UploadistaError } from "../uploadista-error-kKlhLRhY.cjs";
+import { Stream } from "effect";
+
+//#region src/streams/stream-limiter.d.ts
+type StreamLimiterOptions = {
+  maxSize: number;
+  onData?: (chunkSize: number) => void;
+};
+declare function streamLimiter({
+  maxSize,
+  onData
+}: StreamLimiterOptions): TransformStream;
+/**
+ * Effect-based stream limiter that restricts stream size
+ */
+declare 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
+  }: StreamLimiterOptions) => <A>(stream: Stream.Stream<A, UploadistaError>) => Stream.Stream<A, UploadistaError, never>;
+  /**
+   * Creates a legacy TransformStream-based limiter
+   * @param options - Stream limiter options
+   * @returns TransformStream that enforces size limits
+   */
+  createTransformStream: (options: StreamLimiterOptions) => TransformStream;
+};
+//#endregion
+export { StreamLimiterEffect, streamLimiter };
+//# sourceMappingURL=stream-limiter.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream-limiter.d.cts","names":[],"sources":["../../src/streams/stream-limiter.ts"],"sourcesContent":[],"mappings":";;;;KAGK,oBAAA;;EAAA,MAAA,CAAA,EAAA,CAAA,SAAA,EAAA,MAAoB,EAAA,GAAA,IAAA;AAKzB,CAAA;AAA6B,iBAAb,aAAA,CAAa;EAAA,OAAA;EAAA;AAAA,CAAA,EAG1B,oBAH0B,CAAA,EAGH,eAHG;;;;AAGH,cAqBb,mBArBa,EAAA;EAAe;AAqBzC;;;;;OAS8B,EAAA,CAAA;IAAA,OAAA;IAAA;EAAA,CAAA,EADJ,oBACI,EAAA,GAAA,CAAA,CAAA,CAAA,CAAA,MAAA,EAAd,MAAA,CAAO,MAAO,CAAA,CAAA,EAAG,eAAH,CAAA,EAAA,GAAmB,MAAA,CAAA,MAAnB,CAAmB,CAAnB,EAAmB,eAAnB,EAAA,KAAA,CAAA;;;;;;uBA+BK,EAAA,CAAA,OAAA,EAAA,oBAAA,EAAA,GAAuB,eAAvB"}

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

@@ -0,0 +1,27 @@
+import { Stream } from "effect";
+import { UploadistaError } from "../errors/uploadista-error";
+type StreamLimiterOptions = {
+    maxSize: number;
+    onData?: (chunkSize: number) => void;
+};
+export declare function streamLimiter({ maxSize, onData, }: StreamLimiterOptions): TransformStream;
+/**
+ * Effect-based stream limiter that restricts stream size
+ */
+export declare 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 }: StreamLimiterOptions) => <A>(stream: Stream.Stream<A, UploadistaError>) => Stream.Stream<A, UploadistaError, never>;
+    /**
+     * Creates a legacy TransformStream-based limiter
+     * @param options - Stream limiter options
+     * @returns TransformStream that enforces size limits
+     */
+    createTransformStream: (options: StreamLimiterOptions) => TransformStream;
+};
+export {};
+//# sourceMappingURL=stream-limiter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream-limiter.d.ts","sourceRoot":"","sources":["../../src/streams/stream-limiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,KAAK,oBAAoB,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC,CAAC;AAEF,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,MAAM,GACP,EAAE,oBAAoB,GAAG,eAAe,CAgBxC;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;OAKG;iCAEqB,oBAAoB,MACzC,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,CAAC;IA0B/C;;;;OAIG;qCAC8B,oBAAoB,KAAG,eAAe;CAExE,CAAC"}

package/dist/streams/stream-limiter.js

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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":"uHAoBA,SAAS,EAAmB,EAAkC,CAC5D,IAAM,EAAS,IAAI,WAAW,EAAO,QAAQ,EAAG,IAAM,EAAI,EAAE,OAAQ,EAAE,CAAC,CACnE,EAAS,EACb,IAAK,IAAM,KAAS,EAClB,EAAO,IAAI,EAAO,EAAO,CACzB,GAAU,EAAM,OAElB,OAAO,EAGT,eAAsB,EACpB,EACA,CACE,SACA,eACA,iBACA,mBACA,QAAS,CAAE,cAEE,CACf,IAAM,EAAS,EAAW,WAAW,CAEjC,EAAO,EACPA,EAAkC,EAAE,CACpC,EAAkB,EAEtB,GAAI,CACF,OAAa,CACX,GAAM,CAAE,OAAM,SAAU,MAAM,EAAO,MAAM,CAI3C,GAFA,IAAS,GAAO,YAAc,EAAE,CAE5B,EAAM,CAER,GAAI,EAAkB,EAAG,CACvB,EAAe,EAAK,CAEpB,IAAM,EAAS,EAAmB,EAAkB,CAEpD,EAAiB,CACf,WAAY,EACZ,SACA,KAAM,EAAO,OACd,CAAC,CAEJ,MAGF,IAAI,EAAY,EAEhB,KAAO,EAAU,OAAS,GAAG,CAC3B,IAAM,EAAqB,EAAY,EAEvC,GAAI,EAAU,QAAU,EAAoB,CAE1C,EAAkB,KAAK,EAAU,CACjC,GAAmB,EAAU,OAC7B,UACK,CAEL,IAAM,EAAa,EAAU,MAAM,EAAG,EAAmB,CACzD,EAAkB,KAAK,EAAW,CAClC,GAAmB,EAAW,OAG9B,EAAe,EAAK,CACpB,IAAM,EAAS,EAAmB,EAAkB,CACpD,EAAiB,CACf,WAAY,EACZ,SACA,KAAM,EAAO,OACd,CAAC,CAGF,GAAQ,EACR,EAAoB,EAAE,CACtB,EAAkB,EAClB,EAAY,EAAU,MAAM,EAAmB,UAI9C,EAAO,CAEd,MADA,EAAa,EAAM,EAAM,CACnB,SACE,CACR,EAAO,aAAa,EAOxB,MAAa,EAAuB,CAUlC,OACG,CACC,YACA,iBACA,mBACA,eACA,YASA,GAEO,EAAO,IAAI,WAAa,CAC7B,IAAM,EAAW,MAAO,EAAI,KAAK,CAC/B,WAAY,EACZ,OAAQ,EAAE,CACV,WAAY,EACb,CAAC,CAgFF,OAAO,EAAO,KACZ,EAAO,UA9EP,GAEA,EAAO,IAAI,WAAa,CAElB,IACF,MAAO,EAAO,SAAW,EAAO,EAAM,WAAW,CAAC,EAGpD,IAAI,EAAY,EACVC,EAAuB,EAAE,CAE/B,KAAO,EAAU,OAAS,GAAG,CAC3B,IAAM,EAAQ,MAAO,EAAI,IAAI,EAAS,CAChC,EAAiB,EAAY,EAAM,WAEzC,GAAI,EAAU,QAAU,EAAgB,CAEtC,MAAO,EAAI,OAAO,EAAW,IAAO,CAClC,GAAG,EACH,OAAQ,CAAC,GAAG,EAAE,OAAQ,EAAU,CAChC,WAAY,EAAE,WAAa,EAAU,OACtC,EAAE,CACH,UACK,CAEL,IAAM,EAAa,EAAU,MAAM,EAAG,EAAe,CAC/C,EAAiB,CAAC,GAAG,EAAM,OAAQ,EAAW,CAGpD,MAAO,EAAO,SAAW,EAAe,EAAM,WAAW,CAAC,CAE1D,IAAM,EAAqB,EAAmB,EAAe,CACvDC,EAAuB,CAC3B,WAAY,EAAM,WAClB,OAAQ,EACR,KAAM,EAAmB,OAC1B,CAED,MAAO,EAAO,SAAW,EAAiB,EAAU,CAAC,CACrD,EAAQ,KAAK,EAAU,CAGvB,MAAO,EAAI,IAAI,EAAU,CACvB,WAAY,EAAM,WAAa,EAC/B,OAAQ,EAAE,CACV,WAAY,EACb,CAAC,CACF,EAAY,EAAU,MAAM,EAAe,EAI/C,OAAO,GACP,CA0B4C,CAC9C,EAAO,QAAS,GAAe,EAAO,aAAa,EAAW,CAAC,CAC/D,EAAO,OACL,EAAO,gBAvBT,EAAO,IAAI,WAAa,CACtB,IAAM,EAAa,MAAO,EAAI,IAAI,EAAS,CAC3C,GAAI,EAAW,aAAe,EAC5B,MAAO,EAAE,CAGX,MAAO,EAAO,SAAW,EAAe,EAAW,WAAW,CAAC,CAE/D,IAAM,EAAqB,EAAmB,EAAW,OAAO,CAC1DA,EAAuB,CAC3B,WAAY,EAAW,WACvB,OAAQ,EACR,KAAM,EAAmB,OAC1B,CAGD,OADA,MAAO,EAAO,SAAW,EAAiB,EAAU,CAAC,CAC9C,CAAC,EAAU,EAClB,GAMkC,CAAC,CAAC,KAClC,EAAO,QAAS,GAAe,EAAO,aAAa,EAAW,CAAC,CAChE,CACF,CACD,EAAO,SAAU,GAAU,EAAO,SAAW,EAAa,EAAG,EAAM,CAAC,CAAC,CACrE,EAAO,SACJ,GACC,IAAI,EAAgB,CAClB,KAAM,gBACN,OAAQ,IACR,KAAM,0BACN,QAAS,4BAA4B,OAAO,EAAM,GACnD,CAAC,CACL,CACF,EACD,CAAC,KAAK,EAAO,OAAO,CAS1B,oBACE,EACA,IAEA,EAAO,WAAW,CAChB,QAAW,EAAe,EAAY,EAAS,CAC/C,MAAQ,GACN,IAAI,EAAgB,CAClB,KAAM,gBACN,OAAQ,IACR,KAAM,yBACN,QAAS,2BAA2B,OAAO,EAAM,GAClD,CAAC,CACL,CAAC,CACL"}

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

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

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

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