@editframe/api 0.11.0-beta.9 → 0.12.0-beta.2

package/dist/resources/isobmff-track.d.ts

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -76,8 +75,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     codec_name: z.ZodString;
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    byte_size: number;
     type: "audio";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
@@ -106,8 +105,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     };
     duration_ms: number;
 }, {
-    byte_size: number;
     type: "audio";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
@@ -204,8 +203,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     codec_name: z.ZodString;
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    byte_size: number;
     type: "video";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
@@ -232,8 +231,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     };
     duration_ms: number;
 }, {
-    byte_size: number;
     type: "video";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
@@ -265,8 +264,7 @@ export interface CreateISOBMFFTrackResult {
     byte_size: number;
     track_id: number;
     file_id: string;
-    asset_id: string;
     complete: boolean;
 }
 export declare const createISOBMFFTrack: (client: Client, payload: z.infer<typeof CreateISOBMFFTrackPayload>) => Promise<CreateISOBMFFTrackResult>;
-export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: Readable, trackSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: ReadableStream, trackSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;

package/dist/resources/isobmff-track.js

@@ -1,7 +1,50 @@
 import debug from "debug";
 import { z } from "zod";
-import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
 import { uploadChunks } from "../uploadChunks.js";
+const AudioStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("audio"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  sample_fmt: z.string(),
+  sample_rate: z.string(),
+  channels: z.number(),
+  channel_layout: z.string(),
+  bits_per_sample: z.number(),
+  initial_padding: z.number().optional(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number(),
+  start_time: z.coerce.number(),
+  duration_ts: z.number(),
+  duration: z.coerce.number(),
+  bit_rate: z.string(),
+  disposition: z.record(z.unknown())
+});
+const VideoStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("video"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  width: z.number(),
+  height: z.number(),
+  coded_width: z.number(),
+  coded_height: z.number(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number().optional(),
+  start_time: z.coerce.number().optional(),
+  duration_ts: z.number().optional(),
+  duration: z.coerce.number().optional(),
+  bit_rate: z.string().optional(),
+  disposition: z.record(z.unknown())
+});
 const log = debug("ef:api:isobmff-track");
 const MAX_TRACK_SIZE = 1024 * 1024 * 1024;
 const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [

package/dist/resources/process-isobmff.d.ts

@@ -0,0 +1,12 @@
+import { ProgressIterator } from '../ProgressIterator.ts';
+import { Client } from '../client.ts';
+export interface IsobmffProcessInfoResult {
+    id: string;
+    created_at: string;
+    completed_at: string | null;
+    failed_at: string | null;
+    isobmff_file_id: string | null;
+    unprocessed_file_id: string;
+}
+export declare const getIsobmffProcessProgress: (client: Client, id: string) => Promise<ProgressIterator>;
+export declare const getIsobmffProcessInfo: (client: Client, id: string) => Promise<IsobmffProcessInfoResult>;

package/dist/resources/process-isobmff.js

@@ -0,0 +1,22 @@
+import { ProgressIterator } from "../ProgressIterator.js";
+const getIsobmffProcessProgress = async (client, id) => {
+  const eventSource = await client.authenticatedEventSource(
+    `/api/v1/process_isobmff/${id}/progress`
+  );
+  return new ProgressIterator(eventSource);
+};
+const getIsobmffProcessInfo = async (client, id) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/process_isobmff/${id}`
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to get isobmff process info ${response.status} ${response.statusText}`
+  );
+};
+export {
+  getIsobmffProcessInfo,
+  getIsobmffProcessProgress
+};

package/dist/resources/process-isobmff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/resources/renders.d.ts

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateRenderPayload: z.ZodObject<{
@@ -13,23 +12,29 @@ export declare const CreateRenderPayload: z.ZodObject<{
     md5: string;
     height: number;
     width: number;
-    strategy: "v1" | "v2";
     duration_ms: number;
     fps: number;
     work_slice_ms: number;
+    strategy: "v1" | "v2";
 }, {
     md5: string;
     height: number;
     width: number;
-    strategy: "v1" | "v2";
     duration_ms: number;
     fps: number;
     work_slice_ms: number;
+    strategy: "v1" | "v2";
 }>;
 export interface CreateRenderResult {
     id: string;
     md5: string;
-    status: "complete" | "created" | "failed" | "pending" | "rendering";
+    status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
+}
+export interface LookupRenderByMd5Result {
+    id: string;
+    md5: string;
+    status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
 }
 export declare const createRender: (client: Client, payload: z.infer<typeof CreateRenderPayload>) => Promise<CreateRenderResult>;
-export declare const uploadRender: (client: Client, fileId: string, fileStream: Readable, folderSize: number) => Promise<unknown>;
+export declare const uploadRender: (client: Client, fileId: string, fileStream: ReadableStream, folderSize: number) => Promise<any>;
+export declare const lookupRenderByMd5: (client: Client, md5: string) => Promise<LookupRenderByMd5Result | null>;

package/dist/resources/renders.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 const log = debug("ef:api:renders");
 const FILE_SIZE_LIMIT = 1024 * 1024 * 16;
 const CreateRenderPayload = z.object({
@@ -35,7 +35,8 @@ const uploadRender = async (client, fileId, fileStream, folderSize) => {
     `/api/v1/renders/${fileId}/upload`,
     {
       method: "POST",
-      body: fileStream
+      body: fileStream,
+      duplex: "half"
     }
   );
   if (response.ok) {
@@ -45,8 +46,26 @@ const uploadRender = async (client, fileId, fileStream, folderSize) => {
     `Failed to upload render ${response.status} ${response.statusText}`
   );
 };
+const lookupRenderByMd5 = async (client, md5) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/renders/md5/${md5}`,
+    {
+      method: "GET"
+    }
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup render by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateRenderPayload,
   createRender,
+  lookupRenderByMd5,
   uploadRender
 };

package/dist/resources/transcriptions.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { CompletionIterator } from '../ProgressIterator.ts';
+import { Client } from '../client.ts';
+export declare const CreateTranscriptionPayload: z.ZodObject<{
+    file_id: z.ZodString;
+    track_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    file_id: string;
+    track_id: number;
+}, {
+    file_id: string;
+    track_id: number;
+}>;
+export interface CreateTranscriptionResult {
+    id: string;
+    status: "complete" | "created" | "failed" | "pending" | "transcribing";
+}
+export interface TranscriptionInfoResult {
+    id: string;
+    status: "complete" | "created" | "failed" | "pending" | "transcribing";
+}
+export declare const createTranscription: (client: Client, payload: z.infer<typeof CreateTranscriptionPayload>) => Promise<CreateTranscriptionResult>;
+export declare const getTranscriptionProgress: (client: Client, id: string) => Promise<CompletionIterator>;
+export declare const getTranscriptionInfo: (client: Client, id: string) => Promise<TranscriptionInfoResult>;

package/dist/resources/transcriptions.js

@@ -0,0 +1,45 @@
+import debug from "debug";
+import { z } from "zod";
+import { CompletionIterator } from "../ProgressIterator.js";
+const log = debug("ef:api:transcriptions");
+const CreateTranscriptionPayload = z.object({
+  file_id: z.string(),
+  track_id: z.number().int()
+});
+const createTranscription = async (client, payload) => {
+  log("Creating transcription", payload);
+  const response = await client.authenticatedFetch("/api/v1/transcriptions", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+  log("Transcription created", response);
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to create transcription ${response.status} ${response.statusText}`
+  );
+};
+const getTranscriptionProgress = async (client, id) => {
+  const eventSource = await client.authenticatedEventSource(
+    `/api/v1/transcriptions/${id}/progress`
+  );
+  return new CompletionIterator(eventSource);
+};
+const getTranscriptionInfo = async (client, id) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/transcriptions/${id}`
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to get transcription info ${response.status} ${response.statusText}`
+  );
+};
+export {
+  CreateTranscriptionPayload,
+  createTranscription,
+  getTranscriptionInfo,
+  getTranscriptionProgress
+};

package/dist/resources/transcriptions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/resources/unprocessed-file.d.ts

@@ -1,78 +1,37 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
-import { IteratorWithPromise, UploadChunkEvent } from '../uploadChunks.ts';
-declare const FileProcessors: z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"image">, z.ZodLiteral<"captions">, z.ZodString]>, "many">, string[], string[]>;
 export declare const CreateUnprocessedFilePayload: z.ZodObject<{
     md5: z.ZodString;
     filename: z.ZodString;
-    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"image">, z.ZodLiteral<"captions">, z.ZodString]>, "many">, string[], string[]>>;
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     md5: string;
     filename: string;
     byte_size: number;
-    processes?: string[] | undefined;
 }, {
     md5: string;
     filename: string;
     byte_size: number;
-    processes?: string[] | undefined;
 }>;
-export declare const UpdateUnprocessedFilePayload: z.ZodObject<{
-    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"image">, z.ZodLiteral<"captions">, z.ZodString]>, "many">, string[], string[]>>;
-}, "strip", z.ZodTypeAny, {
-    processes?: string[] | undefined;
-}, {
-    processes?: string[] | undefined;
-}>;
-export interface CreateUnprocessedFileResult {
+export declare const UpdateUnprocessedFilePayload: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+interface UnprocessedFile {
     byte_size: number;
     next_byte: number;
     complete: boolean;
     id: string;
     md5: string;
-    processes: z.infer<typeof FileProcessors> & string[];
-    asset_id: string;
 }
-export interface UpdateUnprocessedFileResult {
-    byte_size?: number;
-    next_byte: number;
-    complete: boolean;
+export interface CreateUnprocessedFileResult extends UnprocessedFile {
+}
+export interface LookupUnprocessedFileByMd5Result extends UnprocessedFile {
+}
+export interface UpdateUnprocessedFileResult extends UnprocessedFile {
+}
+export interface ProcessIsobmffFileResult {
     id: string;
-    md5: string;
-    processes: z.infer<typeof FileProcessors>;
-    asset_id: string;
 }
 export declare const createUnprocessedFile: (client: Client, payload: z.infer<typeof CreateUnprocessedFilePayload>) => Promise<CreateUnprocessedFileResult>;
-export declare const updateUnprocessedFile: (client: Client, fileId: string, payload: Partial<z.infer<typeof UpdateUnprocessedFilePayload>>) => Promise<UpdateUnprocessedFileResult>;
-export declare const uploadUnprocessedFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => IteratorWithPromise<UploadChunkEvent>;
-export declare const processAVFileBuffer: (client: Client, buffer: Buffer, filename?: string) => {
-    progress(): AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
-export declare const processAVFile: (client: Client, filePath: string) => {
-    progress: () => Promise<AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
-export declare const processImageFileBuffer: (client: Client, buffer: Buffer, filename?: string) => {
-    progress(): AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
-export declare const processImageFile: (client: Client, filePath: string) => {
-    progress: () => Promise<AsyncGenerator<{
-        type: string;
-        progress: number;
-    }, void, unknown>>;
-    file: () => Promise<UpdateUnprocessedFileResult>;
-};
+export declare const uploadUnprocessedFile: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const lookupUnprocessedFileByMd5: (client: Client, md5: string) => Promise<LookupUnprocessedFileByMd5Result | null>;
+export declare const processIsobmffFile: (client: Client, unprocessedFileId: LookupUnprocessedFileByMd5Result["id"]) => Promise<ProcessIsobmffFileResult>;
 export {};

package/dist/resources/unprocessed-file.js

@@ -1,36 +1,14 @@
-import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
-import { basename } from "node:path";
-import { Readable } from "node:stream";
 import debug from "debug";
 import { z } from "zod";
-import { md5Buffer, md5FilePath } from "@editframe/assets";
 import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:unprocessed-file");
-const FileProcessor = z.union([
-  z.literal("isobmff"),
-  z.literal("image"),
-  z.literal("captions"),
-  z.string()
-]);
-const FileProcessors = z.array(FileProcessor).refine(
-  (value) => {
-    return new Set(value).size === value.length;
-  },
-  {
-    message: "Processors list must not include duplicates"
-  }
-);
 const MAX_FILE_SIZE = 1024 * 1024 * 1024;
 const CreateUnprocessedFilePayload = z.object({
   md5: z.string(),
   filename: z.string(),
-  processes: FileProcessors.optional(),
   byte_size: z.number().int().max(MAX_FILE_SIZE)
 });
-const UpdateUnprocessedFilePayload = z.object({
-  processes: FileProcessors.optional()
-});
+z.object({});
 const createUnprocessedFile = async (client, payload) => {
   log("Creating an unprocessed file", payload);
   CreateUnprocessedFilePayload.parse(payload);
@@ -54,24 +32,6 @@ const createUnprocessedFile = async (client, payload) => {
     `Failed to create unprocessed file ${response.status} ${response.statusText}`
   );
 };
-const updateUnprocessedFile = async (client, fileId, payload) => {
-  log("Updating unprocessed file", fileId, payload);
-  UpdateUnprocessedFilePayload.parse(payload);
-  const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${fileId}`,
-    {
-      method: "POST",
-      body: JSON.stringify(payload)
-    }
-  );
-  log("Unprocessed file updated", response);
-  if (response.ok) {
-    return await response.json();
-  }
-  throw new Error(
-    `Failed to update unprocessed file ${response.status} ${response.statusText}`
-  );
-};
 const uploadUnprocessedFile = (client, fileId, fileStream, fileSize) => {
   log("Uploading unprocessed file", fileId);
   return uploadChunks(client, {
@@ -81,100 +41,41 @@ const uploadUnprocessedFile = (client, fileId, fileStream, fileSize) => {
     maxSize: MAX_FILE_SIZE
   });
 };
-const processResource = (client, filename, md5, byteSize, processor, doUpload) => {
-  log("Processing", { filename, md5, byteSize, processor });
-  const createFilePromise = createUnprocessedFile(client, {
-    md5,
-    processes: [],
-    filename,
-    byte_size: byteSize
-  });
-  return {
-    async *progress() {
-      const unprocessedFile = await createFilePromise;
-      if (unprocessedFile.complete) {
-        yield { type: "progress", progress: 0 };
-        yield { type: "progress", progress: 1 };
-      }
-      yield* doUpload(unprocessedFile.id);
-    },
-    file: async () => {
-      const unprocessedFile = await createFilePromise;
-      if (unprocessedFile.complete) {
-        return unprocessedFile;
-      }
-      await doUpload(unprocessedFile.id).whenUploaded();
-      const fileInformation = await updateUnprocessedFile(
-        client,
-        unprocessedFile.id,
-        {
-          processes: [processor]
-        }
-      );
-      log("File processed", fileInformation);
-      return fileInformation;
+const lookupUnprocessedFileByMd5 = async (client, md5) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/md5/${md5}`,
+    {
+      method: "GET"
     }
-  };
-};
-const buildBufferProcessor = (processor) => {
-  return (client, buffer, filename = "buffer") => {
-    log(`Processing file buffer: ${processor}`, filename);
-    const md5 = md5Buffer(buffer);
-    return processResource(
-      client,
-      filename,
-      md5,
-      buffer.byteLength,
-      processor,
-      (id) => {
-        const readStream = new Readable({
-          read() {
-            readStream.push(buffer);
-            readStream.push(null);
-          }
-        });
-        return uploadUnprocessedFile(client, id, readStream, buffer.byteLength);
-      }
-    );
-  };
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup unprocessed file by md5 ${md5} ${response.status} ${response.statusText}`
+  );
 };
-const buildFileProcessor = (processor) => {
-  return (client, filePath) => {
-    const processPromise = async () => {
-      const [md5, { size: byteSize }] = await Promise.all([
-        md5FilePath(filePath),
-        stat(filePath)
-      ]);
-      return processResource(
-        client,
-        basename(filePath),
-        md5,
-        byteSize,
-        processor,
-        (id) => {
-          const readStream = createReadStream(filePath);
-          return uploadUnprocessedFile(client, id, readStream, byteSize);
-        }
-      );
-    };
-    return {
-      progress: async () => (await processPromise()).progress(),
-      file: async () => (await processPromise()).file()
-    };
-  };
+const processIsobmffFile = async (client, unprocessedFileId) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${unprocessedFileId}/isobmff`,
+    {
+      method: "POST"
+    }
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to process isobmff file ${response.status} ${response.statusText}`
+  );
 };
-const processAVFileBuffer = buildBufferProcessor("isobmff");
-const processAVFile = buildFileProcessor("isobmff");
-const processImageFileBuffer = buildBufferProcessor("image");
-const processImageFile = buildFileProcessor("image");
 export {
   CreateUnprocessedFilePayload,
-  UpdateUnprocessedFilePayload,
   createUnprocessedFile,
-  processAVFile,
-  processAVFileBuffer,
-  processImageFile,
-  processImageFileBuffer,
-  updateUnprocessedFile,
+  lookupUnprocessedFileByMd5,
+  processIsobmffFile,
   uploadUnprocessedFile
 };

package/dist/streamChunker.d.ts

@@ -1,2 +1 @@
-import { Readable } from 'node:stream';
-export declare function streamChunker(readableStream: Readable, chunkSize?: number): AsyncGenerator<Buffer, void, unknown>;
+export declare function streamChunker(readableStream: ReadableStream, chunkSize?: number): AsyncGenerator<Uint8Array, void, unknown>;

package/dist/streamChunker.js

@@ -1,15 +1,26 @@
 import { CHUNK_SIZE_BYTES } from "./CHUNK_SIZE_BYTES.js";
 async function* streamChunker(readableStream, chunkSize = CHUNK_SIZE_BYTES) {
-  let buffer = Buffer.alloc(0);
-  for await (const chunk of readableStream) {
-    buffer = Buffer.concat([buffer, chunk]);
-    while (buffer.length >= chunkSize) {
-      yield buffer.slice(0, chunkSize);
-      buffer = buffer.slice(chunkSize);
+  const reader = readableStream.getReader();
+  let buffer = new Uint8Array(0);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = value;
+      const newBuffer = new Uint8Array(buffer.length + chunk.length);
+      newBuffer.set(buffer);
+      newBuffer.set(chunk, buffer.length);
+      buffer = newBuffer;
+      while (buffer.length >= chunkSize) {
+        yield buffer.slice(0, chunkSize);
+        buffer = buffer.slice(chunkSize);
+      }
     }
-  }
-  if (buffer.length > 0) {
-    yield buffer;
+    if (buffer.length > 0) {
+      yield buffer;
+    }
+  } finally {
+    reader.releaseLock();
   }
 }
 export {

package/dist/uploadChunks.d.ts

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { Client } from './client.ts';
 export interface IteratorWithPromise<T> extends AsyncGenerator<T, void, unknown> {
     whenUploaded: () => Promise<T[]>;
@@ -6,7 +5,7 @@ export interface IteratorWithPromise<T> extends AsyncGenerator<T, void, unknown>
 export declare const fakeCompleteUpload: () => IteratorWithPromise<UploadChunkEvent>;
 interface UploadChunksOptions {
     url: string;
-    fileStream: Readable;
+    fileStream: ReadableStream;
     fileSize: number;
     maxSize: number;
     chunkSizeBytes?: number;

package/dist/uploadChunks.js

@@ -51,7 +51,7 @@ function uploadChunks(client, {
     const uploadStatus = await client.authenticatedFetch(url);
     yield { type: "progress", progress: 0 };
     if (uploadStatus.status === 200) {
-      log("Fragment track already uploaded");
+      log("Chunk already uploaded");
       yield { type: "progress", progress: 1 };
       return;
     }
@@ -72,9 +72,6 @@ function uploadChunks(client, {
         progress: Math.min(1, chunkNumber / (fileSize / chunkSizeBytes))
       };
     }
-    if (!fileStream.readableEnded) {
-      throw new Error("Did not read entire file stream");
-    }
     if (!complete) {
       throw new Error("Did not complete upload");
     }