@uploadista/data-store-azure 0.0.3 → 0.0.4

package/.turbo/turbo-build.log

@@ -1,5 +1,22 @@
 
 
-> @uploadista/data-store-azure@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/data-stores/azure
-> tsc -b
+> @uploadista/data-store-azure@0.0.3 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/data-stores/azure
+> tsdown
 
+ℹ tsdown v0.15.9 powered by rolldown v1.0.0-beta.44
+ℹ Using tsdown config: /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/data-stores/azure/tsdown.config.ts
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 7 files
+ℹ [CJS] dist/index.cjs  11.85 kB │ gzip: 3.94 kB
+ℹ [CJS] 1 files, total: 11.85 kB
+ℹ [ESM] dist/index.js        10.42 kB │ gzip:  3.73 kB
+ℹ [ESM] dist/index.js.map    46.57 kB │ gzip: 11.51 kB
+ℹ [ESM] dist/index.d.ts.map   0.65 kB │ gzip:  0.33 kB
+ℹ [ESM] dist/index.d.ts       2.68 kB │ gzip:  1.09 kB
+ℹ [ESM] 4 files, total: 60.33 kB
+ℹ [CJS] dist/index.d.cts.map  0.65 kB │ gzip: 0.34 kB
+ℹ [CJS] dist/index.d.cts      2.68 kB │ gzip: 1.10 kB
+ℹ [CJS] 2 files, total: 3.34 kB
+✔ Build complete in 6413ms

package/dist/index.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));let c=require(`@azure/storage-blob`);c=s(c);let l=require(`@uploadista/core/errors`);l=s(l);let u=require(`@uploadista/observability`);u=s(u);let d=require(`effect`);d=s(d);const f=e=>typeof globalThis<`u`&&`Buffer`in globalThis?globalThis.Buffer.from(e):new Uint8Array(Array.from(e,e=>e.charCodeAt(0)));function p(e){return e&&e.length>0?e.reduce((e,t)=>e+(t?.size??0),0):0}function m({deliveryUrl:e,blockSize:t,minBlockSize:n=1024,maxBlocks:r=5e4,kvStore:i,maxConcurrentBlockUploads:a=60,expirationPeriodInMilliseconds:o=1e3*60*60*24*7,connectionString:s,sasUrl:m,credential:h,accountName:g,accountKey:_,containerName:v}){let y=t||8*1024*1024,b;if(s)b=c.BlobServiceClient.fromConnectionString(s);else if(m)b=new c.BlobServiceClient(m);else if(h){let e=g?`https://${g}.blob.core.windows.net`:m?.split(`?`)[0]||``;if(!e)throw Error(`When using credential authentication, either accountName or a valid sasUrl must be provided to determine the account URL`);b=new c.BlobServiceClient(e,h)}else if(g&&_)try{let e=new c.StorageSharedKeyCredential(g,_);b=new c.BlobServiceClient(`https://${g}.blob.core.windows.net`,e)}catch(e){throw Error(`StorageSharedKeyCredential is only available in Node.js environments. Use sasUrl or credential options for cross-platform compatibility. Original error: ${e}`)}else throw Error(`Azure authentication required. Provide one of: connectionString, sasUrl, credential, or accountName + accountKey (Node.js only)`);let x=b.getContainerClient(v),S=e=>`${e}.incomplete`,C=(e,t,n)=>(0,u.withAzureTimingMetrics)(u.azurePartUploadDurationHistogram,d.Effect.gen(function*(){yield*d.Effect.logInfo(`Uploading block`).pipe(d.Effect.annotateLogs({upload_id:e.id,block_id:n,block_size:t.length})),yield*(0,u.azureUploadPartsTotal)(d.Effect.succeed(1)),yield*(0,u.azurePartSizeHistogram)(d.Effect.succeed(t.length));try{let r=x.getBlockBlobClient(e.id);yield*d.Effect.tryPromise({try:async()=>{await r.stageBlock(n,t,t.length)},catch:r=>(d.Effect.runSync((0,u.trackAzureError)(`uploadBlock`,r,{upload_id:e.id,block_id:n,block_size:t.length})),l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:r}))}),yield*d.Effect.logInfo(`Finished uploading block`).pipe(d.Effect.annotateLogs({upload_id:e.id,block_id:n,block_size:t.length}))}catch(r){throw d.Effect.runSync((0,u.trackAzureError)(`uploadBlock`,r,{upload_id:e.id,block_id:n,block_size:t.length})),r}})),w=(e,t)=>d.Effect.tryPromise({try:async()=>{await x.getBlockBlobClient(S(e)).upload(t,t.length)},catch:e=>l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:e})}).pipe(d.Effect.tap(()=>d.Effect.logInfo(`Finished uploading incomplete block`).pipe(d.Effect.annotateLogs({upload_id:e})))),T=e=>d.Effect.tryPromise({try:async()=>{try{return(await x.getBlockBlobClient(S(e)).download()).readableStreamBody}catch(e){if(e&&typeof e==`object`&&`statusCode`in e&&e.statusCode===404)return;throw e}},catch:e=>l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),E=e=>d.Effect.tryPromise({try:async()=>{try{return(await x.getBlockBlobClient(S(e)).getProperties()).contentLength}catch(e){if(e&&typeof e==`object`&&`statusCode`in e&&e.statusCode===404)return;throw e}},catch:e=>l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),D=e=>d.Effect.tryPromise({try:async()=>{await x.getBlockBlobClient(S(e)).deleteIfExists()},catch:e=>l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),O=e=>d.Effect.gen(function*(){let t=yield*T(e);if(!t)return;let n=t.getReader(),r=[],i=0;try{for(;;){let e=yield*d.Effect.promise(()=>n.read());if(e.done)break;r.push(e.value),i+=e.value.length}}finally{n.releaseLock()}let a=d.Stream.fromIterable(r);return{size:i,stream:a}}),k=e=>{let t=e??5497558138880,i;i=t<=y?t:t<=y*r?y:Math.ceil(t/r);let a=Math.max(i,n);return Math.ceil(a/1024)*1024},A=e=>t=>d.Stream.async(n=>{let r=new Uint8Array,i=1,a=0,o=(t,r=!1)=>{d.Effect.runSync(d.Effect.logInfo(`Creating chunk`).pipe(d.Effect.annotateLogs({block_number:i,chunk_size:t.length,expected_size:e,is_final_chunk:r,total_bytes_processed:a+t.length}))),n.single({blockNumber:i++,data:t,size:t.length})},s=t=>{let n=new Uint8Array(r.length+t.length);for(n.set(r),n.set(t,r.length),r=n,a+=t.length;r.length>=e;){let t=r.slice(0,e);r=r.slice(e),o(t,!1)}};d.Effect.runFork(t.pipe(d.Stream.runForEach(e=>d.Effect.sync(()=>s(e))),d.Effect.andThen(()=>d.Effect.sync(()=>{r.length>0&&o(r,!0),n.end()})),d.Effect.catchAll(e=>d.Effect.sync(()=>n.fail(e)))))}),j=(e,t=0)=>n=>e?d.Effect.gen(function*(){let r=yield*d.Ref.make(t);return n.pipe(d.Stream.tap(t=>d.Effect.gen(function*(){e(yield*d.Ref.updateAndGet(r,e=>e+t.length))})))}).pipe(d.Stream.unwrap):n,M=(e,t,r,i,o)=>d.Effect.gen(function*(){yield*d.Effect.logInfo(`Uploading blocks`).pipe(d.Effect.annotateLogs({upload_id:e.id,init_offset:i,file_size:e.size}));let s=e.size,c=k(s);yield*d.Effect.logInfo(`Block size`).pipe(d.Effect.annotateLogs({upload_id:e.id,block_size:c}));let p=t.pipe(j(o,i),A(c)),m=yield*d.Ref.make(i),h=yield*d.Ref.make(0),g=yield*d.Ref.make([]),_=t=>d.Effect.gen(function*(){let i=yield*d.Ref.updateAndGet(m,e=>e+t.size),a=i>=(e.size||0);yield*d.Effect.logDebug(`Processing chunk`).pipe(d.Effect.annotateLogs({upload_id:e.id,cumulative_offset:i,file_size:e.size,chunk_size:t.size,is_final_block:a}));let o=r+t.blockNumber-1;if(t.size>c&&(yield*d.Effect.fail(l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:Error(`Block size ${t.size} exceeds upload block size ${c}`)}))),t.size>=n||a){yield*d.Effect.logDebug(`Uploading multipart chunk`).pipe(d.Effect.annotateLogs({upload_id:e.id,block_number:o,chunk_size:t.size,min_block_size:n,is_final_block:a}));let r=f(`block-${o.toString().padStart(6,`0`)}`).toString(`base64`);yield*C(e,t.data,r),yield*d.Ref.update(g,e=>[...e,r]),yield*(0,u.azurePartSizeHistogram)(d.Effect.succeed(t.size))}else yield*w(e.id,t.data);yield*d.Ref.update(h,e=>e+t.size)});return yield*p.pipe(d.Stream.runForEach(e=>_(e)),d.Effect.withConcurrency(a)),{bytesUploaded:yield*d.Ref.get(h),blockIds:yield*d.Ref.get(g)}}),N=(e,t)=>d.Effect.tryPromise({try:async()=>{await x.getBlockBlobClient(e.id).commitBlockList(t,{blobHTTPHeaders:{blobContentType:e.metadata?.contentType?.toString(),blobCacheControl:e.metadata?.cacheControl?.toString()}})},catch:e=>l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),P=e=>d.Effect.tryPromise({try:async()=>{try{return(await x.getBlockBlobClient(e).getBlockList(`committed`)).committedBlocks?.map(e=>({size:e.size}))??[]}catch(e){if(e&&typeof e==`object`&&`statusCode`in e&&e.statusCode===404)return[];throw e}},catch:e=>l.UploadistaError.fromCode(`UPLOAD_ID_NOT_FOUND`,{cause:e})}),F=e=>d.Effect.gen(function*(){yield*d.Effect.logInfo(`Removing cached data`).pipe(d.Effect.annotateLogs({upload_id:e})),yield*i.delete(e)}),I=t=>d.Effect.gen(function*(){return yield*(0,u.azureUploadRequestsTotal)(d.Effect.succeed(1)),yield*(0,u.azureActiveUploadsGauge)(d.Effect.succeed(1)),yield*(0,u.azureFileSizeHistogram)(d.Effect.succeed(t.size||0)),yield*d.Effect.logInfo(`Initializing Azure blob upload`).pipe(d.Effect.annotateLogs({upload_id:t.id})),t.creationDate=new Date().toISOString(),t.storage={id:t.storage.id,type:t.storage.type,path:t.id,bucket:v},t.url=`${e}/${t.id}`,yield*i.set(t.id,t),yield*d.Effect.logInfo(`Azure blob upload initialized`).pipe(d.Effect.annotateLogs({upload_id:t.id})),t}),L=e=>d.Effect.tryPromise({try:async()=>{let t=await x.getBlockBlobClient(e).download();if(t.blobBody)return t.blobBody;if(t.readableStreamBody)return t.readableStreamBody;throw Error(`No blob body or readable stream body`)},catch:e=>l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),R=e=>d.Effect.gen(function*(){let t=yield*L(e);if(t instanceof Blob){let e=yield*d.Effect.promise(()=>t.arrayBuffer());return new Uint8Array(e)}let n=t.getReader(),r=[];try{for(;;){let e=yield*d.Effect.promise(()=>n.read());if(e.done)break;r.push(e.value)}}finally{n.releaseLock()}let i=r.reduce((e,t)=>e+t.length,0),a=new Uint8Array(i),o=0;for(let e of r)a.set(e,o),o+=e.length;return a}),z=(e,t,n)=>d.Effect.gen(function*(){let r=yield*i.get(e),a=(yield*P(e)).length+1,o=yield*O(e);if(o){yield*D(e);let i=t-o.size,s=o.stream.pipe(d.Stream.concat(n));return{uploadFile:r,nextBlockNumber:a-1,offset:i,incompleteBlockSize:o.size,data:s}}else return{uploadFile:r,nextBlockNumber:a,offset:t,incompleteBlockSize:0,data:n}}),B=(e,t)=>(0,u.withAzureUploadMetrics)(e.file_id,(0,u.withAzureTimingMetrics)(u.azureUploadDurationHistogram,d.Effect.gen(function*(){let n=Date.now(),{stream:r,file_id:i,offset:a}=e,{onProgress:o}=t,{uploadFile:s,nextBlockNumber:c,offset:l,data:f}=yield*z(i,a,r),{bytesUploaded:p,blockIds:m}=yield*M(s,f,c,l,o),h=l+p;if(s.size===h)try{yield*N(s,m),yield*F(i),yield*(0,u.logAzureUploadCompletion)(i,{fileSize:s.size||0,totalDurationMs:Date.now()-n,partsCount:m.length,averagePartSize:s.size,throughputBps:s.size/(Date.now()-n),retryCount:0}),yield*(0,u.azureUploadSuccessTotal)(d.Effect.succeed(1)),yield*(0,u.azureActiveUploadsGauge)(d.Effect.succeed(-1))}catch(e){throw yield*d.Effect.logError(`Failed to finish upload`).pipe(d.Effect.annotateLogs({upload_id:i,error:JSON.stringify(e)})),yield*(0,u.azureUploadErrorsTotal)(d.Effect.succeed(1)),d.Effect.runSync((0,u.trackAzureError)(`write`,e,{upload_id:i,operation:`commit`,blocks:m.length})),e}return h}))),V=e=>d.Effect.gen(function*(){let t=yield*i.get(e),n=0;try{n=p(yield*P(e))}catch(n){if(typeof n==`object`&&n&&`statusCode`in n&&n.statusCode===404)return{...t,offset:t.size,size:t.size,metadata:t.metadata,storage:t.storage};throw yield*d.Effect.logError(`Error on get upload`).pipe(d.Effect.annotateLogs({upload_id:e,error:JSON.stringify(n)})),n}let r=yield*E(e);return{...t,offset:n+(r??0),size:t.size,storage:t.storage}}),H=e=>d.Effect.gen(function*(){try{let t=x.getBlockBlobClient(e);yield*d.Effect.promise(()=>t.deleteIfExists()),yield*D(e)}catch(t){if(typeof t==`object`&&t&&`statusCode`in t&&t.statusCode===404)return yield*d.Effect.logError(`No file found`).pipe(d.Effect.annotateLogs({upload_id:e})),yield*d.Effect.fail(l.UploadistaError.fromCode(`FILE_NOT_FOUND`));throw d.Effect.runSync((0,u.trackAzureError)(`remove`,t,{upload_id:e})),t}yield*F(e),yield*(0,u.azureActiveUploadsGauge)(d.Effect.succeed(-1))}),U=()=>o,W=e=>{let t=new Date(e);return new Date(t.getTime()+U())},G=()=>d.Effect.tryPromise({try:async()=>{if(U()===0)return 0;let e=0,t=x.listBlobsFlat({includeMetadata:!0}),n=[];for await(let e of t)if(e.metadata?.creationDate){let t=new Date(e.metadata.creationDate);Date.now()>W(t.toISOString()).getTime()&&n.push(e.name)}for(let t of n)await x.deleteBlob(t),e++;return e},catch:e=>l.UploadistaError.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),K=()=>({supportsParallelUploads:!0,supportsConcatenation:!1,supportsDeferredLength:!0,supportsResumableUploads:!0,supportsTransactionalUploads:!0,maxConcurrentUploads:a,minChunkSize:n,maxChunkSize:4e3*1024*1024,maxParts:r,optimalChunkSize:y,requiresOrderedChunks:!1,requiresMimeTypeValidation:!0,maxValidationSize:void 0});return{bucket:v,create:I,remove:H,write:B,getUpload:V,read:R,readStream:L,deleteExpired:G(),getCapabilities:K,getChunkerConstraints:()=>({minChunkSize:n,maxChunkSize:4e3*1024*1024,optimalChunkSize:y,requiresOrderedChunks:!1}),validateUploadStrategy:e=>{let t=K(),n=(()=>{switch(e){case`parallel`:return t.supportsParallelUploads;case`single`:return!0;default:return!1}})();return d.Effect.succeed(n)}}}exports.azureStore=m;

package/dist/index.d.cts

@@ -0,0 +1,85 @@
+import { TokenCredential } from "@azure/core-auth";
+import { UploadistaError } from "@uploadista/core/errors";
+import { DataStore, KvStore, UploadFile } from "@uploadista/core/types";
+import { Effect } from "effect";
+
+//#region src/azure-store.d.ts
+type ChunkInfo = {
+  blockNumber: number;
+  data: Uint8Array;
+  size: number;
+  isFinalPart?: boolean;
+};
+type AzureStoreOptions = {
+  deliveryUrl: string;
+  /**
+   * The preferred block size for blocks sent to Azure. Can not be lower than 1 byte or more than 4000MiB.
+   * The server calculates the optimal block size, which takes this size into account,
+   * but may increase it to not exceed the Azure 50K blocks limit.
+   */
+  blockSize?: number;
+  /**
+   * The minimal block size for blocks.
+   * Can be used to ensure that all non-trailing blocks are exactly the same size.
+   * Can not be lower than 1 byte or more than 4000MiB.
+   */
+  minBlockSize?: number;
+  /**
+   * The maximum number of blocks allowed in a block blob upload. Defaults to 50,000.
+   */
+  maxBlocks?: number;
+  maxConcurrentBlockUploads?: number;
+  kvStore: KvStore<UploadFile>;
+  expirationPeriodInMilliseconds?: number;
+  connectionString?: string;
+  /**
+   * SAS URL for the storage account (works in all environments including browsers)
+   * Format: https://<account>.blob.core.windows.net?<sas-token>
+   */
+  sasUrl?: string;
+  /**
+   * TokenCredential for OAuth authentication (e.g., DefaultAzureCredential)
+   * Works in all environments and is the recommended approach for production
+   */
+  credential?: TokenCredential;
+  /**
+   * Account name and key for shared key authentication (Node.js only)
+   * @deprecated Use sasUrl or credential instead for cross-platform compatibility
+   */
+  accountName?: string;
+  /**
+   * @deprecated Use sasUrl or credential instead for cross-platform compatibility
+   */
+  accountKey?: string;
+  containerName: string;
+};
+type AzureStore = DataStore<UploadFile> & {
+  getUpload: (id: string) => Effect.Effect<UploadFile, UploadistaError>;
+  readStream: (id: string) => Effect.Effect<ReadableStream | Blob, UploadistaError>;
+  getChunkerConstraints: () => {
+    minChunkSize: number;
+    maxChunkSize: number;
+    optimalChunkSize: number;
+    requiresOrderedChunks: boolean;
+  };
+};
+declare function azureStore({
+  deliveryUrl,
+  blockSize,
+  minBlockSize,
+  // 1KB minimum
+  maxBlocks,
+  kvStore,
+  maxConcurrentBlockUploads,
+  expirationPeriodInMilliseconds,
+  // 1 week
+  connectionString,
+  sasUrl,
+  credential,
+  accountName,
+  accountKey,
+  containerName
+}: AzureStoreOptions): AzureStore;
+//#endregion
+export { AzureStore, AzureStoreOptions, ChunkInfo, azureStore };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/azure-store.ts"],"sourcesContent":[],"mappings":";;;;;;KA4CY,SAAA;;EAAA,IAAA,EAEJ,UAFa;EAOT,IAAA,EAAA,MAAA;EAmBO,WAAA,CAAA,EAAA,OAAA;CAAR;AAaI,KAhCH,iBAAA,GAgCG;EAAe,WAAA,EAAA,MAAA;EAmBlB;;;;;EACiB,SAAO,CAAA,EAAA,MAAA;EAGf;;;;;EASL,YAAA,CAAU,EAAA,MAAA;EACxB;;;EAGA,SAAA,CAAA,EAAA,MAAA;EACA,yBAAA,CAAA,EAAA,MAAA;EACA,OAAA,EAnDS,OAmDT,CAnDiB,UAmDjB,CAAA;EACA,8BAAA,CAAA,EAAA,MAAA;EACA,gBAAA,CAAA,EAAA,MAAA;EACA;;;;EAIA,MAAA,CAAA,EAAA,MAAA;EACC;;;;eA9CY;;;;;;;;;;;;KAmBH,UAAA,GAAa,UAAU;6BACN,MAAA,CAAO,OAAO,YAAY;8BAGhD,MAAA,CAAO,OAAO,iBAAiB,MAAM;;;;;;;;iBAS5B,UAAA;;;;;;;;;;;;;;;;GAcb,oBAAoB"}

package/dist/index.d.ts

@@ -1,2 +1,85 @@
-export * from "./azure-store";
+import { UploadistaError } from "@uploadista/core/errors";
+import { Effect } from "effect";
+import { TokenCredential } from "@azure/core-auth";
+import { DataStore, KvStore, UploadFile } from "@uploadista/core/types";
+
+//#region src/azure-store.d.ts
+type ChunkInfo = {
+  blockNumber: number;
+  data: Uint8Array;
+  size: number;
+  isFinalPart?: boolean;
+};
+type AzureStoreOptions = {
+  deliveryUrl: string;
+  /**
+   * The preferred block size for blocks sent to Azure. Can not be lower than 1 byte or more than 4000MiB.
+   * The server calculates the optimal block size, which takes this size into account,
+   * but may increase it to not exceed the Azure 50K blocks limit.
+   */
+  blockSize?: number;
+  /**
+   * The minimal block size for blocks.
+   * Can be used to ensure that all non-trailing blocks are exactly the same size.
+   * Can not be lower than 1 byte or more than 4000MiB.
+   */
+  minBlockSize?: number;
+  /**
+   * The maximum number of blocks allowed in a block blob upload. Defaults to 50,000.
+   */
+  maxBlocks?: number;
+  maxConcurrentBlockUploads?: number;
+  kvStore: KvStore<UploadFile>;
+  expirationPeriodInMilliseconds?: number;
+  connectionString?: string;
+  /**
+   * SAS URL for the storage account (works in all environments including browsers)
+   * Format: https://<account>.blob.core.windows.net?<sas-token>
+   */
+  sasUrl?: string;
+  /**
+   * TokenCredential for OAuth authentication (e.g., DefaultAzureCredential)
+   * Works in all environments and is the recommended approach for production
+   */
+  credential?: TokenCredential;
+  /**
+   * Account name and key for shared key authentication (Node.js only)
+   * @deprecated Use sasUrl or credential instead for cross-platform compatibility
+   */
+  accountName?: string;
+  /**
+   * @deprecated Use sasUrl or credential instead for cross-platform compatibility
+   */
+  accountKey?: string;
+  containerName: string;
+};
+type AzureStore = DataStore<UploadFile> & {
+  getUpload: (id: string) => Effect.Effect<UploadFile, UploadistaError>;
+  readStream: (id: string) => Effect.Effect<ReadableStream | Blob, UploadistaError>;
+  getChunkerConstraints: () => {
+    minChunkSize: number;
+    maxChunkSize: number;
+    optimalChunkSize: number;
+    requiresOrderedChunks: boolean;
+  };
+};
+declare function azureStore({
+  deliveryUrl,
+  blockSize,
+  minBlockSize,
+  // 1KB minimum
+  maxBlocks,
+  kvStore,
+  maxConcurrentBlockUploads,
+  expirationPeriodInMilliseconds,
+  // 1 week
+  connectionString,
+  sasUrl,
+  credential,
+  accountName,
+  accountKey,
+  containerName
+}: AzureStoreOptions): AzureStore;
+//#endregion
+export { AzureStore, AzureStoreOptions, ChunkInfo, azureStore };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/azure-store.ts"],"sourcesContent":[],"mappings":";;;;;;KA4CY,SAAA;;EAAA,IAAA,EAEJ,UAFa;EAOT,IAAA,EAAA,MAAA;EAmBO,WAAA,CAAA,EAAA,OAAA;CAAR;AAaI,KAhCH,iBAAA,GAgCG;EAAe,WAAA,EAAA,MAAA;EAmBlB;;;;;EACiB,SAAO,CAAA,EAAA,MAAA;EAGf;;;;;EASL,YAAA,CAAU,EAAA,MAAA;EACxB;;;EAGA,SAAA,CAAA,EAAA,MAAA;EACA,yBAAA,CAAA,EAAA,MAAA;EACA,OAAA,EAnDS,OAmDT,CAnDiB,UAmDjB,CAAA;EACA,8BAAA,CAAA,EAAA,MAAA;EACA,gBAAA,CAAA,EAAA,MAAA;EACA;;;;EAIA,MAAA,CAAA,EAAA,MAAA;EACC;;;;eA9CY;;;;;;;;;;;;KAmBH,UAAA,GAAa,UAAU;6BACN,MAAA,CAAO,OAAO,YAAY;8BAGhD,MAAA,CAAO,OAAO,iBAAiB,MAAM;;;;;;;;iBAS5B,UAAA;;;;;;;;;;;;;;;;GAcb,oBAAoB"}

package/dist/index.js

@@ -1 +1,2 @@
-export * from "./azure-store";
+import{BlobServiceClient as e,StorageSharedKeyCredential as t}from"@azure/storage-blob";import{UploadistaError as n}from"@uploadista/core/errors";import{azureActiveUploadsGauge as r,azureFileSizeHistogram as i,azurePartSizeHistogram as a,azurePartUploadDurationHistogram as o,azureUploadDurationHistogram as s,azureUploadErrorsTotal as c,azureUploadPartsTotal as l,azureUploadRequestsTotal as u,azureUploadSuccessTotal as d,logAzureUploadCompletion as f,trackAzureError as p,withAzureTimingMetrics as m,withAzureUploadMetrics as h}from"@uploadista/observability";import{Effect as g,Ref as _,Stream as v}from"effect";const y=e=>typeof globalThis<`u`&&`Buffer`in globalThis?globalThis.Buffer.from(e):new Uint8Array(Array.from(e,e=>e.charCodeAt(0)));function b(e){return e&&e.length>0?e.reduce((e,t)=>e+(t?.size??0),0):0}function x({deliveryUrl:x,blockSize:S,minBlockSize:C=1024,maxBlocks:w=5e4,kvStore:T,maxConcurrentBlockUploads:E=60,expirationPeriodInMilliseconds:D=1e3*60*60*24*7,connectionString:O,sasUrl:k,credential:A,accountName:j,accountKey:M,containerName:N}){let P=S||8*1024*1024,F;if(O)F=e.fromConnectionString(O);else if(k)F=new e(k);else if(A){let t=j?`https://${j}.blob.core.windows.net`:k?.split(`?`)[0]||``;if(!t)throw Error(`When using credential authentication, either accountName or a valid sasUrl must be provided to determine the account URL`);F=new e(t,A)}else if(j&&M)try{let n=new t(j,M);F=new e(`https://${j}.blob.core.windows.net`,n)}catch(e){throw Error(`StorageSharedKeyCredential is only available in Node.js environments. Use sasUrl or credential options for cross-platform compatibility. Original error: ${e}`)}else throw Error(`Azure authentication required. Provide one of: connectionString, sasUrl, credential, or accountName + accountKey (Node.js only)`);let I=F.getContainerClient(N),L=e=>`${e}.incomplete`,R=(e,t,r)=>m(o,g.gen(function*(){yield*g.logInfo(`Uploading block`).pipe(g.annotateLogs({upload_id:e.id,block_id:r,block_size:t.length})),yield*l(g.succeed(1)),yield*a(g.succeed(t.length));try{let i=I.getBlockBlobClient(e.id);yield*g.tryPromise({try:async()=>{await i.stageBlock(r,t,t.length)},catch:i=>(g.runSync(p(`uploadBlock`,i,{upload_id:e.id,block_id:r,block_size:t.length})),n.fromCode(`FILE_WRITE_ERROR`,{cause:i}))}),yield*g.logInfo(`Finished uploading block`).pipe(g.annotateLogs({upload_id:e.id,block_id:r,block_size:t.length}))}catch(n){throw g.runSync(p(`uploadBlock`,n,{upload_id:e.id,block_id:r,block_size:t.length})),n}})),z=(e,t)=>g.tryPromise({try:async()=>{await I.getBlockBlobClient(L(e)).upload(t,t.length)},catch:e=>n.fromCode(`FILE_WRITE_ERROR`,{cause:e})}).pipe(g.tap(()=>g.logInfo(`Finished uploading incomplete block`).pipe(g.annotateLogs({upload_id:e})))),B=e=>g.tryPromise({try:async()=>{try{return(await I.getBlockBlobClient(L(e)).download()).readableStreamBody}catch(e){if(e&&typeof e==`object`&&`statusCode`in e&&e.statusCode===404)return;throw e}},catch:e=>n.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),V=e=>g.tryPromise({try:async()=>{try{return(await I.getBlockBlobClient(L(e)).getProperties()).contentLength}catch(e){if(e&&typeof e==`object`&&`statusCode`in e&&e.statusCode===404)return;throw e}},catch:e=>n.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),H=e=>g.tryPromise({try:async()=>{await I.getBlockBlobClient(L(e)).deleteIfExists()},catch:e=>n.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),U=e=>g.gen(function*(){let t=yield*B(e);if(!t)return;let n=t.getReader(),r=[],i=0;try{for(;;){let e=yield*g.promise(()=>n.read());if(e.done)break;r.push(e.value),i+=e.value.length}}finally{n.releaseLock()}let a=v.fromIterable(r);return{size:i,stream:a}}),W=e=>{let t=e??5497558138880,n;n=t<=P?t:t<=P*w?P:Math.ceil(t/w);let r=Math.max(n,C);return Math.ceil(r/1024)*1024},G=e=>t=>v.async(n=>{let r=new Uint8Array,i=1,a=0,o=(t,r=!1)=>{g.runSync(g.logInfo(`Creating chunk`).pipe(g.annotateLogs({block_number:i,chunk_size:t.length,expected_size:e,is_final_chunk:r,total_bytes_processed:a+t.length}))),n.single({blockNumber:i++,data:t,size:t.length})},s=t=>{let n=new Uint8Array(r.length+t.length);for(n.set(r),n.set(t,r.length),r=n,a+=t.length;r.length>=e;){let t=r.slice(0,e);r=r.slice(e),o(t,!1)}};g.runFork(t.pipe(v.runForEach(e=>g.sync(()=>s(e))),g.andThen(()=>g.sync(()=>{r.length>0&&o(r,!0),n.end()})),g.catchAll(e=>g.sync(()=>n.fail(e)))))}),K=(e,t=0)=>n=>e?g.gen(function*(){let r=yield*_.make(t);return n.pipe(v.tap(t=>g.gen(function*(){e(yield*_.updateAndGet(r,e=>e+t.length))})))}).pipe(v.unwrap):n,q=(e,t,r,i,o)=>g.gen(function*(){yield*g.logInfo(`Uploading blocks`).pipe(g.annotateLogs({upload_id:e.id,init_offset:i,file_size:e.size}));let s=e.size,c=W(s);yield*g.logInfo(`Block size`).pipe(g.annotateLogs({upload_id:e.id,block_size:c}));let l=t.pipe(K(o,i),G(c)),u=yield*_.make(i),d=yield*_.make(0),f=yield*_.make([]),p=t=>g.gen(function*(){let i=yield*_.updateAndGet(u,e=>e+t.size),o=i>=(e.size||0);yield*g.logDebug(`Processing chunk`).pipe(g.annotateLogs({upload_id:e.id,cumulative_offset:i,file_size:e.size,chunk_size:t.size,is_final_block:o}));let s=r+t.blockNumber-1;if(t.size>c&&(yield*g.fail(n.fromCode(`FILE_WRITE_ERROR`,{cause:Error(`Block size ${t.size} exceeds upload block size ${c}`)}))),t.size>=C||o){yield*g.logDebug(`Uploading multipart chunk`).pipe(g.annotateLogs({upload_id:e.id,block_number:s,chunk_size:t.size,min_block_size:C,is_final_block:o}));let n=y(`block-${s.toString().padStart(6,`0`)}`).toString(`base64`);yield*R(e,t.data,n),yield*_.update(f,e=>[...e,n]),yield*a(g.succeed(t.size))}else yield*z(e.id,t.data);yield*_.update(d,e=>e+t.size)});return yield*l.pipe(v.runForEach(e=>p(e)),g.withConcurrency(E)),{bytesUploaded:yield*_.get(d),blockIds:yield*_.get(f)}}),J=(e,t)=>g.tryPromise({try:async()=>{await I.getBlockBlobClient(e.id).commitBlockList(t,{blobHTTPHeaders:{blobContentType:e.metadata?.contentType?.toString(),blobCacheControl:e.metadata?.cacheControl?.toString()}})},catch:e=>n.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),Y=e=>g.tryPromise({try:async()=>{try{return(await I.getBlockBlobClient(e).getBlockList(`committed`)).committedBlocks?.map(e=>({size:e.size}))??[]}catch(e){if(e&&typeof e==`object`&&`statusCode`in e&&e.statusCode===404)return[];throw e}},catch:e=>n.fromCode(`UPLOAD_ID_NOT_FOUND`,{cause:e})}),X=e=>g.gen(function*(){yield*g.logInfo(`Removing cached data`).pipe(g.annotateLogs({upload_id:e})),yield*T.delete(e)}),ee=e=>g.gen(function*(){return yield*u(g.succeed(1)),yield*r(g.succeed(1)),yield*i(g.succeed(e.size||0)),yield*g.logInfo(`Initializing Azure blob upload`).pipe(g.annotateLogs({upload_id:e.id})),e.creationDate=new Date().toISOString(),e.storage={id:e.storage.id,type:e.storage.type,path:e.id,bucket:N},e.url=`${x}/${e.id}`,yield*T.set(e.id,e),yield*g.logInfo(`Azure blob upload initialized`).pipe(g.annotateLogs({upload_id:e.id})),e}),Z=e=>g.tryPromise({try:async()=>{let t=await I.getBlockBlobClient(e).download();if(t.blobBody)return t.blobBody;if(t.readableStreamBody)return t.readableStreamBody;throw Error(`No blob body or readable stream body`)},catch:e=>n.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),te=e=>g.gen(function*(){let t=yield*Z(e);if(t instanceof Blob){let e=yield*g.promise(()=>t.arrayBuffer());return new Uint8Array(e)}let n=t.getReader(),r=[];try{for(;;){let e=yield*g.promise(()=>n.read());if(e.done)break;r.push(e.value)}}finally{n.releaseLock()}let i=r.reduce((e,t)=>e+t.length,0),a=new Uint8Array(i),o=0;for(let e of r)a.set(e,o),o+=e.length;return a}),ne=(e,t,n)=>g.gen(function*(){let r=yield*T.get(e),i=(yield*Y(e)).length+1,a=yield*U(e);if(a){yield*H(e);let o=t-a.size,s=a.stream.pipe(v.concat(n));return{uploadFile:r,nextBlockNumber:i-1,offset:o,incompleteBlockSize:a.size,data:s}}else return{uploadFile:r,nextBlockNumber:i,offset:t,incompleteBlockSize:0,data:n}}),re=(e,t)=>h(e.file_id,m(s,g.gen(function*(){let n=Date.now(),{stream:i,file_id:a,offset:o}=e,{onProgress:s}=t,{uploadFile:l,nextBlockNumber:u,offset:m,data:h}=yield*ne(a,o,i),{bytesUploaded:_,blockIds:v}=yield*q(l,h,u,m,s),y=m+_;if(l.size===y)try{yield*J(l,v),yield*X(a),yield*f(a,{fileSize:l.size||0,totalDurationMs:Date.now()-n,partsCount:v.length,averagePartSize:l.size,throughputBps:l.size/(Date.now()-n),retryCount:0}),yield*d(g.succeed(1)),yield*r(g.succeed(-1))}catch(e){throw yield*g.logError(`Failed to finish upload`).pipe(g.annotateLogs({upload_id:a,error:JSON.stringify(e)})),yield*c(g.succeed(1)),g.runSync(p(`write`,e,{upload_id:a,operation:`commit`,blocks:v.length})),e}return y}))),ie=e=>g.gen(function*(){let t=yield*T.get(e),n=0;try{n=b(yield*Y(e))}catch(n){if(typeof n==`object`&&n&&`statusCode`in n&&n.statusCode===404)return{...t,offset:t.size,size:t.size,metadata:t.metadata,storage:t.storage};throw yield*g.logError(`Error on get upload`).pipe(g.annotateLogs({upload_id:e,error:JSON.stringify(n)})),n}let r=yield*V(e);return{...t,offset:n+(r??0),size:t.size,storage:t.storage}}),ae=e=>g.gen(function*(){try{let t=I.getBlockBlobClient(e);yield*g.promise(()=>t.deleteIfExists()),yield*H(e)}catch(t){if(typeof t==`object`&&t&&`statusCode`in t&&t.statusCode===404)return yield*g.logError(`No file found`).pipe(g.annotateLogs({upload_id:e})),yield*g.fail(n.fromCode(`FILE_NOT_FOUND`));throw g.runSync(p(`remove`,t,{upload_id:e})),t}yield*X(e),yield*r(g.succeed(-1))}),Q=()=>D,oe=e=>{let t=new Date(e);return new Date(t.getTime()+Q())},se=()=>g.tryPromise({try:async()=>{if(Q()===0)return 0;let e=0,t=I.listBlobsFlat({includeMetadata:!0}),n=[];for await(let e of t)if(e.metadata?.creationDate){let t=new Date(e.metadata.creationDate);Date.now()>oe(t.toISOString()).getTime()&&n.push(e.name)}for(let t of n)await I.deleteBlob(t),e++;return e},catch:e=>n.fromCode(`FILE_WRITE_ERROR`,{cause:e})}),$=()=>({supportsParallelUploads:!0,supportsConcatenation:!1,supportsDeferredLength:!0,supportsResumableUploads:!0,supportsTransactionalUploads:!0,maxConcurrentUploads:E,minChunkSize:C,maxChunkSize:4e3*1024*1024,maxParts:w,optimalChunkSize:P,requiresOrderedChunks:!1,requiresMimeTypeValidation:!0,maxValidationSize:void 0});return{bucket:N,create:ee,remove:ae,write:re,getUpload:ie,read:te,readStream:Z,deleteExpired:se(),getCapabilities:$,getChunkerConstraints:()=>({minChunkSize:C,maxChunkSize:4e3*1024*1024,optimalChunkSize:P,requiresOrderedChunks:!1}),validateUploadStrategy:e=>{let t=$(),n=(()=>{switch(e){case`parallel`:return t.supportsParallelUploads;case`single`:return!0;default:return!1}})();return g.succeed(n)}}}export{x as azureStore};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["blobServiceClient: BlobServiceClient","BlobService","containerClient: ContainerClient","withTimingMetrics","partUploadDurationHistogram","readStream","uploadPartsTotal","partSizeHistogram","chunks: Uint8Array[]","optimalBlockSize: number","uploadRequestsTotal","activeUploadsGauge","fileSizeHistogram","result","withUploadMetrics","uploadDurationHistogram","uploadSuccessTotal","uploadErrorsTotal","expiredBlobs: string[]"],"sources":["../src/azure-store.ts"],"sourcesContent":["import type { TokenCredential } from \"@azure/core-auth\";\nimport {\n  BlobServiceClient as BlobService,\n  type BlobServiceClient,\n  type ContainerClient,\n  StorageSharedKeyCredential,\n} from \"@azure/storage-blob\";\nimport { UploadistaError } from \"@uploadista/core/errors\";\n\nimport type {\n  DataStore,\n  DataStoreCapabilities,\n  DataStoreWriteOptions,\n  KvStore,\n  UploadFile,\n  UploadStrategy,\n} from \"@uploadista/core/types\";\nimport {\n  azureActiveUploadsGauge as activeUploadsGauge,\n  azureFileSizeHistogram as fileSizeHistogram,\n  logAzureUploadCompletion,\n  azurePartSizeHistogram as partSizeHistogram,\n  azurePartUploadDurationHistogram as partUploadDurationHistogram,\n  trackAzureError,\n  azureUploadDurationHistogram as uploadDurationHistogram,\n  azureUploadErrorsTotal as uploadErrorsTotal,\n  azureUploadPartsTotal as uploadPartsTotal,\n  azureUploadRequestsTotal as uploadRequestsTotal,\n  azureUploadSuccessTotal as uploadSuccessTotal,\n  withAzureTimingMetrics as withTimingMetrics,\n  withAzureUploadMetrics as withUploadMetrics,\n} from \"@uploadista/observability\";\nimport { Effect, Ref, Stream } from \"effect\";\n\n// Using base64 encoding that works in both Node.js and browser\nconst bufferFrom = (str: string) => {\n  // Use global Buffer if available, otherwise fallback to btoa\n  if (typeof globalThis !== \"undefined\" && \"Buffer\" in globalThis) {\n    return (globalThis as any).Buffer.from(str);\n  }\n  // Fallback for browser environments\n  return new Uint8Array(Array.from(str, (c) => c.charCodeAt(0)));\n};\n\nexport type ChunkInfo = {\n  blockNumber: number;\n  data: Uint8Array;\n  size: number;\n  isFinalPart?: boolean;\n};\n\nexport type AzureStoreOptions = {\n  deliveryUrl: string;\n  /**\n   * The preferred block size for blocks sent to Azure. Can not be lower than 1 byte or more than 4000MiB.\n   * The server calculates the optimal block size, which takes this size into account,\n   * but may increase it to not exceed the Azure 50K blocks limit.\n   */\n  blockSize?: number;\n  /**\n   * The minimal block size for blocks.\n   * Can be used to ensure that all non-trailing blocks are exactly the same size.\n   * Can not be lower than 1 byte or more than 4000MiB.\n   */\n  minBlockSize?: number;\n  /**\n   * The maximum number of blocks allowed in a block blob upload. Defaults to 50,000.\n   */\n  maxBlocks?: number;\n  maxConcurrentBlockUploads?: number;\n  kvStore: KvStore<UploadFile>;\n  expirationPeriodInMilliseconds?: number;\n  // Azure authentication options (choose one)\n  connectionString?: string;\n  /**\n   * SAS URL for the storage account (works in all environments including browsers)\n   * Format: https://<account>.blob.core.windows.net?<sas-token>\n   */\n  sasUrl?: string;\n  /**\n   * TokenCredential for OAuth authentication (e.g., DefaultAzureCredential)\n   * Works in all environments and is the recommended approach for production\n   */\n  credential?: TokenCredential;\n  /**\n   * Account name and key for shared key authentication (Node.js only)\n   * @deprecated Use sasUrl or credential instead for cross-platform compatibility\n   */\n  accountName?: string;\n  /**\n   * @deprecated Use sasUrl or credential instead for cross-platform compatibility\n   */\n  accountKey?: string;\n  containerName: string;\n};\n\nfunction calcOffsetFromBlocks(blocks?: Array<{ size: number }>) {\n  return blocks && blocks.length > 0\n    ? blocks.reduce((a, b) => a + (b?.size ?? 0), 0)\n    : 0;\n}\n\nexport type AzureStore = DataStore<UploadFile> & {\n  getUpload: (id: string) => Effect.Effect<UploadFile, UploadistaError>;\n  readStream: (\n    id: string,\n  ) => Effect.Effect<ReadableStream | Blob, UploadistaError>;\n  getChunkerConstraints: () => {\n    minChunkSize: number;\n    maxChunkSize: number;\n    optimalChunkSize: number;\n    requiresOrderedChunks: boolean;\n  };\n};\n\nexport function azureStore({\n  deliveryUrl,\n  blockSize,\n  minBlockSize = 1024, // 1KB minimum\n  maxBlocks = 50_000,\n  kvStore,\n  maxConcurrentBlockUploads = 60,\n  expirationPeriodInMilliseconds = 1000 * 60 * 60 * 24 * 7, // 1 week\n  connectionString,\n  sasUrl,\n  credential,\n  accountName,\n  accountKey,\n  containerName,\n}: AzureStoreOptions): AzureStore {\n  const preferredBlockSize = blockSize || 8 * 1024 * 1024; // 8MB default\n  const maxUploadSize = 5_497_558_138_880 as const; // 5TiB (Azure Block Blob limit)\n\n  // Initialize Azure Blob Service Client with cross-platform authentication\n  let blobServiceClient: BlobServiceClient;\n\n  if (connectionString) {\n    // Connection string (works in all environments)\n    blobServiceClient = BlobService.fromConnectionString(connectionString);\n  } else if (sasUrl) {\n    // SAS URL (works in all environments including browsers)\n    blobServiceClient = new BlobService(sasUrl);\n  } else if (credential) {\n    // OAuth token credential (works in all environments, recommended for production)\n    const accountUrl = accountName\n      ? `https://${accountName}.blob.core.windows.net`\n      : sasUrl?.split(\"?\")[0] || \"\";\n    if (!accountUrl) {\n      throw new Error(\n        \"When using credential authentication, either accountName or a valid sasUrl must be provided to determine the account URL\",\n      );\n    }\n    blobServiceClient = new BlobService(accountUrl, credential);\n  } else if (accountName && accountKey) {\n    // Legacy shared key authentication (Node.js only)\n    // This will fail in browser/edge environments\n    try {\n      const sharedKeyCredential = new StorageSharedKeyCredential(\n        accountName,\n        accountKey,\n      );\n      blobServiceClient = new BlobService(\n        `https://${accountName}.blob.core.windows.net`,\n        sharedKeyCredential,\n      );\n    } catch (error) {\n      throw new Error(\n        \"StorageSharedKeyCredential is only available in Node.js environments. \" +\n          \"Use sasUrl or credential options for cross-platform compatibility. \" +\n          `Original error: ${error}`,\n      );\n    }\n  } else {\n    throw new Error(\n      \"Azure authentication required. Provide one of: \" +\n        \"connectionString, sasUrl, credential, or accountName + accountKey (Node.js only)\",\n    );\n  }\n\n  const containerClient: ContainerClient =\n    blobServiceClient.getContainerClient(containerName);\n\n  const incompletePartKey = (id: string) => {\n    return `${id}.incomplete`;\n  };\n\n  const uploadBlock = (\n    uploadFile: UploadFile,\n    readStream: Uint8Array,\n    blockId: string,\n  ) => {\n    return withTimingMetrics(\n      partUploadDurationHistogram,\n      Effect.gen(function* () {\n        yield* Effect.logInfo(\"Uploading block\").pipe(\n          Effect.annotateLogs({\n            upload_id: uploadFile.id,\n            block_id: blockId,\n            block_size: readStream.length,\n          }),\n        );\n\n        yield* uploadPartsTotal(Effect.succeed(1));\n        yield* partSizeHistogram(Effect.succeed(readStream.length));\n\n        try {\n          const blobClient = containerClient.getBlockBlobClient(uploadFile.id);\n          yield* Effect.tryPromise({\n            try: async () => {\n              await blobClient.stageBlock(\n                blockId,\n                readStream,\n                readStream.length,\n              );\n            },\n            catch: (error) => {\n              Effect.runSync(\n                trackAzureError(\"uploadBlock\", error, {\n                  upload_id: uploadFile.id,\n                  block_id: blockId,\n                  block_size: readStream.length,\n                }),\n              );\n              return UploadistaError.fromCode(\"FILE_WRITE_ERROR\", {\n                cause: error as Error,\n              });\n            },\n          });\n\n          yield* Effect.logInfo(\"Finished uploading block\").pipe(\n            Effect.annotateLogs({\n              upload_id: uploadFile.id,\n              block_id: blockId,\n              block_size: readStream.length,\n            }),\n          );\n        } catch (error) {\n          Effect.runSync(\n            trackAzureError(\"uploadBlock\", error, {\n              upload_id: uploadFile.id,\n              block_id: blockId,\n              block_size: readStream.length,\n            }),\n          );\n          throw error;\n        }\n      }),\n    );\n  };\n\n  const uploadIncompleteBlock = (id: string, readStream: Uint8Array) => {\n    return Effect.tryPromise({\n      try: async () => {\n        const blobClient = containerClient.getBlockBlobClient(\n          incompletePartKey(id),\n        );\n        await blobClient.upload(readStream, readStream.length);\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"FILE_WRITE_ERROR\", { cause: error as Error }),\n    }).pipe(\n      Effect.tap(() =>\n        Effect.logInfo(\"Finished uploading incomplete block\").pipe(\n          Effect.annotateLogs({\n            upload_id: id,\n          }),\n        ),\n      ),\n    );\n  };\n\n  const getIncompleteBlock = (id: string) => {\n    return Effect.tryPromise({\n      try: async () => {\n        try {\n          const blobClient = containerClient.getBlockBlobClient(\n            incompletePartKey(id),\n          );\n          const response = await blobClient.download();\n          return response.readableStreamBody as unknown as ReadableStream;\n        } catch (error) {\n          if (\n            error &&\n            typeof error === \"object\" &&\n            \"statusCode\" in error &&\n            error.statusCode === 404\n          ) {\n            return undefined;\n          }\n          throw error;\n        }\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"FILE_WRITE_ERROR\", { cause: error as Error }),\n    });\n  };\n\n  const getIncompleteBlockSize = (id: string) => {\n    return Effect.tryPromise({\n      try: async () => {\n        try {\n          const blobClient = containerClient.getBlockBlobClient(\n            incompletePartKey(id),\n          );\n          const properties = await blobClient.getProperties();\n          return properties.contentLength;\n        } catch (error) {\n          if (\n            error &&\n            typeof error === \"object\" &&\n            \"statusCode\" in error &&\n            error.statusCode === 404\n          ) {\n            return undefined;\n          }\n          throw error;\n        }\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"FILE_WRITE_ERROR\", { cause: error as Error }),\n    });\n  };\n\n  const deleteIncompleteBlock = (id: string) => {\n    return Effect.tryPromise({\n      try: async () => {\n        const blobClient = containerClient.getBlockBlobClient(\n          incompletePartKey(id),\n        );\n        await blobClient.deleteIfExists();\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"FILE_WRITE_ERROR\", { cause: error as Error }),\n    });\n  };\n\n  const downloadIncompleteBlock = (id: string) => {\n    return Effect.gen(function* () {\n      const incompleteBlock = yield* getIncompleteBlock(id);\n\n      if (!incompleteBlock) {\n        return;\n      }\n\n      // Read the stream and collect all chunks to calculate size\n      const reader = incompleteBlock.getReader();\n      const chunks: Uint8Array[] = [];\n      let incompleteBlockSize = 0;\n\n      try {\n        while (true) {\n          const result = yield* Effect.promise(() => reader.read());\n          if (result.done) break;\n          chunks.push(result.value);\n          incompleteBlockSize += result.value.length;\n        }\n      } finally {\n        reader.releaseLock();\n      }\n\n      // Create a new readable stream from the chunks\n      const stream = Stream.fromIterable(chunks);\n\n      return {\n        size: incompleteBlockSize,\n        stream,\n      };\n    });\n  };\n\n  const calcOptimalBlockSize = (initSize?: number): number => {\n    const size = initSize ?? maxUploadSize;\n    let optimalBlockSize: number;\n\n    if (size <= preferredBlockSize) {\n      optimalBlockSize = size;\n    } else if (size <= preferredBlockSize * maxBlocks) {\n      optimalBlockSize = preferredBlockSize;\n    } else {\n      // Calculate the minimum block size needed to fit within the max blocks limit\n      optimalBlockSize = Math.ceil(size / maxBlocks);\n    }\n\n    // Ensure the block size respects the minimum and is aligned properly\n    const finalBlockSize = Math.max(optimalBlockSize, minBlockSize);\n\n    // Round up to ensure consistent block sizes\n    return Math.ceil(finalBlockSize / 1024) * 1024; // Align to 1KB boundaries\n  };\n\n  // Proper single-pass chunking using Effect's async stream constructor\n  // Ensures all parts except the final part are exactly the same size (S3 requirement)\n  const createChunkedStream =\n    (chunkSize: number) =>\n    <E>(stream: Stream.Stream<Uint8Array, E>): Stream.Stream<ChunkInfo, E> => {\n      return Stream.async<ChunkInfo, E>((emit) => {\n        let buffer = new Uint8Array(0);\n        let blockNumber = 1;\n        let totalBytesProcessed = 0;\n\n        const emitChunk = (data: Uint8Array, isFinalChunk = false) => {\n          // Log chunk information for debugging - use INFO level to see in logs\n          Effect.runSync(\n            Effect.logInfo(\"Creating chunk\").pipe(\n              Effect.annotateLogs({\n                block_number: blockNumber,\n                chunk_size: data.length,\n                expected_size: chunkSize,\n                is_final_chunk: isFinalChunk,\n                total_bytes_processed: totalBytesProcessed + data.length,\n              }),\n            ),\n          );\n          emit.single({\n            blockNumber: blockNumber++,\n            data,\n            size: data.length,\n          });\n        };\n\n        const processChunk = (newData: Uint8Array) => {\n          // Combine buffer with new data\n          const combined = new Uint8Array(buffer.length + newData.length);\n          combined.set(buffer);\n          combined.set(newData, buffer.length);\n          buffer = combined;\n          totalBytesProcessed += newData.length;\n\n          // Emit full chunks of exactly chunkSize bytes\n          // This ensures S3 multipart upload rule: all parts except last must be same size\n          while (buffer.length >= chunkSize) {\n            const chunk = buffer.slice(0, chunkSize);\n            buffer = buffer.slice(chunkSize);\n            emitChunk(chunk, false);\n          }\n        };\n\n        // Process the stream\n        Effect.runFork(\n          stream.pipe(\n            Stream.runForEach((chunk) =>\n              Effect.sync(() => processChunk(chunk)),\n            ),\n            Effect.andThen(() =>\n              Effect.sync(() => {\n                // Emit final chunk if there's remaining data\n                // The final chunk can be any size < chunkSize (S3 allows this)\n                if (buffer.length > 0) {\n                  emitChunk(buffer, true);\n                }\n                emit.end();\n              }),\n            ),\n            Effect.catchAll((error) => Effect.sync(() => emit.fail(error))),\n          ),\n        );\n      });\n    };\n\n  // Byte-level progress tracking during streaming\n  // This provides smooth, immediate progress feedback by tracking bytes as they\n  // flow through the stream, before they reach S3. This solves the issue where\n  // small files (< 5MB) would jump from 0% to 100% instantly.\n  const withByteProgressTracking =\n    (onProgress?: (totalBytes: number) => void, initialOffset = 0) =>\n    <E, R>(stream: Stream.Stream<Uint8Array, E, R>) => {\n      if (!onProgress) return stream;\n\n      return Effect.gen(function* () {\n        const totalBytesProcessedRef = yield* Ref.make(initialOffset);\n\n        return stream.pipe(\n          Stream.tap((chunk) =>\n            Effect.gen(function* () {\n              const newTotal = yield* Ref.updateAndGet(\n                totalBytesProcessedRef,\n                (total) => total + chunk.length,\n              );\n              onProgress(newTotal);\n            }),\n          ),\n        );\n      }).pipe(Stream.unwrap);\n    };\n\n  /**\n   * Uploads a stream to Azure using multiple blocks\n   */\n  const uploadBlocks = (\n    uploadFile: UploadFile,\n    readStream: Stream.Stream<Uint8Array, UploadistaError>,\n    initCurrentBlockNumber: number,\n    initOffset: number,\n    onProgress?: (newOffset: number) => void,\n  ) => {\n    return Effect.gen(function* () {\n      yield* Effect.logInfo(\"Uploading blocks\").pipe(\n        Effect.annotateLogs({\n          upload_id: uploadFile.id,\n          init_offset: initOffset,\n          file_size: uploadFile.size,\n        }),\n      );\n\n      const size = uploadFile.size;\n\n      const uploadBlockSize = calcOptimalBlockSize(size);\n      yield* Effect.logInfo(\"Block size\").pipe(\n        Effect.annotateLogs({\n          upload_id: uploadFile.id,\n          block_size: uploadBlockSize,\n        }),\n      );\n      // Enhanced Progress Tracking Strategy:\n      // 1. Byte-level progress during streaming - provides immediate, smooth feedback\n      //    as data flows through the pipeline (even for small files)\n      // 2. This tracks progress BEFORE S3 upload, giving users immediate feedback\n      // 3. For large files with multiple parts, this provides granular updates\n      // 4. For small files (single part), this prevents 0%->100% jumps\n      const chunkStream = readStream.pipe(\n        // Add byte-level progress tracking during streaming (immediate feedback)\n        withByteProgressTracking(onProgress, initOffset),\n        // Create chunks for S3 multipart upload with uniform part sizes\n        createChunkedStream(uploadBlockSize),\n      );\n\n      // Track cumulative offset and total bytes with Effect Refs\n      const cumulativeOffsetRef = yield* Ref.make(initOffset);\n      const totalBytesUploadedRef = yield* Ref.make(0);\n      const blockIdsRef = yield* Ref.make<string[]>([]);\n      // Create a chunk upload function for the sink\n      const uploadChunk = (chunkInfo: ChunkInfo) =>\n        Effect.gen(function* () {\n          // Calculate cumulative bytes to determine if this is the final block\n          const cumulativeOffset = yield* Ref.updateAndGet(\n            cumulativeOffsetRef,\n            (offset) => offset + chunkInfo.size,\n          );\n          const isFinalBlock = cumulativeOffset >= (uploadFile.size || 0);\n\n          yield* Effect.logDebug(\"Processing chunk\").pipe(\n            Effect.annotateLogs({\n              upload_id: uploadFile.id,\n              cumulative_offset: cumulativeOffset,\n              file_size: uploadFile.size,\n              chunk_size: chunkInfo.size,\n              is_final_block: isFinalBlock,\n            }),\n          );\n\n          const actualBlockNumber =\n            initCurrentBlockNumber + chunkInfo.blockNumber - 1;\n\n          if (chunkInfo.size > uploadBlockSize) {\n            yield* Effect.fail(\n              UploadistaError.fromCode(\"FILE_WRITE_ERROR\", {\n                cause: new Error(\n                  `Block size ${chunkInfo.size} exceeds upload block size ${uploadBlockSize}`,\n                ),\n              }),\n            );\n          }\n\n          // For parts that meet the minimum part size (5MB) or are the final part,\n          // upload them as regular multipart parts\n          if (chunkInfo.size >= minBlockSize || isFinalBlock) {\n            yield* Effect.logDebug(\"Uploading multipart chunk\").pipe(\n              Effect.annotateLogs({\n                upload_id: uploadFile.id,\n                block_number: actualBlockNumber,\n                chunk_size: chunkInfo.size,\n                min_block_size: minBlockSize,\n                is_final_block: isFinalBlock,\n              }),\n            );\n            // Generate block ID (base64 encoded, must be consistent)\n            const blockId = bufferFrom(\n              `block-${actualBlockNumber.toString().padStart(6, \"0\")}`,\n            ).toString(\"base64\");\n            yield* uploadBlock(uploadFile, chunkInfo.data, blockId);\n            yield* Ref.update(blockIdsRef, (ids) => [...ids, blockId]);\n            yield* partSizeHistogram(Effect.succeed(chunkInfo.size));\n          } else {\n            // Only upload as incomplete part if it's smaller than minimum and not final\n            yield* uploadIncompleteBlock(uploadFile.id, chunkInfo.data);\n          }\n\n          yield* Ref.update(\n            totalBytesUploadedRef,\n            (total) => total + chunkInfo.size,\n          );\n\n          // Note: Byte-level progress is now tracked during streaming phase\n          // This ensures smooth progress updates regardless of part size\n          // Azure upload completion is tracked via totalBytesUploadedRef for accuracy\n        });\n\n      // Process chunks concurrently with controlled concurrency\n      yield* chunkStream.pipe(\n        Stream.runForEach((chunkInfo) => uploadChunk(chunkInfo)),\n        Effect.withConcurrency(maxConcurrentBlockUploads),\n      );\n\n      return {\n        bytesUploaded: yield* Ref.get(totalBytesUploadedRef),\n        blockIds: yield* Ref.get(blockIdsRef),\n      };\n    });\n  };\n\n  /**\n   * Commits all staged blocks to create the final blob\n   */\n  const commitBlocks = (uploadFile: UploadFile, blockIds: string[]) => {\n    return Effect.tryPromise({\n      try: async () => {\n        const blobClient = containerClient.getBlockBlobClient(uploadFile.id);\n        await blobClient.commitBlockList(blockIds, {\n          blobHTTPHeaders: {\n            blobContentType: uploadFile.metadata?.contentType?.toString(),\n            blobCacheControl: uploadFile.metadata?.cacheControl?.toString(),\n          },\n        });\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"FILE_WRITE_ERROR\", { cause: error as Error }),\n    });\n  };\n\n  /**\n   * Gets the committed blocks for a blob\n   */\n  const retrieveBlocks = (id: string) => {\n    return Effect.tryPromise({\n      try: async () => {\n        try {\n          const blobClient = containerClient.getBlockBlobClient(id);\n          const blockList = await blobClient.getBlockList(\"committed\");\n\n          const blocks =\n            blockList.committedBlocks?.map((block) => ({\n              size: block.size,\n            })) ?? [];\n\n          return blocks;\n        } catch (error) {\n          if (\n            error &&\n            typeof error === \"object\" &&\n            \"statusCode\" in error &&\n            error.statusCode === 404\n          ) {\n            return [];\n          }\n          throw error;\n        }\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"UPLOAD_ID_NOT_FOUND\", {\n          cause: error as Error,\n        }),\n    });\n  };\n\n  /**\n   * Removes cached data for a given file\n   */\n  const clearCache = (id: string) => {\n    return Effect.gen(function* () {\n      yield* Effect.logInfo(\"Removing cached data\").pipe(\n        Effect.annotateLogs({\n          upload_id: id,\n        }),\n      );\n      yield* kvStore.delete(id);\n    });\n  };\n\n  /**\n   * Creates a blob placeholder in Azure and stores metadata\n   */\n  const create = (upload: UploadFile) => {\n    return Effect.gen(function* () {\n      yield* uploadRequestsTotal(Effect.succeed(1));\n      yield* activeUploadsGauge(Effect.succeed(1));\n      yield* fileSizeHistogram(Effect.succeed(upload.size || 0));\n\n      yield* Effect.logInfo(\"Initializing Azure blob upload\").pipe(\n        Effect.annotateLogs({\n          upload_id: upload.id,\n        }),\n      );\n\n      upload.creationDate = new Date().toISOString();\n      upload.storage = {\n        id: upload.storage.id,\n        type: upload.storage.type,\n        path: upload.id,\n        bucket: containerName,\n      };\n      upload.url = `${deliveryUrl}/${upload.id}`;\n\n      yield* kvStore.set(upload.id, upload);\n      yield* Effect.logInfo(\"Azure blob upload initialized\").pipe(\n        Effect.annotateLogs({\n          upload_id: upload.id,\n        }),\n      );\n\n      return upload;\n    });\n  };\n\n  const readStream = (\n    id: string,\n  ): Effect.Effect<ReadableStream | Blob, UploadistaError> => {\n    return Effect.tryPromise({\n      try: async () => {\n        const blobClient = containerClient.getBlockBlobClient(id);\n        const response = await blobClient.download();\n        if (response.blobBody) {\n          return response.blobBody;\n        }\n        if (response.readableStreamBody) {\n          return response.readableStreamBody as unknown as ReadableStream;\n        }\n        throw new Error(\"No blob body or readable stream body\");\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"FILE_WRITE_ERROR\", {\n          cause: error as Error,\n        }),\n    });\n  };\n\n  const read = (id: string): Effect.Effect<Uint8Array, UploadistaError> => {\n    return Effect.gen(function* () {\n      const stream = yield* readStream(id);\n\n      // Convert stream/blob to Uint8Array\n      if (stream instanceof Blob) {\n        const arrayBuffer = yield* Effect.promise(() => stream.arrayBuffer());\n        return new Uint8Array(arrayBuffer as ArrayBuffer);\n      }\n\n      // Read from ReadableStream\n      const reader = stream.getReader();\n      const chunks: Uint8Array[] = [];\n\n      try {\n        while (true) {\n          const result = yield* Effect.promise(() => reader.read());\n          if (result.done) break;\n          chunks.push(result.value);\n        }\n      } finally {\n        reader.releaseLock();\n      }\n\n      // Concatenate all chunks\n      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);\n      const result = new Uint8Array(totalLength);\n      let offset = 0;\n      for (const chunk of chunks) {\n        result.set(chunk, offset);\n        offset += chunk.length;\n      }\n\n      return result;\n    });\n  };\n\n  const prepareUpload = (\n    file_id: string,\n    initialOffset: number,\n    initialData: Stream.Stream<Uint8Array, UploadistaError>,\n  ) => {\n    return Effect.gen(function* () {\n      const uploadFile = yield* kvStore.get(file_id);\n\n      const blocks = yield* retrieveBlocks(file_id);\n\n      const blockNumber = blocks.length;\n      const nextBlockNumber = blockNumber + 1;\n\n      const incompleteBlock = yield* downloadIncompleteBlock(file_id);\n\n      if (incompleteBlock) {\n        yield* deleteIncompleteBlock(file_id);\n        const offset = initialOffset - incompleteBlock.size;\n        const data = incompleteBlock.stream.pipe(Stream.concat(initialData));\n        return {\n          uploadFile,\n          nextBlockNumber: nextBlockNumber - 1,\n          offset,\n          incompleteBlockSize: incompleteBlock.size,\n          data,\n        };\n      } else {\n        return {\n          uploadFile,\n          nextBlockNumber,\n          offset: initialOffset,\n          incompleteBlockSize: 0,\n          data: initialData,\n        };\n      }\n    });\n  };\n\n  /**\n   * Write to the file, starting at the provided offset\n   */\n  const write = (\n    options: DataStoreWriteOptions,\n    dependencies: {\n      onProgress?: (chunkSize: number) => void;\n    },\n  ) => {\n    return withUploadMetrics(\n      options.file_id,\n      withTimingMetrics(\n        uploadDurationHistogram,\n        Effect.gen(function* () {\n          const startTime = Date.now();\n          const {\n            stream: initialData,\n            file_id,\n            offset: initialOffset,\n          } = options;\n          const { onProgress } = dependencies;\n\n          const prepareResult = yield* prepareUpload(\n            file_id,\n            initialOffset,\n            initialData,\n          );\n\n          const { uploadFile, nextBlockNumber, offset, data } = prepareResult;\n\n          const { bytesUploaded, blockIds } = yield* uploadBlocks(\n            uploadFile,\n            data,\n            nextBlockNumber,\n            offset,\n            onProgress,\n          );\n\n          const newOffset = offset + bytesUploaded;\n\n          if (uploadFile.size === newOffset) {\n            try {\n              // Commit all blocks to finalize the blob\n              yield* commitBlocks(uploadFile, blockIds);\n              yield* clearCache(file_id);\n\n              // Log completion with observability\n              yield* logAzureUploadCompletion(file_id, {\n                fileSize: uploadFile.size || 0,\n                totalDurationMs: Date.now() - startTime,\n                partsCount: blockIds.length,\n                averagePartSize: uploadFile.size,\n                throughputBps: uploadFile.size / (Date.now() - startTime),\n                retryCount: 0,\n              });\n\n              yield* uploadSuccessTotal(Effect.succeed(1));\n              yield* activeUploadsGauge(Effect.succeed(-1));\n            } catch (error) {\n              yield* Effect.logError(\"Failed to finish upload\").pipe(\n                Effect.annotateLogs({\n                  upload_id: file_id,\n                  error: JSON.stringify(error),\n                }),\n              );\n              yield* uploadErrorsTotal(Effect.succeed(1));\n              Effect.runSync(\n                trackAzureError(\"write\", error, {\n                  upload_id: file_id,\n                  operation: \"commit\",\n                  blocks: blockIds.length,\n                }),\n              );\n              throw error;\n            }\n          }\n\n          return newOffset;\n        }),\n      ),\n    );\n  };\n\n  const getUpload = (id: string) => {\n    return Effect.gen(function* () {\n      const uploadFile = yield* kvStore.get(id);\n\n      let offset = 0;\n\n      try {\n        const blocks = yield* retrieveBlocks(id);\n        offset = calcOffsetFromBlocks(blocks);\n      } catch (error) {\n        // Check if the error is caused by the blob not being found\n        if (\n          typeof error === \"object\" &&\n          error !== null &&\n          \"statusCode\" in error &&\n          error.statusCode === 404\n        ) {\n          return {\n            ...uploadFile,\n            offset: uploadFile.size as number,\n            size: uploadFile.size,\n            metadata: uploadFile.metadata,\n            storage: uploadFile.storage,\n          };\n        }\n\n        yield* Effect.logError(\"Error on get upload\").pipe(\n          Effect.annotateLogs({\n            upload_id: id,\n            error: JSON.stringify(error),\n          }),\n        );\n        throw error;\n      }\n\n      const incompleteBlockSize = yield* getIncompleteBlockSize(id);\n\n      return {\n        ...uploadFile,\n        offset: offset + (incompleteBlockSize ?? 0),\n        size: uploadFile.size,\n        storage: uploadFile.storage,\n      };\n    });\n  };\n\n  const remove = (id: string) => {\n    return Effect.gen(function* () {\n      try {\n        const blobClient = containerClient.getBlockBlobClient(id);\n        yield* Effect.promise(() => blobClient.deleteIfExists());\n\n        // Also delete incomplete block if it exists\n        yield* deleteIncompleteBlock(id);\n      } catch (error) {\n        if (\n          typeof error === \"object\" &&\n          error !== null &&\n          \"statusCode\" in error &&\n          error.statusCode === 404\n        ) {\n          yield* Effect.logError(\"No file found\").pipe(\n            Effect.annotateLogs({\n              upload_id: id,\n            }),\n          );\n          return yield* Effect.fail(UploadistaError.fromCode(\"FILE_NOT_FOUND\"));\n        }\n        Effect.runSync(\n          trackAzureError(\"remove\", error, {\n            upload_id: id,\n          }),\n        );\n        throw error;\n      }\n\n      yield* clearCache(id);\n      yield* activeUploadsGauge(Effect.succeed(-1));\n    });\n  };\n\n  const getExpiration = () => {\n    return expirationPeriodInMilliseconds;\n  };\n\n  const getExpirationDate = (created_at: string) => {\n    const date = new Date(created_at);\n    return new Date(date.getTime() + getExpiration());\n  };\n\n  const deleteExpired = (): Effect.Effect<number, UploadistaError> => {\n    return Effect.tryPromise({\n      try: async (): Promise<number> => {\n        if (getExpiration() === 0) {\n          return 0;\n        }\n\n        let deleted = 0;\n\n        const response = containerClient.listBlobsFlat({\n          includeMetadata: true,\n        });\n\n        const expiredBlobs: string[] = [];\n\n        for await (const blob of response) {\n          if (blob.metadata?.creationDate) {\n            const creationDate = new Date(blob.metadata.creationDate);\n            if (\n              Date.now() >\n              getExpirationDate(creationDate.toISOString()).getTime()\n            ) {\n              expiredBlobs.push(blob.name);\n            }\n          }\n        }\n\n        // Delete expired blobs\n        for (const blobName of expiredBlobs) {\n          await containerClient.deleteBlob(blobName);\n          deleted++;\n        }\n\n        return deleted;\n      },\n      catch: (error) =>\n        UploadistaError.fromCode(\"FILE_WRITE_ERROR\", { cause: error as Error }),\n    });\n  };\n\n  const getCapabilities = (): DataStoreCapabilities => {\n    return {\n      supportsParallelUploads: true,\n      supportsConcatenation: false, // Azure doesn't have native concatenation like GCS\n      supportsDeferredLength: true,\n      supportsResumableUploads: true,\n      supportsTransactionalUploads: true,\n      maxConcurrentUploads: maxConcurrentBlockUploads,\n      minChunkSize: minBlockSize,\n      maxChunkSize: 4000 * 1024 * 1024, // 4000MB Azure limit\n      maxParts: maxBlocks,\n      optimalChunkSize: preferredBlockSize,\n      requiresOrderedChunks: false,\n      requiresMimeTypeValidation: true,\n      maxValidationSize: undefined, // no size limit\n    };\n  };\n\n  const getChunkerConstraints = () => {\n    return {\n      minChunkSize: minBlockSize,\n      maxChunkSize: 4000 * 1024 * 1024, // 4000MB Azure limit\n      optimalChunkSize: preferredBlockSize,\n      requiresOrderedChunks: false,\n    };\n  };\n\n  const validateUploadStrategy = (\n    strategy: UploadStrategy,\n  ): Effect.Effect<boolean, never> => {\n    const capabilities = getCapabilities();\n\n    const result = (() => {\n      switch (strategy) {\n        case \"parallel\":\n          return capabilities.supportsParallelUploads;\n        case \"single\":\n          return true;\n        default:\n          return false;\n      }\n    })();\n\n    return Effect.succeed(result);\n  };\n\n  return {\n    bucket: containerName,\n    create,\n    remove,\n    write,\n    getUpload,\n    read,\n    readStream,\n    deleteExpired: deleteExpired(),\n    getCapabilities,\n    getChunkerConstraints,\n    validateUploadStrategy,\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/data-store-azure",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Azure Blob Storage data store for Uploadista",
   "license": "MIT",
   "author": "Uploadista",
@@ -16,15 +16,16 @@
     "@azure/core-auth": "^1.8.0",
     "@azure/storage-blob": "12.29.1",
     "effect": "3.18.4",
-    "@uploadista/core": "0.0.3",
-    "@uploadista/kv-store-memory": "0.0.3",
-    "@uploadista/observability": "0.0.3"
+    "@uploadista/core": "0.0.4",
+    "@uploadista/kv-store-memory": "0.0.4",
+    "@uploadista/observability": "0.0.4"
   },
   "devDependencies": {
-    "@uploadista/typescript-config": "0.0.3"
+    "tsdown": "0.15.9",
+    "@uploadista/typescript-config": "0.0.4"
   },
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsdown",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
     "check": "biome check --write ./src",

package/tsdown.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+  },
+  minify: true,
+  format: ["esm", "cjs"],
+  dts: true,
+  outDir: "dist",
+});

package/dist/azure-store.d.ts

@@ -1,67 +0,0 @@
-import type { TokenCredential } from "@azure/core-auth";
-import { UploadistaError } from "@uploadista/core/errors";
-import type { DataStore, KvStore, UploadFile } from "@uploadista/core/types";
-import { Effect } from "effect";
-export type ChunkInfo = {
-    blockNumber: number;
-    data: Uint8Array;
-    size: number;
-    isFinalPart?: boolean;
-};
-export type AzureStoreOptions = {
-    deliveryUrl: string;
-    /**
-     * The preferred block size for blocks sent to Azure. Can not be lower than 1 byte or more than 4000MiB.
-     * The server calculates the optimal block size, which takes this size into account,
-     * but may increase it to not exceed the Azure 50K blocks limit.
-     */
-    blockSize?: number;
-    /**
-     * The minimal block size for blocks.
-     * Can be used to ensure that all non-trailing blocks are exactly the same size.
-     * Can not be lower than 1 byte or more than 4000MiB.
-     */
-    minBlockSize?: number;
-    /**
-     * The maximum number of blocks allowed in a block blob upload. Defaults to 50,000.
-     */
-    maxBlocks?: number;
-    maxConcurrentBlockUploads?: number;
-    kvStore: KvStore<UploadFile>;
-    expirationPeriodInMilliseconds?: number;
-    connectionString?: string;
-    /**
-     * SAS URL for the storage account (works in all environments including browsers)
-     * Format: https://<account>.blob.core.windows.net?<sas-token>
-     */
-    sasUrl?: string;
-    /**
-     * TokenCredential for OAuth authentication (e.g., DefaultAzureCredential)
-     * Works in all environments and is the recommended approach for production
-     */
-    credential?: TokenCredential;
-    /**
-     * Account name and key for shared key authentication (Node.js only)
-     * @deprecated Use sasUrl or credential instead for cross-platform compatibility
-     */
-    accountName?: string;
-    /**
-     * @deprecated Use sasUrl or credential instead for cross-platform compatibility
-     */
-    accountKey?: string;
-    containerName: string;
-};
-export type AzureStore = DataStore<UploadFile> & {
-    getUpload: (id: string) => Effect.Effect<UploadFile, UploadistaError>;
-    readStream: (id: string) => Effect.Effect<ReadableStream | Blob, UploadistaError>;
-    getChunkerConstraints: () => {
-        minChunkSize: number;
-        maxChunkSize: number;
-        optimalChunkSize: number;
-        requiresOrderedChunks: boolean;
-    };
-};
-export declare function azureStore({ deliveryUrl, blockSize, minBlockSize, // 1KB minimum
-maxBlocks, kvStore, maxConcurrentBlockUploads, expirationPeriodInMilliseconds, // 1 week
-connectionString, sasUrl, credential, accountName, accountKey, containerName, }: AzureStoreOptions): AzureStore;
-//# sourceMappingURL=azure-store.d.ts.map

package/dist/azure-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"azure-store.d.ts","sourceRoot":"","sources":["../src/azure-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOxD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,KAAK,EACV,SAAS,EAGT,OAAO,EACP,UAAU,EAEX,MAAM,wBAAwB,CAAC;AAgBhC,OAAO,EAAE,MAAM,EAAe,MAAM,QAAQ,CAAC;AAY7C,MAAM,MAAM,SAAS,GAAG;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7B,8BAA8B,CAAC,EAAE,MAAM,CAAC;IAExC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAQF,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,GAAG;IAC/C,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;IACtE,UAAU,EAAE,CACV,EAAE,EAAE,MAAM,KACP,MAAM,CAAC,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,eAAe,CAAC,CAAC;IAC3D,qBAAqB,EAAE,MAAM;QAC3B,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,gBAAgB,EAAE,MAAM,CAAC;QACzB,qBAAqB,EAAE,OAAO,CAAC;KAChC,CAAC;CACH,CAAC;AAEF,wBAAgB,UAAU,CAAC,EACzB,WAAW,EACX,SAAS,EACT,YAAmB,EAAE,cAAc;AACnC,SAAkB,EAClB,OAAO,EACP,yBAA8B,EAC9B,8BAAwD,EAAE,SAAS;AACnE,gBAAgB,EAChB,MAAM,EACN,UAAU,EACV,WAAW,EACX,UAAU,EACV,aAAa,GACd,EAAE,iBAAiB,GAAG,UAAU,CAy7BhC"}

package/dist/azure-store.js

@@ -1,725 +0,0 @@
-import { BlobServiceClient as BlobService, StorageSharedKeyCredential, } from "@azure/storage-blob";
-import { UploadistaError } from "@uploadista/core/errors";
-import { azureActiveUploadsGauge as activeUploadsGauge, azureFileSizeHistogram as fileSizeHistogram, logAzureUploadCompletion, azurePartSizeHistogram as partSizeHistogram, azurePartUploadDurationHistogram as partUploadDurationHistogram, trackAzureError, azureUploadDurationHistogram as uploadDurationHistogram, azureUploadErrorsTotal as uploadErrorsTotal, azureUploadPartsTotal as uploadPartsTotal, azureUploadRequestsTotal as uploadRequestsTotal, azureUploadSuccessTotal as uploadSuccessTotal, withAzureTimingMetrics as withTimingMetrics, withAzureUploadMetrics as withUploadMetrics, } from "@uploadista/observability";
-import { Effect, Ref, Stream } from "effect";
-// Using base64 encoding that works in both Node.js and browser
-const bufferFrom = (str) => {
-    // Use global Buffer if available, otherwise fallback to btoa
-    if (typeof globalThis !== "undefined" && "Buffer" in globalThis) {
-        return globalThis.Buffer.from(str);
-    }
-    // Fallback for browser environments
-    return new Uint8Array(Array.from(str, (c) => c.charCodeAt(0)));
-};
-function calcOffsetFromBlocks(blocks) {
-    return blocks && blocks.length > 0
-        ? blocks.reduce((a, b) => a + (b?.size ?? 0), 0)
-        : 0;
-}
-export function azureStore({ deliveryUrl, blockSize, minBlockSize = 1024, // 1KB minimum
-maxBlocks = 50_000, kvStore, maxConcurrentBlockUploads = 60, expirationPeriodInMilliseconds = 1000 * 60 * 60 * 24 * 7, // 1 week
-connectionString, sasUrl, credential, accountName, accountKey, containerName, }) {
-    const preferredBlockSize = blockSize || 8 * 1024 * 1024; // 8MB default
-    const maxUploadSize = 5_497_558_138_880; // 5TiB (Azure Block Blob limit)
-    // Initialize Azure Blob Service Client with cross-platform authentication
-    let blobServiceClient;
-    if (connectionString) {
-        // Connection string (works in all environments)
-        blobServiceClient = BlobService.fromConnectionString(connectionString);
-    }
-    else if (sasUrl) {
-        // SAS URL (works in all environments including browsers)
-        blobServiceClient = new BlobService(sasUrl);
-    }
-    else if (credential) {
-        // OAuth token credential (works in all environments, recommended for production)
-        const accountUrl = accountName
-            ? `https://${accountName}.blob.core.windows.net`
-            : sasUrl?.split("?")[0] || "";
-        if (!accountUrl) {
-            throw new Error("When using credential authentication, either accountName or a valid sasUrl must be provided to determine the account URL");
-        }
-        blobServiceClient = new BlobService(accountUrl, credential);
-    }
-    else if (accountName && accountKey) {
-        // Legacy shared key authentication (Node.js only)
-        // This will fail in browser/edge environments
-        try {
-            const sharedKeyCredential = new StorageSharedKeyCredential(accountName, accountKey);
-            blobServiceClient = new BlobService(`https://${accountName}.blob.core.windows.net`, sharedKeyCredential);
-        }
-        catch (error) {
-            throw new Error("StorageSharedKeyCredential is only available in Node.js environments. " +
-                "Use sasUrl or credential options for cross-platform compatibility. " +
-                `Original error: ${error}`);
-        }
-    }
-    else {
-        throw new Error("Azure authentication required. Provide one of: " +
-            "connectionString, sasUrl, credential, or accountName + accountKey (Node.js only)");
-    }
-    const containerClient = blobServiceClient.getContainerClient(containerName);
-    const incompletePartKey = (id) => {
-        return `${id}.incomplete`;
-    };
-    const uploadBlock = (uploadFile, readStream, blockId) => {
-        return withTimingMetrics(partUploadDurationHistogram, Effect.gen(function* () {
-            yield* Effect.logInfo("Uploading block").pipe(Effect.annotateLogs({
-                upload_id: uploadFile.id,
-                block_id: blockId,
-                block_size: readStream.length,
-            }));
-            yield* uploadPartsTotal(Effect.succeed(1));
-            yield* partSizeHistogram(Effect.succeed(readStream.length));
-            try {
-                const blobClient = containerClient.getBlockBlobClient(uploadFile.id);
-                yield* Effect.tryPromise({
-                    try: async () => {
-                        await blobClient.stageBlock(blockId, readStream, readStream.length);
-                    },
-                    catch: (error) => {
-                        Effect.runSync(trackAzureError("uploadBlock", error, {
-                            upload_id: uploadFile.id,
-                            block_id: blockId,
-                            block_size: readStream.length,
-                        }));
-                        return UploadistaError.fromCode("FILE_WRITE_ERROR", {
-                            cause: error,
-                        });
-                    },
-                });
-                yield* Effect.logInfo("Finished uploading block").pipe(Effect.annotateLogs({
-                    upload_id: uploadFile.id,
-                    block_id: blockId,
-                    block_size: readStream.length,
-                }));
-            }
-            catch (error) {
-                Effect.runSync(trackAzureError("uploadBlock", error, {
-                    upload_id: uploadFile.id,
-                    block_id: blockId,
-                    block_size: readStream.length,
-                }));
-                throw error;
-            }
-        }));
-    };
-    const uploadIncompleteBlock = (id, readStream) => {
-        return Effect.tryPromise({
-            try: async () => {
-                const blobClient = containerClient.getBlockBlobClient(incompletePartKey(id));
-                await blobClient.upload(readStream, readStream.length);
-            },
-            catch: (error) => UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error }),
-        }).pipe(Effect.tap(() => Effect.logInfo("Finished uploading incomplete block").pipe(Effect.annotateLogs({
-            upload_id: id,
-        }))));
-    };
-    const getIncompleteBlock = (id) => {
-        return Effect.tryPromise({
-            try: async () => {
-                try {
-                    const blobClient = containerClient.getBlockBlobClient(incompletePartKey(id));
-                    const response = await blobClient.download();
-                    return response.readableStreamBody;
-                }
-                catch (error) {
-                    if (error &&
-                        typeof error === "object" &&
-                        "statusCode" in error &&
-                        error.statusCode === 404) {
-                        return undefined;
-                    }
-                    throw error;
-                }
-            },
-            catch: (error) => UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error }),
-        });
-    };
-    const getIncompleteBlockSize = (id) => {
-        return Effect.tryPromise({
-            try: async () => {
-                try {
-                    const blobClient = containerClient.getBlockBlobClient(incompletePartKey(id));
-                    const properties = await blobClient.getProperties();
-                    return properties.contentLength;
-                }
-                catch (error) {
-                    if (error &&
-                        typeof error === "object" &&
-                        "statusCode" in error &&
-                        error.statusCode === 404) {
-                        return undefined;
-                    }
-                    throw error;
-                }
-            },
-            catch: (error) => UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error }),
-        });
-    };
-    const deleteIncompleteBlock = (id) => {
-        return Effect.tryPromise({
-            try: async () => {
-                const blobClient = containerClient.getBlockBlobClient(incompletePartKey(id));
-                await blobClient.deleteIfExists();
-            },
-            catch: (error) => UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error }),
-        });
-    };
-    const downloadIncompleteBlock = (id) => {
-        return Effect.gen(function* () {
-            const incompleteBlock = yield* getIncompleteBlock(id);
-            if (!incompleteBlock) {
-                return;
-            }
-            // Read the stream and collect all chunks to calculate size
-            const reader = incompleteBlock.getReader();
-            const chunks = [];
-            let incompleteBlockSize = 0;
-            try {
-                while (true) {
-                    const result = yield* Effect.promise(() => reader.read());
-                    if (result.done)
-                        break;
-                    chunks.push(result.value);
-                    incompleteBlockSize += result.value.length;
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-            // Create a new readable stream from the chunks
-            const stream = Stream.fromIterable(chunks);
-            return {
-                size: incompleteBlockSize,
-                stream,
-            };
-        });
-    };
-    const calcOptimalBlockSize = (initSize) => {
-        const size = initSize ?? maxUploadSize;
-        let optimalBlockSize;
-        if (size <= preferredBlockSize) {
-            optimalBlockSize = size;
-        }
-        else if (size <= preferredBlockSize * maxBlocks) {
-            optimalBlockSize = preferredBlockSize;
-        }
-        else {
-            // Calculate the minimum block size needed to fit within the max blocks limit
-            optimalBlockSize = Math.ceil(size / maxBlocks);
-        }
-        // Ensure the block size respects the minimum and is aligned properly
-        const finalBlockSize = Math.max(optimalBlockSize, minBlockSize);
-        // Round up to ensure consistent block sizes
-        return Math.ceil(finalBlockSize / 1024) * 1024; // Align to 1KB boundaries
-    };
-    // Proper single-pass chunking using Effect's async stream constructor
-    // Ensures all parts except the final part are exactly the same size (S3 requirement)
-    const createChunkedStream = (chunkSize) => (stream) => {
-        return Stream.async((emit) => {
-            let buffer = new Uint8Array(0);
-            let blockNumber = 1;
-            let totalBytesProcessed = 0;
-            const emitChunk = (data, isFinalChunk = false) => {
-                // Log chunk information for debugging - use INFO level to see in logs
-                Effect.runSync(Effect.logInfo("Creating chunk").pipe(Effect.annotateLogs({
-                    block_number: blockNumber,
-                    chunk_size: data.length,
-                    expected_size: chunkSize,
-                    is_final_chunk: isFinalChunk,
-                    total_bytes_processed: totalBytesProcessed + data.length,
-                })));
-                emit.single({
-                    blockNumber: blockNumber++,
-                    data,
-                    size: data.length,
-                });
-            };
-            const processChunk = (newData) => {
-                // Combine buffer with new data
-                const combined = new Uint8Array(buffer.length + newData.length);
-                combined.set(buffer);
-                combined.set(newData, buffer.length);
-                buffer = combined;
-                totalBytesProcessed += newData.length;
-                // Emit full chunks of exactly chunkSize bytes
-                // This ensures S3 multipart upload rule: all parts except last must be same size
-                while (buffer.length >= chunkSize) {
-                    const chunk = buffer.slice(0, chunkSize);
-                    buffer = buffer.slice(chunkSize);
-                    emitChunk(chunk, false);
-                }
-            };
-            // Process the stream
-            Effect.runFork(stream.pipe(Stream.runForEach((chunk) => Effect.sync(() => processChunk(chunk))), Effect.andThen(() => Effect.sync(() => {
-                // Emit final chunk if there's remaining data
-                // The final chunk can be any size < chunkSize (S3 allows this)
-                if (buffer.length > 0) {
-                    emitChunk(buffer, true);
-                }
-                emit.end();
-            })), Effect.catchAll((error) => Effect.sync(() => emit.fail(error)))));
-        });
-    };
-    // Byte-level progress tracking during streaming
-    // This provides smooth, immediate progress feedback by tracking bytes as they
-    // flow through the stream, before they reach S3. This solves the issue where
-    // small files (< 5MB) would jump from 0% to 100% instantly.
-    const withByteProgressTracking = (onProgress, initialOffset = 0) => (stream) => {
-        if (!onProgress)
-            return stream;
-        return Effect.gen(function* () {
-            const totalBytesProcessedRef = yield* Ref.make(initialOffset);
-            return stream.pipe(Stream.tap((chunk) => Effect.gen(function* () {
-                const newTotal = yield* Ref.updateAndGet(totalBytesProcessedRef, (total) => total + chunk.length);
-                onProgress(newTotal);
-            })));
-        }).pipe(Stream.unwrap);
-    };
-    /**
-     * Uploads a stream to Azure using multiple blocks
-     */
-    const uploadBlocks = (uploadFile, readStream, initCurrentBlockNumber, initOffset, onProgress) => {
-        return Effect.gen(function* () {
-            yield* Effect.logInfo("Uploading blocks").pipe(Effect.annotateLogs({
-                upload_id: uploadFile.id,
-                init_offset: initOffset,
-                file_size: uploadFile.size,
-            }));
-            const size = uploadFile.size;
-            const uploadBlockSize = calcOptimalBlockSize(size);
-            yield* Effect.logInfo("Block size").pipe(Effect.annotateLogs({
-                upload_id: uploadFile.id,
-                block_size: uploadBlockSize,
-            }));
-            // Enhanced Progress Tracking Strategy:
-            // 1. Byte-level progress during streaming - provides immediate, smooth feedback
-            //    as data flows through the pipeline (even for small files)
-            // 2. This tracks progress BEFORE S3 upload, giving users immediate feedback
-            // 3. For large files with multiple parts, this provides granular updates
-            // 4. For small files (single part), this prevents 0%->100% jumps
-            const chunkStream = readStream.pipe(
-            // Add byte-level progress tracking during streaming (immediate feedback)
-            withByteProgressTracking(onProgress, initOffset), 
-            // Create chunks for S3 multipart upload with uniform part sizes
-            createChunkedStream(uploadBlockSize));
-            // Track cumulative offset and total bytes with Effect Refs
-            const cumulativeOffsetRef = yield* Ref.make(initOffset);
-            const totalBytesUploadedRef = yield* Ref.make(0);
-            const blockIdsRef = yield* Ref.make([]);
-            // Create a chunk upload function for the sink
-            const uploadChunk = (chunkInfo) => Effect.gen(function* () {
-                // Calculate cumulative bytes to determine if this is the final block
-                const cumulativeOffset = yield* Ref.updateAndGet(cumulativeOffsetRef, (offset) => offset + chunkInfo.size);
-                const isFinalBlock = cumulativeOffset >= (uploadFile.size || 0);
-                yield* Effect.logDebug("Processing chunk").pipe(Effect.annotateLogs({
-                    upload_id: uploadFile.id,
-                    cumulative_offset: cumulativeOffset,
-                    file_size: uploadFile.size,
-                    chunk_size: chunkInfo.size,
-                    is_final_block: isFinalBlock,
-                }));
-                const actualBlockNumber = initCurrentBlockNumber + chunkInfo.blockNumber - 1;
-                if (chunkInfo.size > uploadBlockSize) {
-                    yield* Effect.fail(UploadistaError.fromCode("FILE_WRITE_ERROR", {
-                        cause: new Error(`Block size ${chunkInfo.size} exceeds upload block size ${uploadBlockSize}`),
-                    }));
-                }
-                // For parts that meet the minimum part size (5MB) or are the final part,
-                // upload them as regular multipart parts
-                if (chunkInfo.size >= minBlockSize || isFinalBlock) {
-                    yield* Effect.logDebug("Uploading multipart chunk").pipe(Effect.annotateLogs({
-                        upload_id: uploadFile.id,
-                        block_number: actualBlockNumber,
-                        chunk_size: chunkInfo.size,
-                        min_block_size: minBlockSize,
-                        is_final_block: isFinalBlock,
-                    }));
-                    // Generate block ID (base64 encoded, must be consistent)
-                    const blockId = bufferFrom(`block-${actualBlockNumber.toString().padStart(6, "0")}`).toString("base64");
-                    yield* uploadBlock(uploadFile, chunkInfo.data, blockId);
-                    yield* Ref.update(blockIdsRef, (ids) => [...ids, blockId]);
-                    yield* partSizeHistogram(Effect.succeed(chunkInfo.size));
-                }
-                else {
-                    // Only upload as incomplete part if it's smaller than minimum and not final
-                    yield* uploadIncompleteBlock(uploadFile.id, chunkInfo.data);
-                }
-                yield* Ref.update(totalBytesUploadedRef, (total) => total + chunkInfo.size);
-                // Note: Byte-level progress is now tracked during streaming phase
-                // This ensures smooth progress updates regardless of part size
-                // Azure upload completion is tracked via totalBytesUploadedRef for accuracy
-            });
-            // Process chunks concurrently with controlled concurrency
-            yield* chunkStream.pipe(Stream.runForEach((chunkInfo) => uploadChunk(chunkInfo)), Effect.withConcurrency(maxConcurrentBlockUploads));
-            return {
-                bytesUploaded: yield* Ref.get(totalBytesUploadedRef),
-                blockIds: yield* Ref.get(blockIdsRef),
-            };
-        });
-    };
-    /**
-     * Commits all staged blocks to create the final blob
-     */
-    const commitBlocks = (uploadFile, blockIds) => {
-        return Effect.tryPromise({
-            try: async () => {
-                const blobClient = containerClient.getBlockBlobClient(uploadFile.id);
-                await blobClient.commitBlockList(blockIds, {
-                    blobHTTPHeaders: {
-                        blobContentType: uploadFile.metadata?.contentType?.toString(),
-                        blobCacheControl: uploadFile.metadata?.cacheControl?.toString(),
-                    },
-                });
-            },
-            catch: (error) => UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error }),
-        });
-    };
-    /**
-     * Gets the committed blocks for a blob
-     */
-    const retrieveBlocks = (id) => {
-        return Effect.tryPromise({
-            try: async () => {
-                try {
-                    const blobClient = containerClient.getBlockBlobClient(id);
-                    const blockList = await blobClient.getBlockList("committed");
-                    const blocks = blockList.committedBlocks?.map((block) => ({
-                        size: block.size,
-                    })) ?? [];
-                    return blocks;
-                }
-                catch (error) {
-                    if (error &&
-                        typeof error === "object" &&
-                        "statusCode" in error &&
-                        error.statusCode === 404) {
-                        return [];
-                    }
-                    throw error;
-                }
-            },
-            catch: (error) => UploadistaError.fromCode("UPLOAD_ID_NOT_FOUND", {
-                cause: error,
-            }),
-        });
-    };
-    /**
-     * Removes cached data for a given file
-     */
-    const clearCache = (id) => {
-        return Effect.gen(function* () {
-            yield* Effect.logInfo("Removing cached data").pipe(Effect.annotateLogs({
-                upload_id: id,
-            }));
-            yield* kvStore.delete(id);
-        });
-    };
-    /**
-     * Creates a blob placeholder in Azure and stores metadata
-     */
-    const create = (upload) => {
-        return Effect.gen(function* () {
-            yield* uploadRequestsTotal(Effect.succeed(1));
-            yield* activeUploadsGauge(Effect.succeed(1));
-            yield* fileSizeHistogram(Effect.succeed(upload.size || 0));
-            yield* Effect.logInfo("Initializing Azure blob upload").pipe(Effect.annotateLogs({
-                upload_id: upload.id,
-            }));
-            upload.creationDate = new Date().toISOString();
-            upload.storage = {
-                id: upload.storage.id,
-                type: upload.storage.type,
-                path: upload.id,
-                bucket: containerName,
-            };
-            upload.url = `${deliveryUrl}/${upload.id}`;
-            yield* kvStore.set(upload.id, upload);
-            yield* Effect.logInfo("Azure blob upload initialized").pipe(Effect.annotateLogs({
-                upload_id: upload.id,
-            }));
-            return upload;
-        });
-    };
-    const readStream = (id) => {
-        return Effect.tryPromise({
-            try: async () => {
-                const blobClient = containerClient.getBlockBlobClient(id);
-                const response = await blobClient.download();
-                if (response.blobBody) {
-                    return response.blobBody;
-                }
-                if (response.readableStreamBody) {
-                    return response.readableStreamBody;
-                }
-                throw new Error("No blob body or readable stream body");
-            },
-            catch: (error) => UploadistaError.fromCode("FILE_WRITE_ERROR", {
-                cause: error,
-            }),
-        });
-    };
-    const read = (id) => {
-        return Effect.gen(function* () {
-            const stream = yield* readStream(id);
-            // Convert stream/blob to Uint8Array
-            if (stream instanceof Blob) {
-                const arrayBuffer = yield* Effect.promise(() => stream.arrayBuffer());
-                return new Uint8Array(arrayBuffer);
-            }
-            // Read from ReadableStream
-            const reader = stream.getReader();
-            const chunks = [];
-            try {
-                while (true) {
-                    const result = yield* Effect.promise(() => reader.read());
-                    if (result.done)
-                        break;
-                    chunks.push(result.value);
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-            // Concatenate all chunks
-            const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-            const result = new Uint8Array(totalLength);
-            let offset = 0;
-            for (const chunk of chunks) {
-                result.set(chunk, offset);
-                offset += chunk.length;
-            }
-            return result;
-        });
-    };
-    const prepareUpload = (file_id, initialOffset, initialData) => {
-        return Effect.gen(function* () {
-            const uploadFile = yield* kvStore.get(file_id);
-            const blocks = yield* retrieveBlocks(file_id);
-            const blockNumber = blocks.length;
-            const nextBlockNumber = blockNumber + 1;
-            const incompleteBlock = yield* downloadIncompleteBlock(file_id);
-            if (incompleteBlock) {
-                yield* deleteIncompleteBlock(file_id);
-                const offset = initialOffset - incompleteBlock.size;
-                const data = incompleteBlock.stream.pipe(Stream.concat(initialData));
-                return {
-                    uploadFile,
-                    nextBlockNumber: nextBlockNumber - 1,
-                    offset,
-                    incompleteBlockSize: incompleteBlock.size,
-                    data,
-                };
-            }
-            else {
-                return {
-                    uploadFile,
-                    nextBlockNumber,
-                    offset: initialOffset,
-                    incompleteBlockSize: 0,
-                    data: initialData,
-                };
-            }
-        });
-    };
-    /**
-     * Write to the file, starting at the provided offset
-     */
-    const write = (options, dependencies) => {
-        return withUploadMetrics(options.file_id, withTimingMetrics(uploadDurationHistogram, Effect.gen(function* () {
-            const startTime = Date.now();
-            const { stream: initialData, file_id, offset: initialOffset, } = options;
-            const { onProgress } = dependencies;
-            const prepareResult = yield* prepareUpload(file_id, initialOffset, initialData);
-            const { uploadFile, nextBlockNumber, offset, data } = prepareResult;
-            const { bytesUploaded, blockIds } = yield* uploadBlocks(uploadFile, data, nextBlockNumber, offset, onProgress);
-            const newOffset = offset + bytesUploaded;
-            if (uploadFile.size === newOffset) {
-                try {
-                    // Commit all blocks to finalize the blob
-                    yield* commitBlocks(uploadFile, blockIds);
-                    yield* clearCache(file_id);
-                    // Log completion with observability
-                    yield* logAzureUploadCompletion(file_id, {
-                        fileSize: uploadFile.size || 0,
-                        totalDurationMs: Date.now() - startTime,
-                        partsCount: blockIds.length,
-                        averagePartSize: uploadFile.size,
-                        throughputBps: uploadFile.size / (Date.now() - startTime),
-                        retryCount: 0,
-                    });
-                    yield* uploadSuccessTotal(Effect.succeed(1));
-                    yield* activeUploadsGauge(Effect.succeed(-1));
-                }
-                catch (error) {
-                    yield* Effect.logError("Failed to finish upload").pipe(Effect.annotateLogs({
-                        upload_id: file_id,
-                        error: JSON.stringify(error),
-                    }));
-                    yield* uploadErrorsTotal(Effect.succeed(1));
-                    Effect.runSync(trackAzureError("write", error, {
-                        upload_id: file_id,
-                        operation: "commit",
-                        blocks: blockIds.length,
-                    }));
-                    throw error;
-                }
-            }
-            return newOffset;
-        })));
-    };
-    const getUpload = (id) => {
-        return Effect.gen(function* () {
-            const uploadFile = yield* kvStore.get(id);
-            let offset = 0;
-            try {
-                const blocks = yield* retrieveBlocks(id);
-                offset = calcOffsetFromBlocks(blocks);
-            }
-            catch (error) {
-                // Check if the error is caused by the blob not being found
-                if (typeof error === "object" &&
-                    error !== null &&
-                    "statusCode" in error &&
-                    error.statusCode === 404) {
-                    return {
-                        ...uploadFile,
-                        offset: uploadFile.size,
-                        size: uploadFile.size,
-                        metadata: uploadFile.metadata,
-                        storage: uploadFile.storage,
-                    };
-                }
-                yield* Effect.logError("Error on get upload").pipe(Effect.annotateLogs({
-                    upload_id: id,
-                    error: JSON.stringify(error),
-                }));
-                throw error;
-            }
-            const incompleteBlockSize = yield* getIncompleteBlockSize(id);
-            return {
-                ...uploadFile,
-                offset: offset + (incompleteBlockSize ?? 0),
-                size: uploadFile.size,
-                storage: uploadFile.storage,
-            };
-        });
-    };
-    const remove = (id) => {
-        return Effect.gen(function* () {
-            try {
-                const blobClient = containerClient.getBlockBlobClient(id);
-                yield* Effect.promise(() => blobClient.deleteIfExists());
-                // Also delete incomplete block if it exists
-                yield* deleteIncompleteBlock(id);
-            }
-            catch (error) {
-                if (typeof error === "object" &&
-                    error !== null &&
-                    "statusCode" in error &&
-                    error.statusCode === 404) {
-                    yield* Effect.logError("No file found").pipe(Effect.annotateLogs({
-                        upload_id: id,
-                    }));
-                    return yield* Effect.fail(UploadistaError.fromCode("FILE_NOT_FOUND"));
-                }
-                Effect.runSync(trackAzureError("remove", error, {
-                    upload_id: id,
-                }));
-                throw error;
-            }
-            yield* clearCache(id);
-            yield* activeUploadsGauge(Effect.succeed(-1));
-        });
-    };
-    const getExpiration = () => {
-        return expirationPeriodInMilliseconds;
-    };
-    const getExpirationDate = (created_at) => {
-        const date = new Date(created_at);
-        return new Date(date.getTime() + getExpiration());
-    };
-    const deleteExpired = () => {
-        return Effect.tryPromise({
-            try: async () => {
-                if (getExpiration() === 0) {
-                    return 0;
-                }
-                let deleted = 0;
-                const response = containerClient.listBlobsFlat({
-                    includeMetadata: true,
-                });
-                const expiredBlobs = [];
-                for await (const blob of response) {
-                    if (blob.metadata?.creationDate) {
-                        const creationDate = new Date(blob.metadata.creationDate);
-                        if (Date.now() >
-                            getExpirationDate(creationDate.toISOString()).getTime()) {
-                            expiredBlobs.push(blob.name);
-                        }
-                    }
-                }
-                // Delete expired blobs
-                for (const blobName of expiredBlobs) {
-                    await containerClient.deleteBlob(blobName);
-                    deleted++;
-                }
-                return deleted;
-            },
-            catch: (error) => UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error }),
-        });
-    };
-    const getCapabilities = () => {
-        return {
-            supportsParallelUploads: true,
-            supportsConcatenation: false, // Azure doesn't have native concatenation like GCS
-            supportsDeferredLength: true,
-            supportsResumableUploads: true,
-            supportsTransactionalUploads: true,
-            maxConcurrentUploads: maxConcurrentBlockUploads,
-            minChunkSize: minBlockSize,
-            maxChunkSize: 4000 * 1024 * 1024, // 4000MB Azure limit
-            maxParts: maxBlocks,
-            optimalChunkSize: preferredBlockSize,
-            requiresOrderedChunks: false,
-            requiresMimeTypeValidation: true,
-            maxValidationSize: undefined, // no size limit
-        };
-    };
-    const getChunkerConstraints = () => {
-        return {
-            minChunkSize: minBlockSize,
-            maxChunkSize: 4000 * 1024 * 1024, // 4000MB Azure limit
-            optimalChunkSize: preferredBlockSize,
-            requiresOrderedChunks: false,
-        };
-    };
-    const validateUploadStrategy = (strategy) => {
-        const capabilities = getCapabilities();
-        const result = (() => {
-            switch (strategy) {
-                case "parallel":
-                    return capabilities.supportsParallelUploads;
-                case "single":
-                    return true;
-                default:
-                    return false;
-            }
-        })();
-        return Effect.succeed(result);
-    };
-    return {
-        bucket: containerName,
-        create,
-        remove,
-        write,
-        getUpload,
-        read,
-        readStream,
-        deleteExpired: deleteExpired(),
-        getCapabilities,
-        getChunkerConstraints,
-        validateUploadStrategy,
-    };
-}