@editframe/api 0.16.8-beta.0 → 0.17.6-beta.0

package/dist/resources/isobmff-track.js

@@ -1,104 +1,95 @@
+import { uploadChunks } from "../uploadChunks.js";
+import { assertTypesMatch } from "../utils/assertTypesMatch.js";
 import debug from "debug";
 import { z } from "zod";
-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().optional(),
-  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().optional(),
-  start_time: z.coerce.number().optional(),
-  duration_ts: z.number(),
-  duration: z.coerce.number(),
-  bit_rate: z.string(),
-  disposition: z.record(z.unknown())
+	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().optional(),
+	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().optional(),
+	start_time: z.coerce.number().optional(),
+	duration_ts: z.number(),
+	duration: z.coerce.number(),
+	bit_rate: z.string(),
+	disposition: z.record(z.unknown())
 });
+assertTypesMatch(true);
 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())
+	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())
 });
+assertTypesMatch(true);
 const log = debug("ef:api:isobmff-track");
 const MAX_TRACK_SIZE = 1024 * 1024 * 1024;
 const AudioTrackPayload = z.object({
-  file_id: z.string(),
-  track_id: z.number().int(),
-  type: z.literal("audio"),
-  probe_info: AudioStreamSchema,
-  duration_ms: z.number().int(),
-  codec_name: z.string(),
-  byte_size: z.number().int().max(MAX_TRACK_SIZE)
+	file_id: z.string(),
+	track_id: z.number().int(),
+	type: z.literal("audio"),
+	probe_info: AudioStreamSchema,
+	duration_ms: z.number().int(),
+	codec_name: z.string(),
+	byte_size: z.number().int().max(MAX_TRACK_SIZE)
 });
+assertTypesMatch(true);
 const VideoTrackPayload = z.object({
-  file_id: z.string(),
-  track_id: z.number().int(),
-  type: z.literal("video"),
-  probe_info: VideoStreamSchema,
-  duration_ms: z.number().int(),
-  codec_name: z.string(),
-  byte_size: z.number().int().max(MAX_TRACK_SIZE)
+	file_id: z.string(),
+	track_id: z.number().int(),
+	type: z.literal("video"),
+	probe_info: VideoStreamSchema,
+	duration_ms: z.number().int(),
+	codec_name: z.string(),
+	byte_size: z.number().int().max(MAX_TRACK_SIZE)
 });
-const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
-  AudioTrackPayload,
-  VideoTrackPayload
-]);
+assertTypesMatch(true);
+const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [AudioTrackPayload, VideoTrackPayload]);
+assertTypesMatch(true);
 const createISOBMFFTrack = async (client, payload) => {
-  log("Creating isobmff track", payload);
-  CreateISOBMFFTrackPayload.parse(payload);
-  const response = await client.authenticatedFetch("/api/v1/isobmff_tracks", {
-    method: "POST",
-    body: JSON.stringify(payload)
-  });
-  log("ISOBMFF track created", response);
-  if (response.ok) {
-    return await response.json();
-  }
-  throw new Error(
-    `Failed to create isobmff track ${response.status} ${response.statusText}`
-  );
+	log("Creating isobmff track", payload);
+	CreateISOBMFFTrackPayload.parse(payload);
+	const response = await client.authenticatedFetch("/api/v1/isobmff_tracks", {
+		method: "POST",
+		body: JSON.stringify(payload)
+	});
+	log("ISOBMFF track created", response);
+	if (response.ok) return await response.json();
+	throw new Error(`Failed to create isobmff track ${response.status} ${response.statusText}`);
 };
 const uploadISOBMFFTrack = (client, fileId, trackId, fileStream, trackSize) => {
-  log("Uploading fragment track", fileId);
-  return uploadChunks(client, {
-    url: `/api/v1/isobmff_tracks/${fileId}/${trackId}/upload`,
-    fileStream,
-    fileSize: trackSize,
-    maxSize: MAX_TRACK_SIZE
-  });
-};
-export {
-  AudioStreamSchema,
-  AudioTrackPayload,
-  CreateISOBMFFTrackPayload,
-  VideoStreamSchema,
-  VideoTrackPayload,
-  createISOBMFFTrack,
-  uploadISOBMFFTrack
+	log("Uploading fragment track", fileId);
+	return uploadChunks(client, {
+		url: `/api/v1/isobmff_tracks/${fileId}/${trackId}/upload`,
+		fileStream,
+		fileSize: trackSize,
+		maxSize: MAX_TRACK_SIZE
+	});
 };
+export { AudioTrackPayload, CreateISOBMFFTrackPayload, VideoTrackPayload, createISOBMFFTrack, uploadISOBMFFTrack };

package/dist/resources/process-isobmff.js

@@ -1,22 +1,11 @@
 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 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
+	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/renders.bundle.js

@@ -1,46 +1,37 @@
+import { createReadableStreamFromReadable } from "../utils/createReadableStreamFromReadable.js";
 import path from "node:path";
 import { PassThrough } from "node:stream";
 import react from "@vitejs/plugin-react";
+import { build } from "rolldown-vite";
 import * as tar from "tar";
-import { build } from "vite";
 import { viteSingleFile } from "vite-plugin-singlefile";
 import tsconfigPathsPlugin from "vite-tsconfig-paths";
 import { randomUUID } from "node:crypto";
-import { createReadableStreamFromReadable } from "../utils/createReadableStreamFromReadable.js";
 const bundleRender = async (options) => {
-  const outDir = path.join(process.cwd(), "renders", randomUUID());
-  await build({
-    root: options.root,
-    define: {
-      RENDER_DATA: JSON.stringify(options.renderData)
-    },
-    build: {
-      outDir,
-      rollupOptions: {
-        input: path.resolve(options.root, "index.html")
-      }
-    },
-    plugins: [
-      tsconfigPathsPlugin(),
-      react({
-        include: "**/*.{jsx,js,tsx,ts}",
-        jsxRuntime: "automatic"
-      }),
-      viteSingleFile()
-    ]
-  });
-  const tarStream = tar.create(
-    {
-      gzip: true,
-      cwd: outDir
-    },
-    ["."]
-  );
-  const passthrough = new PassThrough();
-  tarStream.pipe(passthrough);
-  const tarReadStream = createReadableStreamFromReadable(passthrough);
-  return tarReadStream;
-};
-export {
-  bundleRender
+	const outDir = path.join(process.cwd(), "renders", randomUUID());
+	await build({
+		root: options.root,
+		define: { RENDER_DATA: JSON.stringify(options.renderData) },
+		build: {
+			outDir,
+			rollupOptions: { input: path.resolve(options.root, "index.html") }
+		},
+		plugins: [
+			tsconfigPathsPlugin(),
+			react({
+				include: "**/*.{jsx,js,tsx,ts}",
+				jsxRuntime: "automatic"
+			}),
+			viteSingleFile()
+		]
+	});
+	const tarStream = tar.create({
+		gzip: true,
+		cwd: outDir
+	}, ["."]);
+	const passthrough = new PassThrough();
+	tarStream.pipe(passthrough);
+	const tarReadStream = createReadableStreamFromReadable(passthrough);
+	return tarReadStream;
 };
+export { bundleRender };

package/dist/resources/renders.js

@@ -1,197 +1,139 @@
+import { assertTypesMatch } from "../utils/assertTypesMatch.js";
+import { CompletionIterator } from "../ProgressIterator.js";
 import debug from "debug";
 import { z } from "zod";
-import { CompletionIterator } from "../ProgressIterator.js";
 const log = debug("ef:api:renders");
-const H264Configuration = z.object({
-  codec: z.literal("h264")
-});
-const AACConfiguration = z.object({
-  codec: z.literal("aac")
-});
+const H264Configuration = z.object({ codec: z.literal("h264") });
+const AACConfiguration = z.object({ codec: z.literal("aac") });
 const MP4Configuration = z.object({
-  container: z.literal("mp4"),
-  video: H264Configuration,
-  audio: AACConfiguration
+	container: z.literal("mp4"),
+	video: H264Configuration,
+	audio: AACConfiguration
 });
 const JpegConfiguration = z.object({
-  container: z.literal("jpeg"),
-  quality: z.number().int().min(1).max(100).default(80).optional()
+	container: z.literal("jpeg"),
+	quality: z.number().int().min(1).max(100).default(80).optional()
 });
 const PngConfiguration = z.object({
-  container: z.literal("png"),
-  compression: z.number().int().min(1).max(100).default(80).optional(),
-  transparency: z.boolean().default(false).optional()
+	container: z.literal("png"),
+	compression: z.number().int().min(1).max(100).default(80).optional(),
+	transparency: z.boolean().default(false).optional()
 });
 const WebpConfiguration = z.object({
-  container: z.literal("webp"),
-  quality: z.number().int().min(1).max(100).default(80).optional(),
-  compression: z.number().int().min(0).max(6).default(4).optional(),
-  transparency: z.boolean().default(false).optional()
+	container: z.literal("webp"),
+	quality: z.number().int().min(1).max(100).default(80).optional(),
+	compression: z.number().int().min(0).max(6).default(4).optional(),
+	transparency: z.boolean().default(false).optional()
 });
 const RenderOutputConfiguration = z.discriminatedUnion("container", [
-  MP4Configuration,
-  JpegConfiguration,
-  PngConfiguration,
-  WebpConfiguration
+	MP4Configuration,
+	JpegConfiguration,
+	PngConfiguration,
+	WebpConfiguration
 ]);
 const CreateRenderPayload = z.object({
-  md5: z.string().optional(),
-  fps: z.number().int().min(1).max(120).default(30).optional(),
-  width: z.number().int().min(2).optional(),
-  height: z.number().int().min(2).optional(),
-  work_slice_ms: z.number().int().min(1e3).max(1e4).default(4e3).optional(),
-  html: z.string().optional(),
-  metadata: z.record(z.string(), z.string()).optional(),
-  duration_ms: z.number().int().optional(),
-  strategy: z.enum(["v1"]).default("v1").optional(),
-  output: RenderOutputConfiguration.default({
-    container: "mp4",
-    video: {
-      codec: "h264"
-    },
-    audio: {
-      codec: "aac"
-    }
-  }).optional()
+	md5: z.string().optional(),
+	fps: z.number().int().min(1).max(120).default(30).optional(),
+	width: z.number().int().min(2).optional(),
+	height: z.number().int().min(2).optional(),
+	work_slice_ms: z.number().int().min(1e3).max(1e4).default(4e3).optional(),
+	html: z.string().optional(),
+	metadata: z.record(z.string(), z.string()).optional(),
+	duration_ms: z.number().int().optional(),
+	strategy: z.enum(["v1"]).default("v1").optional(),
+	output: RenderOutputConfiguration.default({
+		container: "mp4",
+		video: { codec: "h264" },
+		audio: { codec: "aac" }
+	}).optional()
 });
-CreateRenderPayload.extend({
-  output: RenderOutputConfiguration
-});
-class OutputConfiguration {
-  constructor(output) {
-    this.output = output;
-  }
-  static parse(input) {
-    const output = RenderOutputConfiguration.parse(
-      input ?? {
-        container: "mp4",
-        video: {
-          codec: "h264"
-        },
-        audio: {
-          codec: "aac"
-        }
-      }
-    );
-    return new OutputConfiguration(output);
-  }
-  get isStill() {
-    return this.output.container === "jpeg" || this.output.container === "png" || this.output.container === "webp";
-  }
-  get isVideo() {
-    return this.output.container === "mp4";
-  }
-  get fileExtension() {
-    return this.output.container;
-  }
-  get contentType() {
-    if (this.isStill) {
-      return `image/${this.fileExtension}`;
-    }
-    return `video/${this.fileExtension}`;
-  }
-  get container() {
-    return this.output.container;
-  }
-  get jpegConfig() {
-    return this.output.container === "jpeg" ? this.output : null;
-  }
-  get pngConfig() {
-    return this.output.container === "png" ? this.output : null;
-  }
-  get webpConfig() {
-    return this.output.container === "webp" ? this.output : null;
-  }
-  get mp4Config() {
-    return this.output.container === "mp4" ? this.output : null;
-  }
-}
+const CreateRenderPayloadWithOutput = CreateRenderPayload.extend({ output: RenderOutputConfiguration });
+var OutputConfiguration = class OutputConfiguration {
+	static parse(input) {
+		const output = RenderOutputConfiguration.parse(input ?? {
+			container: "mp4",
+			video: { codec: "h264" },
+			audio: { codec: "aac" }
+		});
+		return new OutputConfiguration(output);
+	}
+	constructor(output) {
+		this.output = output;
+	}
+	get isStill() {
+		return this.output.container === "jpeg" || this.output.container === "png" || this.output.container === "webp";
+	}
+	get isVideo() {
+		return this.output.container === "mp4";
+	}
+	get fileExtension() {
+		return this.output.container;
+	}
+	get contentType() {
+		if (this.isStill) return `image/${this.fileExtension}`;
+		return `video/${this.fileExtension}`;
+	}
+	get container() {
+		return this.output.container;
+	}
+	get jpegConfig() {
+		return this.output.container === "jpeg" ? this.output : null;
+	}
+	get pngConfig() {
+		return this.output.container === "png" ? this.output : null;
+	}
+	get webpConfig() {
+		return this.output.container === "webp" ? this.output : null;
+	}
+	get mp4Config() {
+		return this.output.container === "mp4" ? this.output : null;
+	}
+};
+assertTypesMatch(true);
 const createRender = async (client, payload) => {
-  log("Creating render", payload);
-  payload.strategy ??= "v1";
-  payload.work_slice_ms ??= 4e3;
-  payload.output ??= {
-    container: "mp4",
-    video: {
-      codec: "h264"
-    },
-    audio: {
-      codec: "aac"
-    }
-  };
-  const response = await client.authenticatedFetch("/api/v1/renders", {
-    method: "POST",
-    body: JSON.stringify(payload)
-  });
-  log("Render created", response);
-  if (response.ok) {
-    return await response.json();
-  }
-  throw new Error(
-    `Failed to create render ${response.status} ${response.statusText} ${await response.text()}`
-  );
+	log("Creating render", payload);
+	payload.strategy ??= "v1";
+	payload.work_slice_ms ??= 4e3;
+	payload.output ??= {
+		container: "mp4",
+		video: { codec: "h264" },
+		audio: { codec: "aac" }
+	};
+	const response = await client.authenticatedFetch("/api/v1/renders", {
+		method: "POST",
+		body: JSON.stringify(payload)
+	});
+	log("Render created", response);
+	if (response.ok) return await response.json();
+	throw new Error(`Failed to create render ${response.status} ${response.statusText} ${await response.text()}`);
 };
 const uploadRender = async (client, renderId, fileStream) => {
-  log("Uploading render", renderId);
-  const response = await client.authenticatedFetch(
-    `/api/v1/renders/${renderId}/upload`,
-    {
-      method: "POST",
-      body: fileStream,
-      duplex: "half"
-    }
-  );
-  if (response.ok) {
-    return response.json();
-  }
-  throw new Error(
-    `Failed to upload render ${response.status} ${response.statusText}`
-  );
+	log("Uploading render", renderId);
+	const response = await client.authenticatedFetch(`/api/v1/renders/${renderId}/upload`, {
+		method: "POST",
+		body: fileStream,
+		duplex: "half"
+	});
+	if (response.ok) return response.json();
+	throw new Error(`Failed to upload render ${response.status} ${response.statusText}`);
 };
 const getRenderInfo = async (client, id) => {
-  const response = await client.authenticatedFetch(`/api/v1/renders/${id}`);
-  return response.json();
+	const response = await client.authenticatedFetch(`/api/v1/renders/${id}`);
+	return response.json();
 };
 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}`
-  );
+	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}`);
 };
 const getRenderProgress = async (client, id) => {
-  const eventSource = await client.authenticatedEventSource(
-    `/api/v1/renders/${id}/progress`
-  );
-  return new CompletionIterator(eventSource);
+	const eventSource = await client.authenticatedEventSource(`/api/v1/renders/${id}/progress`);
+	return new CompletionIterator(eventSource);
 };
 const downloadRender = async (client, id) => {
-  const response = await client.authenticatedFetch(`/api/v1/renders/${id}.mp4`);
-  if (response.ok) {
-    return response;
-  }
-  throw new Error(
-    `Failed to download render ${id} ${response.status} ${response.statusText}`
-  );
-};
-export {
-  CreateRenderPayload,
-  OutputConfiguration,
-  RenderOutputConfiguration,
-  createRender,
-  downloadRender,
-  getRenderInfo,
-  getRenderProgress,
-  lookupRenderByMd5,
-  uploadRender
+	const response = await client.authenticatedFetch(`/api/v1/renders/${id}.mp4`);
+	if (response.ok) return response;
+	throw new Error(`Failed to download render ${id} ${response.status} ${response.statusText}`);
 };
+export { CreateRenderPayload, OutputConfiguration, RenderOutputConfiguration, createRender, downloadRender, getRenderInfo, getRenderProgress, lookupRenderByMd5, uploadRender };

package/dist/resources/transcriptions.js

@@ -1,45 +1,28 @@
+import { CompletionIterator } from "../ProgressIterator.js";
 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()
+	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}`
-  );
+	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 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
+	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 };