@editframe/api 0.12.0-beta.3 → 0.12.0-beta.8

package/dist/{index.js → api/src/index.js}

@@ -1,11 +1,11 @@
 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 { CreateISOBMFFFilePayload, TranscribeISOBMFFFilePayload, createISOBMFFFile, getISOBMFFFileTranscription, lookupISOBMFFFileByMd5, transcribeISOBMFFFile, uploadFragmentIndex } from "./resources/isobmff-file.js";
 import { CreateISOBMFFTrackPayload, createISOBMFFTrack, uploadISOBMFFTrack } from "./resources/isobmff-track.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, createUnprocessedFile, lookupUnprocessedFileByMd5, processIsobmffFile, uploadUnprocessedFile } from "./resources/unprocessed-file.js";
+import { CreateUnprocessedFilePayload, createUnprocessedFile, createUnprocessedFileFromPath, lookupUnprocessedFileByMd5, processIsobmffFile, uploadUnprocessedFile, uploadUnprocessedReadableStream } from "./resources/unprocessed-file.js";
 import { getIsobmffProcessInfo, getIsobmffProcessProgress } from "./resources/process-isobmff.js";
 import { Client } from "./client.js";
 export {
@@ -17,6 +17,7 @@ export {
   CreateRenderPayload,
   CreateTranscriptionPayload,
   CreateUnprocessedFilePayload,
+  TranscribeISOBMFFFilePayload,
   createCaptionFile,
   createISOBMFFFile,
   createISOBMFFTrack,
@@ -25,6 +26,7 @@ export {
   createTranscription,
   createURLToken,
   createUnprocessedFile,
+  createUnprocessedFileFromPath,
   getISOBMFFFileTranscription,
   getIsobmffProcessInfo,
   getIsobmffProcessProgress,
@@ -36,10 +38,12 @@ export {
   lookupRenderByMd5,
   lookupUnprocessedFileByMd5,
   processIsobmffFile,
+  transcribeISOBMFFFile,
   uploadCaptionFile,
   uploadFragmentIndex,
   uploadISOBMFFTrack,
   uploadImageFile,
   uploadRender,
-  uploadUnprocessedFile
+  uploadUnprocessedFile,
+  uploadUnprocessedReadableStream
 };

package/dist/{resources → api/src/resources}/image-file.js

@@ -1,4 +1,5 @@
 import debug from "debug";
+import "mime";
 import { z } from "zod";
 import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:image-file");
@@ -26,11 +27,11 @@ const createImageFile = async (client, payload) => {
     `Failed to create file ${response.status} ${response.statusText}`
   );
 };
-const uploadImageFile = (client, fileId, fileStream, fileSize) => {
-  log("Uploading image file", fileId);
+const uploadImageFile = (client, uploadDetails, fileStream) => {
+  log("Uploading image file", uploadDetails.id);
   return uploadChunks(client, {
-    url: `/api/v1/image_files/${fileId}/upload`,
-    fileSize,
+    url: `/api/v1/image_files/${uploadDetails.id}/upload`,
+    fileSize: uploadDetails.byte_size,
     fileStream,
     maxSize: MAX_IMAGE_SIZE
   });

package/dist/{resources → api/src/resources}/isobmff-file.js

@@ -73,10 +73,30 @@ const getISOBMFFFileTranscription = async (client, id) => {
     `Failed to get isobmff file transcription ${id} ${response.status} ${response.statusText}`
   );
 };
+const TranscribeISOBMFFFilePayload = z.object({
+  trackId: z.string().optional()
+});
+const transcribeISOBMFFFile = async (client, id, payload = {}) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${id}/transcribe`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to transcribe isobmff file ${id} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateISOBMFFFilePayload,
+  TranscribeISOBMFFFilePayload,
   createISOBMFFFile,
   getISOBMFFFileTranscription,
   lookupISOBMFFFileByMd5,
+  transcribeISOBMFFFile,
   uploadFragmentIndex
 };

package/dist/{resources → api/src/resources}/unprocessed-file.js

@@ -9,6 +9,27 @@ const CreateUnprocessedFilePayload = z.object({
   byte_size: z.number().int().max(MAX_FILE_SIZE)
 });
 z.object({});
+const createUnprocessedFileFromPath = async (client, path) => {
+  const [{ stat }, { basename }, { md5FilePath }] = await Promise.all([
+    import("node:fs/promises"),
+    import("node:path"),
+    import("@editframe/assets")
+  ]).catch((error) => {
+    console.error("Error importing modules", error);
+    console.error(
+      "This is likely because you are bundling for the browser. createUnprocessedFileFromPath can only be run in environments that support importing `node:path`"
+    );
+    throw error;
+  });
+  const fileInfo = await stat(path);
+  const byte_size = fileInfo.size;
+  const md5 = await md5FilePath(path);
+  return createUnprocessedFile(client, {
+    md5,
+    filename: basename(path),
+    byte_size
+  });
+};
 const createUnprocessedFile = async (client, payload) => {
   log("Creating an unprocessed file", payload);
   CreateUnprocessedFilePayload.parse(payload);
@@ -32,11 +53,21 @@ const createUnprocessedFile = async (client, payload) => {
     `Failed to create unprocessed file ${response.status} ${response.statusText}`
   );
 };
-const uploadUnprocessedFile = (client, fileId, fileStream, fileSize) => {
-  log("Uploading unprocessed file", fileId);
+const uploadUnprocessedFile = async (client, uploadDetails, path) => {
+  const { createReadStream } = await import("node:fs");
+  const readStream = createReadStream(path);
+  const { createReadableStreamFromReadable } = await import("../../../cli/src/utils/createReadableStreamFromReadable.js");
+  return uploadUnprocessedReadableStream(
+    client,
+    uploadDetails,
+    createReadableStreamFromReadable(readStream)
+  );
+};
+const uploadUnprocessedReadableStream = (client, uploadDetails, fileStream) => {
+  log("Uploading unprocessed file", uploadDetails.id);
   return uploadChunks(client, {
-    url: `/api/v1/unprocessed_files/${fileId}/upload`,
-    fileSize,
+    url: `/api/v1/unprocessed_files/${uploadDetails.id}/upload`,
+    fileSize: uploadDetails.byte_size,
     fileStream,
     maxSize: MAX_FILE_SIZE
   });
@@ -58,9 +89,9 @@ const lookupUnprocessedFileByMd5 = async (client, md5) => {
     `Failed to lookup unprocessed file by md5 ${md5} ${response.status} ${response.statusText}`
   );
 };
-const processIsobmffFile = async (client, unprocessedFileId) => {
+const processIsobmffFile = async (client, id) => {
   const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${unprocessedFileId}/isobmff`,
+    `/api/v1/unprocessed_files/${id}/isobmff`,
     {
       method: "POST"
     }
@@ -69,13 +100,15 @@ const processIsobmffFile = async (client, unprocessedFileId) => {
     return await response.json();
   }
   throw new Error(
-    `Failed to process isobmff file ${response.status} ${response.statusText}`
+    `Failed to process isobmff file ${id} ${response.status} ${response.statusText}`
   );
 };
 export {
   CreateUnprocessedFilePayload,
   createUnprocessedFile,
+  createUnprocessedFileFromPath,
   lookupUnprocessedFileByMd5,
   processIsobmffFile,
-  uploadUnprocessedFile
+  uploadUnprocessedFile,
+  uploadUnprocessedReadableStream
 };

package/dist/cli/src/utils/createReadableStreamFromReadable.js

@@ -0,0 +1,82 @@
+import { Stream } from "node:stream";
+const createReadableStreamFromReadable = (source) => {
+  const pump = new StreamPump(source);
+  const stream = new ReadableStream(pump, pump);
+  return stream;
+};
+class StreamPump {
+  constructor(stream) {
+    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
+    this.accumalatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+  size(chunk) {
+    return chunk?.byteLength || 0;
+  }
+  start(controller) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  }
+  pull() {
+    this.resume();
+  }
+  cancel(reason) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  }
+  enqueue(chunk) {
+    if (this.controller) {
+      try {
+        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (error) {
+        this.controller.error(
+          new Error(
+            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"
+          )
+        );
+        this.cancel();
+      }
+    }
+  }
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      delete this.controller;
+    }
+  }
+  error(error) {
+    if (this.controller) {
+      this.controller.error(error);
+      delete this.controller;
+    }
+  }
+}
+export {
+  createReadableStreamFromReadable
+};

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 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 { createISOBMFFFile, CreateISOBMFFFilePayload, type CreateISOBMFFFileResult, uploadFragmentIndex, type LookupISOBMFFFileByMd5Result, lookupISOBMFFFileByMd5, type GetISOBMFFFileTranscriptionResult, getISOBMFFFileTranscription, type TranscribeISOBMFFFileResult, transcribeISOBMFFFile, TranscribeISOBMFFFilePayload, } from './resources/isobmff-file.ts';
 export { createISOBMFFTrack, CreateISOBMFFTrackPayload, type CreateISOBMFFTrackResult, uploadISOBMFFTrack, } from './resources/isobmff-track.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, uploadUnprocessedFile, type LookupUnprocessedFileByMd5Result, lookupUnprocessedFileByMd5, processIsobmffFile, type ProcessIsobmffFileResult, } from './resources/unprocessed-file.ts';
+export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, uploadUnprocessedReadableStream, type LookupUnprocessedFileByMd5Result, lookupUnprocessedFileByMd5, processIsobmffFile, type ProcessIsobmffFileResult, createUnprocessedFileFromPath, uploadUnprocessedFile, } from './resources/unprocessed-file.ts';
 export { getIsobmffProcessInfo, getIsobmffProcessProgress, type IsobmffProcessInfoResult, } from './resources/process-isobmff.ts';
 export { Client } from './client.ts';

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

@@ -11,27 +11,33 @@ export declare const CreateImageFilePayload: z.ZodObject<{
     md5: string;
     filename: string;
     byte_size: number;
-    height: number;
     width: number;
+    height: number;
     mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
 }, {
     md5: string;
     filename: string;
     byte_size: number;
-    height: number;
     width: number;
+    height: number;
     mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
 }>;
 export interface CreateImageFileResult {
     complete: boolean | null;
+    byte_size: number;
     id: string;
     md5: string;
 }
 export interface LookupImageFileByMd5Result {
     complete: boolean | null;
+    byte_size: number;
     id: string;
     md5: string;
 }
+export declare const createImageFileFromPath: (client: Client, path: string) => Promise<CreateImageFileResult>;
 export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult>;
-export declare const uploadImageFile: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const uploadImageFile: (client: Client, uploadDetails: {
+    id: string;
+    byte_size: number;
+}, fileStream: ReadableStream) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
 export declare const lookupImageFileByMd5: (client: Client, md5: string) => Promise<LookupImageFileByMd5Result | null>;

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

@@ -33,3 +33,16 @@ export declare const createISOBMFFFile: (client: Client, payload: z.infer<typeof
 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>;
+export declare const TranscribeISOBMFFFilePayload: z.ZodObject<{
+    trackId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    trackId?: string | undefined;
+}, {
+    trackId?: string | undefined;
+}>;
+export interface TranscribeISOBMFFFileResult {
+    id: string;
+    file_id: string;
+    track_id: number;
+}
+export declare const transcribeISOBMFFFile: (client: Client, id: string, payload?: z.infer<typeof TranscribeISOBMFFFilePayload>) => Promise<TranscribeISOBMFFFileResult>;

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

@@ -159,8 +159,6 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         bit_rate: z.ZodOptional<z.ZodString>;
         disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -171,6 +169,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;
@@ -179,8 +179,6 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         duration?: number | undefined;
         bit_rate?: string | undefined;
     }, {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -191,6 +189,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;
@@ -209,8 +209,6 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     file_id: string;
     track_id: number;
     probe_info: {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -221,6 +219,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;
@@ -237,8 +237,6 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     file_id: string;
     track_id: number;
     probe_info: {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -249,6 +247,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;

package/dist/resources/renders.d.ts

@@ -10,20 +10,20 @@ export declare const CreateRenderPayload: z.ZodObject<{
     strategy: z.ZodEnum<["v1", "v2"]>;
 }, "strip", z.ZodTypeAny, {
     md5: string;
-    height: number;
     width: number;
+    height: number;
+    strategy: "v1" | "v2";
     duration_ms: number;
     fps: number;
     work_slice_ms: number;
-    strategy: "v1" | "v2";
 }, {
     md5: string;
-    height: number;
     width: number;
+    height: number;
+    strategy: "v1" | "v2";
     duration_ms: number;
     fps: number;
     work_slice_ms: number;
-    strategy: "v1" | "v2";
 }>;
 export interface CreateRenderResult {
     id: string;

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

@@ -21,6 +21,7 @@ interface UnprocessedFile {
     id: string;
     md5: string;
 }
+type UnprocessedFileUploadDetails = Pick<UnprocessedFile, "id" | "byte_size">;
 export interface CreateUnprocessedFileResult extends UnprocessedFile {
 }
 export interface LookupUnprocessedFileByMd5Result extends UnprocessedFile {
@@ -30,8 +31,10 @@ export interface UpdateUnprocessedFileResult extends UnprocessedFile {
 export interface ProcessIsobmffFileResult {
     id: string;
 }
+export declare const createUnprocessedFileFromPath: (client: Client, path: string) => Promise<CreateUnprocessedFileResult>;
 export declare const createUnprocessedFile: (client: Client, payload: z.infer<typeof CreateUnprocessedFilePayload>) => Promise<CreateUnprocessedFileResult>;
-export declare const uploadUnprocessedFile: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const uploadUnprocessedFile: (client: Client, uploadDetails: UnprocessedFileUploadDetails, path: string) => Promise<import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>>;
+export declare const uploadUnprocessedReadableStream: (client: Client, uploadDetails: UnprocessedFileUploadDetails, fileStream: ReadableStream) => 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 declare const processIsobmffFile: (client: Client, id: string) => Promise<ProcessIsobmffFileResult>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/api",
-  "version": "0.12.0-beta.3",
+  "version": "0.12.0-beta.8",
   "description": "API functions for EditFrame",
   "exports": {
     ".": {
@@ -29,7 +29,7 @@
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/assets": "0.12.0-beta.3",
+    "@editframe/assets": "0.12.0-beta.8",
     "debug": "^4.3.5",
     "jsonwebtoken": "^9.0.2",
     "node-fetch": "^3.3.2",

package/src/resources/image-file.test.ts

@@ -97,9 +97,8 @@ describe("ImageFile", () => {
       await expect(
         uploadImageFile(
           client,
-          "test-file-id",
+          { id: "test-file-id", byte_size: 1024 * 1024 * 17 },
           webReadableFromBuffers(Buffer.from("test")),
-          1024 * 1024 * 17,
         ).whenUploaded(),
       ).rejects.toThrowError(
         "File size 17825792 bytes exceeds limit 16777216 bytes",
@@ -118,9 +117,8 @@ describe("ImageFile", () => {
       await expect(
         uploadImageFile(
           client,
-          "test-file-id",
+          { id: "test-file-id", byte_size: 4 },
           webReadableFromBuffers(Buffer.from("test")),
-          4,
         ).whenUploaded(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/image_files/test-file-id/upload 500 Internal Server Error",
@@ -139,9 +137,8 @@ describe("ImageFile", () => {
       await expect(
         uploadImageFile(
           client,
-          "test-file-id",
+          { id: "test-file-id", byte_size: 4 },
           webReadableFromBuffers(Buffer.from("test")),
-          4,
         ).whenUploaded(),
       ).resolves.toEqual([
         { type: "progress", progress: 0 },

package/src/resources/image-file.ts

@@ -1,4 +1,5 @@
 import debug from "debug";
+import mime from "mime";
 import { z } from "zod";
 
 import type { Client } from "../client.ts";
@@ -19,16 +20,51 @@ export const CreateImageFilePayload = z.object({
 
 export interface CreateImageFileResult {
   complete: boolean | null;
+  byte_size: number;
   id: string;
   md5: string;
 }
 
 export interface LookupImageFileByMd5Result {
   complete: boolean | null;
+  byte_size: number;
   id: string;
   md5: string;
 }
 
+export const createImageFileFromPath = async (client: Client, path: string) => {
+  const [{ stat }, { basename }, { md5FilePath }] = await Promise.all([
+    import("node:fs/promises"),
+    import("node:path"),
+    import("@editframe/assets"),
+  ]).catch((error) => {
+    console.error("Error importing modules", error);
+    console.error(
+      "This is likely because you are bundling for the browser. createImageFileFromPath can only be run in environments that support importing `node:path`",
+    );
+    throw error;
+  });
+
+  const fileInfo = await stat(path);
+
+  const byte_size = fileInfo.size;
+
+  const md5 = await md5FilePath(path);
+
+  const mime_type = mime.getType(path);
+
+  return createImageFile(client, {
+    ...CreateImageFilePayload.parse({
+      md5,
+      height: 0,
+      width: 0,
+      mime_type,
+      filename: basename(path),
+      byte_size,
+    }),
+  });
+};
+
 export const createImageFile = async (
   client: Client,
   payload: z.infer<typeof CreateImageFilePayload>,
@@ -53,15 +89,17 @@ export const createImageFile = async (
 
 export const uploadImageFile = (
   client: Client,
-  fileId: string,
+  uploadDetails: {
+    id: string;
+    byte_size: number;
+  },
   fileStream: ReadableStream,
-  fileSize: number,
 ) => {
-  log("Uploading image file", fileId);
+  log("Uploading image file", uploadDetails.id);
 
   return uploadChunks(client, {
-    url: `/api/v1/image_files/${fileId}/upload`,
-    fileSize,
+    url: `/api/v1/image_files/${uploadDetails.id}/upload`,
+    fileSize: uploadDetails.byte_size,
     fileStream,
     maxSize: MAX_IMAGE_SIZE,
   });

package/src/resources/isobmff-file.ts

@@ -128,3 +128,35 @@ export const getISOBMFFFileTranscription = async (
     `Failed to get isobmff file transcription ${id} ${response.status} ${response.statusText}`,
   );
 };
+
+export const TranscribeISOBMFFFilePayload = z.object({
+  trackId: z.string().optional(),
+});
+
+export interface TranscribeISOBMFFFileResult {
+  id: string;
+  file_id: string;
+  track_id: number;
+}
+
+export const transcribeISOBMFFFile = async (
+  client: Client,
+  id: string,
+  payload: z.infer<typeof TranscribeISOBMFFFilePayload> = {},
+) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/isobmff_files/${id}/transcribe`,
+    {
+      method: "POST",
+      body: JSON.stringify(payload),
+    },
+  );
+
+  if (response.ok) {
+    return (await response.json()) as TranscribeISOBMFFFileResult;
+  }
+
+  throw new Error(
+    `Failed to transcribe isobmff file ${id} ${response.status} ${response.statusText}`,
+  );
+};

package/src/resources/unprocessed-file.test.ts

@@ -8,7 +8,7 @@ import { webReadableFromBuffers } from "../readableFromBuffers.ts";
 import {
   createUnprocessedFile,
   lookupUnprocessedFileByMd5,
-  uploadUnprocessedFile,
+  uploadUnprocessedReadableStream,
 } from "./unprocessed-file.ts";
 
 const server = setupServer();
@@ -96,11 +96,10 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        uploadUnprocessedFile(
+        uploadUnprocessedReadableStream(
           client,
-          "test-file",
+          { id: "test-file", byte_size: 4 },
           webReadableFromBuffers(Buffer.from("test")),
-          4,
         ).whenUploaded(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/unprocessed_files/test-file/upload 500 Internal Server Error",
@@ -117,11 +116,10 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        uploadUnprocessedFile(
+        uploadUnprocessedReadableStream(
           client,
-          "test-file",
+          { id: "test-file", byte_size: 4 },
           webReadableFromBuffers(Buffer.from("test")),
-          4,
         ).whenUploaded(),
       ).resolves.toEqual([
         { type: "progress", progress: 0 },

package/src/resources/unprocessed-file.ts

@@ -24,6 +24,8 @@ interface UnprocessedFile {
   md5: string;
 }
 
+type UnprocessedFileUploadDetails = Pick<UnprocessedFile, "id" | "byte_size">;
+
 export interface CreateUnprocessedFileResult extends UnprocessedFile {}
 
 export interface LookupUnprocessedFileByMd5Result extends UnprocessedFile {}
@@ -34,6 +36,35 @@ export interface ProcessIsobmffFileResult {
   id: string;
 }
 
+export const createUnprocessedFileFromPath = async (
+  client: Client,
+  path: string,
+) => {
+  const [{ stat }, { basename }, { md5FilePath }] = await Promise.all([
+    import("node:fs/promises"),
+    import("node:path"),
+    import("@editframe/assets"),
+  ]).catch((error) => {
+    console.error("Error importing modules", error);
+    console.error(
+      "This is likely because you are bundling for the browser. createUnprocessedFileFromPath can only be run in environments that support importing `node:path`",
+    );
+    throw error;
+  });
+
+  const fileInfo = await stat(path);
+
+  const byte_size = fileInfo.size;
+
+  const md5 = await md5FilePath(path);
+
+  return createUnprocessedFile(client, {
+    md5,
+    filename: basename(path),
+    byte_size,
+  });
+};
+
 export const createUnprocessedFile = async (
   client: Client,
   payload: z.infer<typeof CreateUnprocessedFilePayload>,
@@ -64,17 +95,35 @@ export const createUnprocessedFile = async (
   );
 };
 
-export const uploadUnprocessedFile = (
+export const uploadUnprocessedFile = async (
   client: Client,
-  fileId: string,
+  uploadDetails: UnprocessedFileUploadDetails,
+  path: string,
+) => {
+  const { createReadStream } = await import("node:fs");
+  const readStream = createReadStream(path);
+
+  const { createReadableStreamFromReadable } = await import(
+    "packages/cli/src/utils/createReadableStreamFromReadable.ts"
+  );
+
+  return uploadUnprocessedReadableStream(
+    client,
+    uploadDetails,
+    createReadableStreamFromReadable(readStream),
+  );
+};
+
+export const uploadUnprocessedReadableStream = (
+  client: Client,
+  uploadDetails: UnprocessedFileUploadDetails,
   fileStream: ReadableStream,
-  fileSize: number,
 ) => {
-  log("Uploading unprocessed file", fileId);
+  log("Uploading unprocessed file", uploadDetails.id);
 
   return uploadChunks(client, {
-    url: `/api/v1/unprocessed_files/${fileId}/upload`,
-    fileSize,
+    url: `/api/v1/unprocessed_files/${uploadDetails.id}/upload`,
+    fileSize: uploadDetails.byte_size,
     fileStream,
     maxSize: MAX_FILE_SIZE,
   });
@@ -104,12 +153,9 @@ export const lookupUnprocessedFileByMd5 = async (
   );
 };
 
-export const processIsobmffFile = async (
-  client: Client,
-  unprocessedFileId: LookupUnprocessedFileByMd5Result["id"],
-) => {
+export const processIsobmffFile = async (client: Client, id: string) => {
   const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${unprocessedFileId}/isobmff`,
+    `/api/v1/unprocessed_files/${id}/isobmff`,
     {
       method: "POST",
     },
@@ -120,6 +166,6 @@ export const processIsobmffFile = async (
   }
 
   throw new Error(
-    `Failed to process isobmff file ${response.status} ${response.statusText}`,
+    `Failed to process isobmff file ${id} ${response.status} ${response.statusText}`,
   );
 };