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

package/dist/CHUNK_SIZE_BYTES.js

@@ -1,5 +1,5 @@
 let CHUNK_SIZE_BYTES = 8 * 1024 * 1024;
-if (process.env.CHUNK_SIZE_BYTES) {
+if ("process" in globalThis && process.env.CHUNK_SIZE_BYTES) {
   CHUNK_SIZE_BYTES = Number.parseInt(process.env.CHUNK_SIZE_BYTES, 10);
 }
 export {

package/dist/ProgressIterator.d.ts

@@ -0,0 +1,25 @@
+import { CompleteEvent, ProgressEvent, StreamEventSource } from './StreamEventSource.ts';
+declare abstract class BaseEventIterator<T extends CompleteEvent | any> implements AsyncIterable<T> {
+    protected eventSource: StreamEventSource;
+    protected queue: T[];
+    protected index: number;
+    protected isComplete: boolean;
+    protected resolversNext: PromiseWithResolvers<void>;
+    constructor(eventSource: StreamEventSource);
+    whenComplete(): Promise<T[]>;
+    on: (event: "progress", callback: (event: ProgressEvent) => void) => this;
+    protected push(event: T): void;
+    protected get queueLength(): number;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+export declare class ProgressIterator extends BaseEventIterator<ProgressEvent | CompleteEvent> {
+    constructor(eventSource: StreamEventSource);
+    private initializeListeners;
+}
+export declare class CompletionIterator extends BaseEventIterator<CompleteEvent | ProgressEvent> {
+    private totalSize;
+    private currentProgress;
+    constructor(eventSource: StreamEventSource);
+    private initializeListeners;
+}
+export {};

package/dist/ProgressIterator.js

@@ -0,0 +1,99 @@
+class BaseEventIterator {
+  constructor(eventSource) {
+    this.queue = [];
+    this.index = 0;
+    this.isComplete = false;
+    this.resolversNext = Promise.withResolvers();
+    this.eventSource = eventSource;
+  }
+  async whenComplete() {
+    for await (const _ of this) {
+    }
+    return this.queue;
+  }
+  push(event) {
+    this.queue.push(event);
+    this.resolversNext.resolve();
+    this.resolversNext = Promise.withResolvers();
+  }
+  get queueLength() {
+    return this.queue.length - this.index;
+  }
+  async *[Symbol.asyncIterator]() {
+    try {
+      while (!this.isComplete || this.queueLength > 0) {
+        if (this.queueLength === 0) {
+          await this.resolversNext.promise;
+        } else {
+          const item = this.queue[this.index];
+          if (!item) {
+            throw new Error("Queue is corrupted");
+          }
+          yield item;
+          this.index++;
+        }
+      }
+    } finally {
+      this.eventSource.close();
+    }
+  }
+}
+class ProgressIterator extends BaseEventIterator {
+  constructor(eventSource) {
+    super(eventSource);
+    this.initializeListeners();
+  }
+  initializeListeners() {
+    this.eventSource.on("progress", (event) => {
+      this.push(event);
+    });
+    this.eventSource.on("complete", (event) => {
+      this.isComplete = true;
+      this.push(event);
+    });
+    this.eventSource.on("error", (error) => {
+      this.eventSource.close();
+      this.resolversNext.reject(error);
+    });
+  }
+}
+class CompletionIterator extends BaseEventIterator {
+  constructor(eventSource) {
+    super(eventSource);
+    this.totalSize = 0;
+    this.currentProgress = 0;
+    this.initializeListeners();
+  }
+  initializeListeners() {
+    this.eventSource.on("size", (event) => {
+      this.totalSize = event.data.size;
+      this.push({
+        type: "progress",
+        data: {
+          progress: 0
+        }
+      });
+    });
+    this.eventSource.on("completion", (event) => {
+      this.currentProgress += Number(event.data.count);
+      this.push({
+        type: "progress",
+        data: {
+          progress: this.currentProgress / this.totalSize
+        }
+      });
+    });
+    this.eventSource.on("complete", (event) => {
+      this.isComplete = true;
+      this.push(event);
+    });
+    this.eventSource.on("error", (error) => {
+      this.eventSource.close();
+      this.resolversNext.reject(error);
+    });
+  }
+}
+export {
+  CompletionIterator,
+  ProgressIterator
+};

package/dist/ProgressIterator.test.d.ts

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

package/dist/StreamEventSource.d.ts

@@ -0,0 +1,50 @@
+type EventCallback<T> = (event: T) => void;
+export type StreamEventSourceEventMap = {
+    progress: ProgressEvent;
+    complete: CompleteEvent;
+    size: SizeEvent;
+    completion: CompletionEvent;
+    message: {
+        id: string | undefined;
+        data: string;
+    };
+    end: [];
+    error: Error;
+};
+export type ProgressEvent = {
+    type: "progress";
+    data: {
+        progress: number;
+    };
+};
+export type CompleteEvent = {
+    type: "complete";
+    data: object;
+};
+export type SizeEvent = {
+    type: "size";
+    data: {
+        size: number;
+    };
+};
+export type CompletionEvent = {
+    type: "completion";
+    data: {
+        count: number;
+    };
+};
+export declare class StreamEventSource {
+    private stream;
+    private activeReader;
+    private decoder;
+    private parser;
+    private listeners;
+    constructor(stream: ReadableStream);
+    on<K extends keyof StreamEventSourceEventMap>(event: K, callback: EventCallback<StreamEventSourceEventMap[K]>): this;
+    off<K extends keyof StreamEventSourceEventMap>(event: K, callback: EventCallback<StreamEventSourceEventMap[K]>): this;
+    protected emit<K extends keyof StreamEventSourceEventMap>(event: K, data: StreamEventSourceEventMap[K]): void;
+    whenClosed(): Promise<void>;
+    private startReading;
+    close(): void;
+}
+export {};

package/dist/StreamEventSource.js

@@ -0,0 +1,130 @@
+import debug from "debug";
+import { createParser } from "eventsource-parser";
+const log = debug("ef:StreamEventSource");
+class StreamEventSource {
+  constructor(stream) {
+    this.activeReader = null;
+    this.decoder = new TextDecoder();
+    this.listeners = {};
+    if (!stream) {
+      console.error("StreamEventSource: Stream is null or undefined");
+      throw new Error("Stream is required");
+    }
+    this.stream = stream;
+    this.parser = createParser({
+      onError: (err) => {
+        console.error("StreamEventSource: Parser error:", err);
+        this.emit("error", err);
+      },
+      onEvent: (event) => {
+        if (event.event) {
+          switch (event.event) {
+            case "size":
+              this.emit("size", {
+                type: "size",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "completion":
+              this.emit("completion", {
+                type: "completion",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "progress":
+              this.emit("progress", {
+                type: "progress",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "complete":
+              this.emit("complete", {
+                type: "complete",
+                data: JSON.parse(event.data)
+              });
+              break;
+            case "error":
+              log("StreamEventSource: Error event", event.data);
+              this.emit("error", new Error(event.data));
+              break;
+            default:
+              this.emit(
+                "error",
+                new Error(`Unknown event: ${event.event} data: ${event.data}`)
+              );
+          }
+        } else {
+          this.emit("message", {
+            id: event.id,
+            data: event.data
+          });
+        }
+      }
+    });
+    this.startReading().catch((error) => {
+      console.error("StreamEventSource: Error in startReading:", error);
+      this.emit("error", error);
+    });
+  }
+  on(event, callback) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event]?.push(callback);
+    return this;
+  }
+  off(event, callback) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      const index = listeners.indexOf(callback);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  emit(event, data) {
+    for (const callback of this.listeners[event] ?? []) {
+      callback(data);
+    }
+  }
+  whenClosed() {
+    return new Promise((resolve) => {
+      this.on("end", () => resolve());
+    });
+  }
+  async startReading() {
+    try {
+      this.activeReader = this.stream.getReader();
+      while (true) {
+        const { done, value } = await this.activeReader.read();
+        if (done) break;
+        const chunk = this.decoder.decode(value);
+        if (!value) {
+          throw new Error("Chunk is null");
+        }
+        this.parser.feed(chunk);
+      }
+      this.activeReader.releaseLock();
+      this.activeReader = null;
+      this.emit("end", []);
+    } catch (error) {
+      console.error("StreamEventSource: Error reading stream:", error);
+      if (error instanceof Error) {
+        this.emit("error", error);
+      } else {
+        this.emit("error", new Error(String(error)));
+      }
+    }
+  }
+  close() {
+    if (this.activeReader) {
+      this.activeReader.releaseLock();
+      this.activeReader = null;
+    }
+    this.parser.reset();
+  }
+}
+export {
+  StreamEventSource
+};

package/dist/StreamEventSource.test.d.ts

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

package/dist/client.d.ts

@@ -1,6 +1,9 @@
-import { RequestInit } from 'node-fetch';
+import { StreamEventSource } from './StreamEventSource.ts';
 export declare class Client {
     #private;
-    constructor(token: string, efHost?: string);
-    authenticatedFetch: (path: string, init?: RequestInit) => Promise<import('node-fetch').Response>;
+    constructor(token?: string, efHost?: string);
+    authenticatedEventSource: (path: string, init?: RequestInit) => Promise<StreamEventSource>;
+    authenticatedFetch: (path: string, init?: RequestInit & {
+        duplex?: "half";
+    }) => Promise<Response>;
 }

package/dist/client.js

@@ -1,20 +1,32 @@
 import debug from "debug";
-import fetch from "node-fetch";
+import { StreamEventSource } from "./StreamEventSource.js";
 const log = debug("ef:api:client");
 class Client {
   constructor(token, efHost = "https://editframe.dev") {
+    this.authenticatedEventSource = async (path, init = {}) => {
+      const response = await this.authenticatedFetch(path, init);
+      if (response.body === null) {
+        throw new Error("Could not create event source. Response body is null.");
+      }
+      return new StreamEventSource(response.body);
+    };
     this.authenticatedFetch = async (path, init = {}) => {
       init.headers ||= {};
       const url = new URL(path, this.#efHost);
       log(
         "Authenticated fetch",
         { url: url.toString(), init },
-        "(Token will be added as Bearer token)"
+        this.#token ? "(Token will be added as Bearer token)" : "(Using session cookie)"
       );
+      if (this.#token) {
+        Object.assign(init.headers, {
+          Authorization: `Bearer ${this.#token}`
+        });
+      }
       Object.assign(init.headers, {
-        Authorization: `Bearer ${this.#token}`,
         "Content-Type": "application/json"
       });
+      init.credentials = "include";
       const response = await fetch(url, init);
       log("Authenticated fetch response", response.status, response.statusText);
       return response;
@@ -22,9 +34,11 @@ class Client {
     log("Creating client with efHost", { efHost, tokenIsSet: !!token });
     this.#token = token;
     this.#efHost = efHost;
-    const { apiKey, apiSecret } = token.match(/^(?<apiSecret>ef_[^_]+)_(?<apiKey>.+)$/)?.groups ?? {};
-    if (!apiKey || !apiSecret) {
-      throw new Error("Invalid token format. Must look like: ef_{}_{}");
+    if (token) {
+      const { apiKey, apiSecret } = token.match(/^(?<apiSecret>ef_[^_]+)_(?<apiKey>.+)$/)?.groups ?? {};
+      if (!apiKey || !apiSecret) {
+        throw new Error("Invalid token format. Must look like: ef_{}_{}");
+      }
     }
   }
   #token;

package/dist/index.d.ts

@@ -1,8 +1,10 @@
-export { createCaptionFile, CreateCaptionFilePayload, type CreateCaptionFileResult, uploadCaptionFile, } from './resources/caption-file.ts';
-export { createImageFile, CreateImageFilePayload, type CreateImageFileResult, uploadImageFile, } from './resources/image-file.ts';
-export { createISOBMFFFile, CreateISOBMFFFilePayload, type CreateISOBMFFFileResult, uploadFragmentIndex, } from './resources/isobmff-file.ts';
+export { createCaptionFile, CreateCaptionFilePayload, type CreateCaptionFileResult, uploadCaptionFile, type LookupCaptionFileByMd5Result, lookupCaptionFileByMd5, } from './resources/caption-file.ts';
+export { createImageFile, CreateImageFilePayload, type CreateImageFileResult, uploadImageFile, type LookupImageFileByMd5Result, lookupImageFileByMd5, } from './resources/image-file.ts';
+export { createISOBMFFFile, CreateISOBMFFFilePayload, type CreateISOBMFFFileResult, uploadFragmentIndex, type LookupISOBMFFFileByMd5Result, lookupISOBMFFFileByMd5, type GetISOBMFFFileTranscriptionResult, getISOBMFFFileTranscription, } from './resources/isobmff-file.ts';
 export { createISOBMFFTrack, CreateISOBMFFTrackPayload, type CreateISOBMFFTrackResult, uploadISOBMFFTrack, } from './resources/isobmff-track.ts';
-export { createRender, CreateRenderPayload, type CreateRenderResult, uploadRender, } from './resources/renders.ts';
+export { createRender, CreateRenderPayload, type CreateRenderResult, uploadRender, type LookupRenderByMd5Result, lookupRenderByMd5, } from './resources/renders.ts';
+export { createTranscription, CreateTranscriptionPayload, type CreateTranscriptionResult, getTranscriptionInfo, getTranscriptionProgress, type TranscriptionInfoResult, } from './resources/transcriptions.ts';
 export { createURLToken, type URLTokenResult, } from './resources/url-token.ts';
-export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, updateUnprocessedFile, UpdateUnprocessedFilePayload, type UpdateUnprocessedFileResult, uploadUnprocessedFile, processAVFile, processAVFileBuffer, processImageFile, processImageFileBuffer, } from './resources/unprocessed-file.ts';
+export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, uploadUnprocessedFile, type LookupUnprocessedFileByMd5Result, lookupUnprocessedFileByMd5, processIsobmffFile, type ProcessIsobmffFileResult, } from './resources/unprocessed-file.ts';
+export { getIsobmffProcessInfo, getIsobmffProcessProgress, type IsobmffProcessInfoResult, } from './resources/process-isobmff.ts';
 export { Client } from './client.ts';

package/dist/index.js

@@ -1,10 +1,12 @@
-import { CreateCaptionFilePayload, createCaptionFile, uploadCaptionFile } from "./resources/caption-file.js";
-import { CreateImageFilePayload, createImageFile, uploadImageFile } from "./resources/image-file.js";
-import { CreateISOBMFFFilePayload, createISOBMFFFile, uploadFragmentIndex } from "./resources/isobmff-file.js";
+import { CreateCaptionFilePayload, createCaptionFile, lookupCaptionFileByMd5, uploadCaptionFile } from "./resources/caption-file.js";
+import { CreateImageFilePayload, createImageFile, lookupImageFileByMd5, uploadImageFile } from "./resources/image-file.js";
+import { CreateISOBMFFFilePayload, createISOBMFFFile, getISOBMFFFileTranscription, lookupISOBMFFFileByMd5, uploadFragmentIndex } from "./resources/isobmff-file.js";
 import { CreateISOBMFFTrackPayload, createISOBMFFTrack, uploadISOBMFFTrack } from "./resources/isobmff-track.js";
-import { CreateRenderPayload, createRender, uploadRender } from "./resources/renders.js";
+import { CreateRenderPayload, createRender, lookupRenderByMd5, uploadRender } from "./resources/renders.js";
+import { CreateTranscriptionPayload, createTranscription, getTranscriptionInfo, getTranscriptionProgress } from "./resources/transcriptions.js";
 import { createURLToken } from "./resources/url-token.js";
-import { CreateUnprocessedFilePayload, UpdateUnprocessedFilePayload, createUnprocessedFile, processAVFile, processAVFileBuffer, processImageFile, processImageFileBuffer, updateUnprocessedFile, uploadUnprocessedFile } from "./resources/unprocessed-file.js";
+import { CreateUnprocessedFilePayload, createUnprocessedFile, lookupUnprocessedFileByMd5, processIsobmffFile, uploadUnprocessedFile } from "./resources/unprocessed-file.js";
+import { getIsobmffProcessInfo, getIsobmffProcessProgress } from "./resources/process-isobmff.js";
 import { Client } from "./client.js";
 export {
   Client,
@@ -13,20 +15,27 @@ export {
   CreateISOBMFFTrackPayload,
   CreateImageFilePayload,
   CreateRenderPayload,
+  CreateTranscriptionPayload,
   CreateUnprocessedFilePayload,
-  UpdateUnprocessedFilePayload,
   createCaptionFile,
   createISOBMFFFile,
   createISOBMFFTrack,
   createImageFile,
   createRender,
+  createTranscription,
   createURLToken,
   createUnprocessedFile,
-  processAVFile,
-  processAVFileBuffer,
-  processImageFile,
-  processImageFileBuffer,
-  updateUnprocessedFile,
+  getISOBMFFFileTranscription,
+  getIsobmffProcessInfo,
+  getIsobmffProcessProgress,
+  getTranscriptionInfo,
+  getTranscriptionProgress,
+  lookupCaptionFileByMd5,
+  lookupISOBMFFFileByMd5,
+  lookupImageFileByMd5,
+  lookupRenderByMd5,
+  lookupUnprocessedFileByMd5,
+  processIsobmffFile,
   uploadCaptionFile,
   uploadFragmentIndex,
   uploadISOBMFFTrack,

package/dist/readableFromBuffers.d.ts

@@ -1,2 +1 @@
-import { Readable } from 'node:stream';
-export declare const readableFromBuffers: (...buffers: Buffer[]) => Readable;
+export declare const webReadableFromBuffers: (...buffers: Buffer[]) => ReadableStream<any>;

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

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateCaptionFilePayload: z.ZodObject<{
@@ -18,7 +17,11 @@ export interface CreateCaptionFileResult {
     complete: boolean | null;
     id: string;
     md5: string;
-    asset_id: string;
+}
+export interface LookupCaptionFileByMd5Result {
+    complete: boolean | null;
+    id: string;
+    md5: string;
 }
 /**
  * Create a caption file
@@ -38,4 +41,5 @@ export interface CreateCaptionFileResult {
  * @beta
  */
 export declare const createCaptionFile: (client: Client, payload: z.infer<typeof CreateCaptionFilePayload>) => Promise<CreateCaptionFileResult>;
-export declare const uploadCaptionFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<unknown>;
+export declare const uploadCaptionFile: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => Promise<any>;
+export declare const lookupCaptionFileByMd5: (client: Client, md5: string) => Promise<LookupCaptionFileByMd5Result | null>;

package/dist/resources/caption-file.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 const log = debug("ef:api:caption-file");
 const MAX_CAPTION_SIZE = 1024 * 1024 * 2;
 const CreateCaptionFilePayload = z.object({
@@ -37,7 +37,8 @@ const uploadCaptionFile = async (client, fileId, fileStream, fileSize) => {
     `/api/v1/caption_files/${fileId}/upload`,
     {
       method: "POST",
-      body: fileStream
+      body: fileStream,
+      duplex: "half"
     }
   );
   log("Caption file uploaded", response);
@@ -48,8 +49,27 @@ const uploadCaptionFile = async (client, fileId, fileStream, fileSize) => {
     `Failed to upload caption ${response.status} ${response.statusText}`
   );
 };
+const lookupCaptionFileByMd5 = async (client, md5) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/caption_files/md5/${md5}`,
+    {
+      method: "GET"
+    }
+  );
+  log("Caption file lookup", response);
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup caption by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateCaptionFilePayload,
   createCaptionFile,
+  lookupCaptionFileByMd5,
   uploadCaptionFile
 };

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

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateImageFilePayload: z.ZodObject<{
@@ -27,7 +26,12 @@ export interface CreateImageFileResult {
     complete: boolean | null;
     id: string;
     md5: string;
-    asset_id: string;
+}
+export interface LookupImageFileByMd5Result {
+    complete: boolean | null;
+    id: string;
+    md5: string;
 }
 export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult>;
-export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const uploadImageFile: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const lookupImageFileByMd5: (client: Client, md5: string) => Promise<LookupImageFileByMd5Result | null>;

package/dist/resources/image-file.js

@@ -35,8 +35,27 @@ const uploadImageFile = (client, fileId, fileStream, fileSize) => {
     maxSize: MAX_IMAGE_SIZE
   });
 };
+const lookupImageFileByMd5 = async (client, md5) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/image_files/md5/${md5}`,
+    {
+      method: "GET"
+    }
+  );
+  log("Image file lookup", response);
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup image by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateImageFilePayload,
   createImageFile,
+  lookupImageFileByMd5,
   uploadImageFile
 };

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

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateISOBMFFFilePayload: z.ZodObject<{
@@ -16,7 +15,21 @@ export interface CreateISOBMFFFileResult {
     filename: string;
     id: string;
     md5: string;
-    asset_id: string;
+}
+export interface LookupISOBMFFFileByMd5Result {
+    fragment_index_complete: boolean;
+    filename: string;
+    id: string;
+    md5: string;
+}
+export interface GetISOBMFFFileTranscriptionResult {
+    id: string;
+    work_slice_ms: number;
+    isobmff_track: {
+        duration_ms: number;
+    };
 }
 export declare const createISOBMFFFile: (client: Client, payload: z.infer<typeof CreateISOBMFFFilePayload>) => Promise<CreateISOBMFFFileResult>;
-export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<unknown>;
+export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => Promise<any>;
+export declare const lookupISOBMFFFileByMd5: (client: Client, md5: string) => Promise<LookupISOBMFFFileByMd5Result | null>;
+export declare const getISOBMFFFileTranscription: (client: Client, id: string) => Promise<GetISOBMFFFileTranscriptionResult | null>;

package/dist/resources/isobmff-file.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 const log = debug("ef:api:isobmff-file");
 const FILE_SIZE_LIMIT = 1024 * 1024 * 2;
 const CreateISOBMFFFilePayload = z.object({
@@ -29,7 +29,8 @@ const uploadFragmentIndex = async (client, fileId, fileStream, fileSize) => {
     `/api/v1/isobmff_files/${fileId}/index/upload`,
     {
       method: "POST",
-      body: fileStream
+      body: fileStream,
+      duplex: "half"
     }
   );
   log("Fragment index uploaded", response);
@@ -40,8 +41,42 @@ const uploadFragmentIndex = async (client, fileId, fileStream, fileSize) => {
     `Failed to create fragment index ${response.status} ${response.statusText}`
   );
 };
+const lookupISOBMFFFileByMd5 = async (client, md5) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/md5/${md5}`,
+    {
+      method: "GET"
+    }
+  );
+  log("ISOBMFF file lookup", response);
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup isobmff file by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
+const getISOBMFFFileTranscription = async (client, id) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${id}/transcription`
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to get isobmff file transcription ${id} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateISOBMFFFilePayload,
   createISOBMFFFile,
+  getISOBMFFFileTranscription,
+  lookupISOBMFFFileByMd5,
   uploadFragmentIndex
 };