@editframe/vite-plugin 0.5.0-beta.9 → 0.6.0-beta.10

package/dist/packages/vite-plugin/forbidRelativePaths.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const forbidRelativePaths = (req) => {
+  if (req.url?.includes("..")) {
+    throw new Error("Relative paths are forbidden");
+  }
+};
+exports.forbidRelativePaths = forbidRelativePaths;

package/dist/packages/vite-plugin/forbidRelativePaths.d.ts

@@ -0,0 +1,3 @@
+import { IncomingMessage } from 'connect';
+
+export declare const forbidRelativePaths: (req: IncomingMessage) => void;

package/dist/packages/vite-plugin/index.cjs

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const debug = require("debug");
+const assets = require("@editframe/assets");
+const forbidRelativePaths = require("./forbidRelativePaths.cjs");
+const sendTaskResult = require("./sendTaskResult.cjs");
+const vitePluginEditframe = (options) => {
+  return {
+    name: "vite-plugin-editframe",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        const log = debug("@ef:vite-plugin");
+        if (req.url?.startsWith("/@ef")) {
+          forbidRelativePaths.forbidRelativePaths(req);
+        } else {
+          return next();
+        }
+        log(`Handling ${req.url}`);
+        const requestPath = req.url.replace(/^\/@ef-[^\/]+\//, "");
+        const assetPath = requestPath.replace(/\?.*$/, "");
+        const absolutePath = path.join(options.root, assetPath).replace("dist/", "src/");
+        options.cacheRoot = options.cacheRoot.replace("dist/", "src/");
+        const efPrefix = req.url.split("/")[1];
+        switch (efPrefix) {
+          case "@ef-asset": {
+            if (req.method !== "HEAD") {
+              res.writeHead(405, { Allow: "HEAD" });
+              res.end();
+            }
+            assets.md5FilePath(absolutePath).then((md5) => {
+              res.writeHead(200, {
+                etag: md5
+              });
+              res.end();
+            }).catch(next);
+            break;
+          }
+          case "@ef-track-fragment-index": {
+            log(`Serving track fragment index for ${absolutePath}`);
+            assets.generateTrackFragmentIndex(options.cacheRoot, absolutePath).then((taskResult) => sendTaskResult.sendTaskResult(req, res, taskResult)).catch(next);
+            break;
+          }
+          case "@ef-track": {
+            log(`Serving track for ${absolutePath}`);
+            assets.generateTrack(options.cacheRoot, absolutePath, req.url).then((taskResult) => sendTaskResult.sendTaskResult(req, res, taskResult)).catch(next);
+            break;
+          }
+          case "@ef-captions":
+            log(`Serving captions for ${absolutePath}`);
+            assets.findOrCreateCaptions(options.cacheRoot, absolutePath).then((taskResult) => sendTaskResult.sendTaskResult(req, res, taskResult)).catch(next);
+            break;
+          case "@ef-image":
+            log(`Serving image file ${absolutePath}`);
+            assets.cacheImage(options.cacheRoot, absolutePath).then((taskResult) => sendTaskResult.sendTaskResult(req, res, taskResult)).catch(next);
+            break;
+          default:
+            log(`Unknown asset type ${efPrefix}`);
+            break;
+        }
+      });
+    }
+  };
+};
+exports.vitePluginEditframe = vitePluginEditframe;

package/dist/packages/vite-plugin/index.d.ts

@@ -0,0 +1,9 @@
+interface VitePluginEditframeOptions {
+    root: string;
+    cacheRoot: string;
+}
+export declare const vitePluginEditframe: (options: VitePluginEditframeOptions) => {
+    name: string;
+    configureServer(this: void, server: import('vite').ViteDevServer): void;
+};
+export {};

package/dist/packages/vite-plugin/{src/vite-plugin-editframe.mjs → index.js}

@@ -1,12 +1,8 @@
-import path from "path";
+import path from "node:path";
 import debug from "debug";
-import { findOrCreateCaptions } from "../../../lib/assets/tasks/findOrCreateCaptions.mjs";
-import { generateTrackFragmentIndex } from "../../../lib/assets/tasks/generateTrackFragmentIndex.mjs";
-import { generateTrack } from "../../../lib/assets/tasks/generateTrack.mjs";
-import { cacheImage } from "../../../lib/assets/tasks/cacheImage.mjs";
-import { md5FilePath } from "../../../lib/assets/md5.mjs";
-import { forbidRelativePaths } from "./forbidRelativePaths.mjs";
-import { sendTaskResult } from "./sendTaskResult.mjs";
+import { cacheImage, findOrCreateCaptions, generateTrack, generateTrackFragmentIndex, md5FilePath } from "@editframe/assets";
+import { forbidRelativePaths } from "./forbidRelativePaths.js";
+import { sendTaskResult } from "./sendTaskResult.js";
 const vitePluginEditframe = (options) => {
   return {
     name: "vite-plugin-editframe",
@@ -19,7 +15,7 @@ const vitePluginEditframe = (options) => {
           return next();
         }
         log(`Handling ${req.url}`);
-        const requestPath = req.url.replace(new RegExp("^/@ef-[^/]+/"), "");
+        const requestPath = req.url.replace(/^\/@ef-[^\/]+\//, "");
         const assetPath = requestPath.replace(/\?.*$/, "");
         const absolutePath = path.join(options.root, assetPath).replace("dist/", "src/");
         options.cacheRoot = options.cacheRoot.replace("dist/", "src/");

package/dist/packages/vite-plugin/sendTaskResult.cjs

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_fs = require("node:fs");
+const mime = require("mime");
+const debug = require("debug");
+const sendTaskResult = (req, res, taskResult) => {
+  const { cachePath, md5Sum } = taskResult;
+  const filePath = cachePath;
+  const headers = {
+    etag: md5Sum
+  };
+  const log = debug("@ef:sendfile");
+  try {
+    log(`Sending file ${filePath}`);
+    const stats = node_fs.statSync(filePath);
+    if (req.headers.range) {
+      const [x, y] = req.headers.range.replace("bytes=", "").split("-");
+      let end = Number.parseInt(y ?? "0", 10) || stats.size - 1;
+      const start = Number.parseInt(x ?? "0", 10) || 0;
+      if (end >= stats.size) {
+        end = stats.size - 1;
+      }
+      if (start >= stats.size) {
+        log("Range start is greater than file size");
+        res.setHeader("Content-Range", `bytes */${stats.size}`);
+        res.statusCode = 416;
+        return res.end();
+      }
+      res.writeHead(206, {
+        ...headers,
+        "Content-Type": mime.getType(filePath) || "text/plain",
+        "Content-Range": `bytes ${start}-${end}/${stats.size}`,
+        "Content-Length": end - start + 1,
+        "Accept-Ranges": "bytes"
+      });
+      log(`Sending ${filePath} range ${start}-${end}/${stats.size}`);
+      const readStream = node_fs.createReadStream(filePath, { start, end });
+      readStream.pipe(res);
+    } else {
+      res.writeHead(200, {
+        ...headers,
+        "Content-Type": mime.getType(filePath) || "text/plain",
+        "Contetn-Length": stats.size
+      });
+      log(`Sending ${filePath}`);
+      const readStream = node_fs.createReadStream(filePath);
+      readStream.pipe(res);
+    }
+  } catch (error) {
+    log("Error sending file", error);
+    console.error(error);
+  }
+};
+exports.sendTaskResult = sendTaskResult;

package/dist/packages/vite-plugin/sendTaskResult.d.ts

@@ -0,0 +1,5 @@
+import { ServerResponse } from 'node:http';
+import { IncomingMessage } from 'connect';
+import { TaskResult } from '../../assets';
+
+export declare const sendTaskResult: (req: IncomingMessage, res: ServerResponse<IncomingMessage>, taskResult: TaskResult) => ServerResponse<IncomingMessage> | undefined;

package/dist/packages/vite-plugin/{src/sendTaskResult.mjs → sendTaskResult.js}

@@ -1,4 +1,4 @@
-import { statSync, createReadStream } from "fs";
+import { statSync, createReadStream } from "node:fs";
 import mime from "mime";
 import debug from "debug";
 const sendTaskResult = (req, res, taskResult) => {
@@ -12,9 +12,9 @@ const sendTaskResult = (req, res, taskResult) => {
     log(`Sending file ${filePath}`);
     const stats = statSync(filePath);
     if (req.headers.range) {
-      let [x, y] = req.headers.range.replace("bytes=", "").split("-");
-      let end = parseInt(y ?? "0", 10) || stats.size - 1;
-      let start = parseInt(x ?? "0", 10) || 0;
+      const [x, y] = req.headers.range.replace("bytes=", "").split("-");
+      let end = Number.parseInt(y ?? "0", 10) || stats.size - 1;
+      const start = Number.parseInt(x ?? "0", 10) || 0;
       if (end >= stats.size) {
         end = stats.size - 1;
       }

package/package.json

@@ -1,23 +1,34 @@
 {
   "name": "@editframe/vite-plugin",
-  "version": "0.5.0-beta.9",
+  "version": "0.6.0-beta.10",
   "description": "Editframe vite plugin",
   "exports": {
-    ".": "./dist/packages/vite-plugin/src/vite-plugin-editframe.mjs"
+    ".": {
+      "import": "./dist/packages/vite-plugin/index.js",
+      "require": "./dist/packages/vite-plugin/index.cjs"
+    }
   },
+  "types": "./dist/packages/vite-plugin/index.d.ts",
   "scripts": {
-    "build": "vite build"
+    "typecheck": "tsc --noEmit --emitDeclarationOnly false",
+    "build": "vite build",
+    "build:watch": "vite build --watch"
   },
+  "type": "module",
   "author": "",
   "license": "UNLICENSED",
   "dependencies": {
+    "@editframe/assets": "0.6.0-beta.10",
     "debug": "^4.3.4",
     "mime": "^4.0.3",
     "node-html-parser": "^6.1.13",
     "vite": "^5.2.11"
   },
   "devDependencies": {
+    "@types/dom-webcodecs": "^0.1.11",
+    "@types/node": "^20.14.9",
     "connect": "^3.7.0",
+    "vite-plugin-dts": "^3.9.1",
     "vite-tsconfig-paths": "^4.3.2"
   }
 }

package/dist/lib/assets/Probe.mjs

@@ -1,176 +0,0 @@
-import { spawn } from "child_process";
-import { execPromise } from "../util/execPromise.mjs";
-import * as z from "zod";
-import { createReadStream } from "fs";
-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 ProbeFormatSchema = z.object({
-  filename: z.string(),
-  nb_streams: z.number(),
-  nb_programs: z.number(),
-  format_name: z.string(),
-  format_long_name: z.string(),
-  start_time: z.string().optional(),
-  duration: z.string().optional(),
-  size: z.string(),
-  bit_rate: z.string().optional(),
-  probe_score: z.number()
-});
-const StreamSchema = z.discriminatedUnion("codec_type", [
-  AudioStreamSchema,
-  VideoStreamSchema
-]);
-const ProbeSchema = z.object({
-  streams: z.array(StreamSchema),
-  format: ProbeFormatSchema
-});
-class Probe {
-  constructor(absolutePath, rawData) {
-    this.absolutePath = absolutePath;
-    this.data = ProbeSchema.parse(rawData);
-  }
-  static async probePath(absolutePath) {
-    const probeResult = await execPromise(
-      `ffprobe -v error -show_format -show_streams -of json ${absolutePath}`
-    );
-    const json = JSON.parse(probeResult.stdout);
-    return new Probe(absolutePath, json);
-  }
-  get audioStreams() {
-    return this.data.streams.filter(
-      (stream) => stream.codec_type === "audio"
-    );
-  }
-  get videoStreams() {
-    return this.data.streams.filter(
-      (stream) => stream.codec_type === "video"
-    );
-  }
-  get streams() {
-    return this.data.streams;
-  }
-  get format() {
-    return this.data.format;
-  }
-  get mustReencodeAudio() {
-    return this.audioStreams.some((stream) => stream.codec_name !== "aac");
-  }
-  get mustReencodeVideo() {
-    return false;
-  }
-  get mustRemux() {
-    return this.format.format_name !== "mp4";
-  }
-  get hasAudio() {
-    return this.audioStreams.length > 0;
-  }
-  get hasVideo() {
-    return this.videoStreams.length > 0;
-  }
-  get isAudioOnly() {
-    return this.audioStreams.length > 0 && this.videoStreams.length === 0;
-  }
-  get isVideoOnly() {
-    return this.audioStreams.length === 0 && this.videoStreams.length > 0;
-  }
-  get mustProcess() {
-    return this.mustReencodeAudio || this.mustReencodeVideo || this.mustRemux;
-  }
-  get ffmpegAudioOptions() {
-    if (!this.hasAudio) {
-      return [];
-    }
-    if (this.mustReencodeAudio) {
-      return [
-        "-c:a",
-        "aac",
-        "-b:a",
-        "192k",
-        "-ar",
-        "48000"
-      ];
-    }
-    return ["-c:a", "copy"];
-  }
-  get ffmpegVideoOptions() {
-    if (!this.hasVideo) {
-      return [];
-    }
-    if (this.mustReencodeVideo) {
-      return [
-        "-c:v",
-        "h264",
-        "-pix_fmt",
-        "yuv420p"
-      ];
-    }
-    return ["-c:v", "copy"];
-  }
-  createConformingReadstream() {
-    if (!this.mustProcess) {
-      return createReadStream(this.absolutePath);
-    }
-    return spawn("ffmpeg", [
-      "-i",
-      this.absolutePath,
-      ...this.ffmpegAudioOptions,
-      ...this.ffmpegVideoOptions,
-      "-f",
-      "mp4",
-      "-frag_duration",
-      "8000000",
-      "-movflags",
-      "frag_keyframe+empty_moov",
-      "pipe:1"
-    ], {
-      stdio: ["ignore", "pipe", "inherit"]
-    }).stdout;
-  }
-}
-export {
-  AudioStreamSchema,
-  Probe,
-  VideoStreamSchema
-};

package/dist/lib/assets/idempotentTask.mjs

@@ -1,57 +0,0 @@
-import { existsSync, createWriteStream } from "fs";
-import path from "path";
-import { md5FilePath } from "./md5.mjs";
-import debug from "debug";
-import { mkdir, writeFile } from "fs/promises";
-import { Readable } from "stream";
-const idempotentTask = ({
-  label,
-  filename,
-  runner
-}) => {
-  const tasks = {};
-  return async (rootDir, absolutePath, ...args) => {
-    const log = debug(`@ef:${label}`);
-    const md5 = await md5FilePath(absolutePath);
-    const cacheDir = path.join(rootDir, ".cache", md5);
-    log(`Cache dir: ${cacheDir}`);
-    await mkdir(cacheDir, { recursive: true });
-    const cachePath = path.join(cacheDir, filename(absolutePath, ...args));
-    const key = cachePath;
-    if (existsSync(cachePath)) {
-      log(`Returning cached @ef:${label} task for ${key}`);
-      return { cachePath, md5Sum: md5 };
-    }
-    const maybeTask = tasks[key];
-    if (maybeTask) {
-      log(`Returning existing @ef:${label} task for ${key}`);
-      await maybeTask;
-      return { cachePath, md5Sum: md5 };
-    }
-    log(`Creating new @ef:${label} task for ${key}`);
-    const task = runner(absolutePath, ...args);
-    tasks[key] = task;
-    log(`Awaiting task for ${key}`);
-    const result = await task;
-    if (result instanceof Readable) {
-      log(`Piping task for ${key} to cache`);
-      const writeStream = createWriteStream(cachePath);
-      result.pipe(writeStream);
-      await new Promise((resolve, reject) => {
-        result.on("error", reject);
-        writeStream.on("error", reject);
-        writeStream.on("finish", resolve);
-      });
-      return { cachePath, md5Sum: md5 };
-    }
-    log(`Writing to ${cachePath}`);
-    await writeFile(cachePath, result);
-    return {
-      md5Sum: md5,
-      cachePath
-    };
-  };
-};
-export {
-  idempotentTask
-};

package/dist/lib/assets/md5.mjs

@@ -1,28 +0,0 @@
-import { createReadStream } from "fs";
-import crypto from "crypto";
-async function md5FilePath(filePath) {
-  const readStream = createReadStream(filePath);
-  return md5ReadStream(readStream);
-}
-function md5ReadStream(readStream) {
-  return new Promise((resolve, reject) => {
-    const hash = crypto.createHash("md5");
-    readStream.on("data", (data) => {
-      hash.update(data);
-    });
-    readStream.on("error", reject);
-    readStream.on("end", () => {
-      resolve(addDashesToUUID(hash.digest("hex")));
-    });
-  });
-}
-function addDashesToUUID(uuidWithoutDashes) {
-  if (uuidWithoutDashes.length !== 32) {
-    throw new Error("Invalid UUID without dashes. Expected 32 characters.");
-  }
-  return uuidWithoutDashes.slice(0, 8) + "-" + uuidWithoutDashes.slice(8, 12) + "-" + uuidWithoutDashes.slice(12, 16) + "-" + uuidWithoutDashes.slice(16, 20) + "-" + uuidWithoutDashes.slice(20, 32);
-}
-export {
-  md5FilePath,
-  md5ReadStream
-};

package/dist/lib/assets/mp4FileWritable.mjs

@@ -1,21 +0,0 @@
-import { Writable } from "stream";
-const mp4FileWritable = (mp4File) => {
-  let arrayBufferStart = 0;
-  return new Writable({
-    write: (chunk, _encoding, callback) => {
-      const mp4BoxBuffer = chunk.buffer;
-      mp4BoxBuffer.fileStart = arrayBufferStart;
-      arrayBufferStart += chunk.length;
-      mp4File.appendBuffer(mp4BoxBuffer, false);
-      callback();
-    },
-    final: (callback) => {
-      mp4File.flush();
-      mp4File.processSamples(true);
-      callback();
-    }
-  });
-};
-export {
-  mp4FileWritable
-};

package/dist/lib/assets/tasks/cacheImage.mjs

@@ -1,22 +0,0 @@
-import { idempotentTask } from "../idempotentTask.mjs";
-import { createReadStream } from "fs";
-import path from "path";
-const cacheImageTask = idempotentTask({
-  label: "image",
-  filename: (absolutePath) => path.basename(absolutePath),
-  runner: async (absolutePath) => {
-    return createReadStream(absolutePath);
-  }
-});
-const cacheImage = async (cacheRoot, absolutePath) => {
-  try {
-    return await cacheImageTask(cacheRoot, absolutePath);
-  } catch (error) {
-    console.error(error);
-    console.trace("Error generating track fragment index", error);
-    throw error;
-  }
-};
-export {
-  cacheImage
-};

package/dist/lib/assets/tasks/findOrCreateCaptions.mjs

@@ -1,26 +0,0 @@
-import { execPromise } from "../../util/execPromise.mjs";
-import { idempotentTask } from "../idempotentTask.mjs";
-import debug from "debug";
-import { basename } from "path";
-const log = debug("@ef:generateCaptions");
-const generateCaptionData = idempotentTask({
-  label: "captions",
-  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
-  runner: async (absolutePath) => {
-    const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
-    log(`Running command: ${command}`);
-    const { stdout } = await execPromise(command);
-    return stdout;
-  }
-});
-const findOrCreateCaptions = async (cacheRoot, absolutePath) => {
-  try {
-    return await generateCaptionData(cacheRoot, absolutePath);
-  } catch (error) {
-    console.trace("Error finding or creating captions", error);
-    throw error;
-  }
-};
-export {
-  findOrCreateCaptions
-};

package/dist/lib/assets/tasks/generateTrack.mjs

@@ -1,52 +0,0 @@
-import { idempotentTask } from "../idempotentTask.mjs";
-import { MP4File } from "../../av/MP4File.mjs";
-import debug from "debug";
-import { mp4FileWritable } from "../mp4FileWritable.mjs";
-import { PassThrough } from "stream";
-import { basename } from "path";
-import { Probe } from "../Probe.mjs";
-const generateTrackTask = idempotentTask({
-  label: "track",
-  filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
-  runner: async (absolutePath, trackId) => {
-    const log = debug("@ef:generateTrackFragment");
-    const probe = await Probe.probePath(absolutePath);
-    const readStream = probe.createConformingReadstream();
-    const mp4File = new MP4File();
-    log(`Generating track fragment index for ${absolutePath}`);
-    readStream.pipe(mp4FileWritable(mp4File));
-    await new Promise((resolve, reject) => {
-      readStream.on("end", resolve);
-      readStream.on("error", reject);
-    });
-    const trackStream = new PassThrough();
-    for await (const fragment of mp4File.fragmentIterator()) {
-      if (fragment.track !== trackId) {
-        continue;
-      }
-      trackStream.write(Buffer.from(fragment.data), "binary");
-    }
-    trackStream.end();
-    return trackStream;
-  }
-});
-const generateTrack = async (cacheRoot, absolutePath, url) => {
-  try {
-    const trackId = new URL(
-      `http://localhost${url}` ?? "bad-url"
-    ).searchParams.get("trackId");
-    if (trackId === null) {
-      throw new Error(
-        "No trackId provided. IT must be specified in the query string: ?trackId=0"
-      );
-    }
-    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
-  } catch (error) {
-    console.error(error);
-    console.trace("Error generating track fragment index", error);
-    throw error;
-  }
-};
-export {
-  generateTrack
-};

package/dist/lib/assets/tasks/generateTrackFragmentIndex.mjs

@@ -1,71 +0,0 @@
-import { idempotentTask } from "../idempotentTask.mjs";
-import { MP4File } from "../../av/MP4File.mjs";
-import debug from "debug";
-import { mp4FileWritable } from "../mp4FileWritable.mjs";
-import { basename } from "path";
-import { Probe } from "../Probe.mjs";
-const generateTrackFragmentIndexFromPath = async (absolutePath) => {
-  const log = debug("@ef:generateTrackFragment");
-  const probe = await Probe.probePath(absolutePath);
-  const readStream = probe.createConformingReadstream();
-  const mp4File = new MP4File();
-  log(`Generating track fragment index for ${absolutePath}`);
-  readStream.pipe(mp4FileWritable(mp4File));
-  await new Promise((resolve, reject) => {
-    readStream.on("end", resolve);
-    readStream.on("error", reject);
-  });
-  const trackFragmentIndexes = {};
-  const trackByteOffsets = {};
-  for await (const fragment of mp4File.fragmentIterator()) {
-    const track = mp4File.getInfo().tracks.find((track2) => track2.id === fragment.track);
-    if (!track) {
-      throw new Error("Track not found");
-    }
-    if (fragment.segment === "init") {
-      trackByteOffsets[fragment.track] = fragment.data.byteLength;
-      trackFragmentIndexes[fragment.track] = {
-        track: fragment.track,
-        type: track?.type ?? "video",
-        timescale: track.timescale,
-        duration: 0,
-        initSegment: {
-          offset: 0,
-          size: fragment.data.byteLength
-        },
-        segments: []
-      };
-    } else {
-      const fragmentIndex = trackFragmentIndexes[fragment.track];
-      if (!fragmentIndex) {
-        throw new Error("Fragment index not found");
-      }
-      fragmentIndex.duration += fragment.duration;
-      fragmentIndex.segments.push({
-        cts: fragment.cts,
-        dts: fragment.dts,
-        duration: fragment.duration,
-        offset: trackByteOffsets[fragment.track],
-        size: fragment.data.byteLength
-      });
-      trackByteOffsets[fragment.track] += fragment.data.byteLength;
-    }
-  }
-  return JSON.stringify(trackFragmentIndexes, null, 2);
-};
-const generateTrackFragmentIndexTask = idempotentTask({
-  label: "trackFragmentIndex",
-  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
-  runner: generateTrackFragmentIndexFromPath
-});
-const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
-  try {
-    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
-  } catch (error) {
-    console.trace("Error generating track fragment index", error);
-    throw error;
-  }
-};
-export {
-  generateTrackFragmentIndex
-};

package/dist/lib/av/MP4File.mjs

@@ -1,160 +0,0 @@
-import * as MP4Box from "mp4box";
-class MP4File extends MP4Box.ISOFile {
-  constructor() {
-    super(...arguments);
-    this.readyPromise = new Promise((resolve, reject) => {
-      this.onReady = () => resolve();
-      this.onError = reject;
-    });
-    this.waitingForSamples = [];
-    this._hasSeenLastSamples = false;
-    this._arrayBufferFileStart = 0;
-  }
-  setSegmentOptions(id, user, options) {
-    const trak = this.getTrackById(id);
-    if (trak) {
-      trak.nextSample = 0;
-      this.fragmentedTracks.push({
-        id,
-        user,
-        trak,
-        segmentStream: null,
-        nb_samples: "nbSamples" in options && options.nbSamples || 1e3,
-        rapAlignement: ("rapAlignement" in options && options.rapAlignement) ?? true
-      });
-    }
-  }
-  /**
-   * Fragments all tracks in a file into separate array buffers.
-   */
-  async fragmentAllTracks() {
-    let trackBuffers = {};
-    for await (const segment of this.fragmentIterator()) {
-      (trackBuffers[segment.track] ??= []).push(segment.data);
-    }
-    return trackBuffers;
-  }
-  async *fragmentIterator() {
-    await this.readyPromise;
-    const trackInfo = {};
-    for (const videoTrack of this.getInfo().videoTracks) {
-      trackInfo[videoTrack.id] = { index: 0, complete: false };
-      this.setSegmentOptions(videoTrack.id, null, {
-        rapAlignement: true
-      });
-    }
-    for (const audioTrack of this.getInfo().audioTracks) {
-      trackInfo[audioTrack.id] = { index: 0, complete: false };
-      const sampleRate = audioTrack.audio.sample_rate;
-      const probablePacketSize = 1024;
-      const probableFourSecondsOfSamples = Math.ceil(
-        sampleRate / probablePacketSize * 4
-      );
-      this.setSegmentOptions(audioTrack.id, null, {
-        nbSamples: probableFourSecondsOfSamples
-      });
-    }
-    const initSegments = this.initializeSegmentation();
-    for (const initSegment of initSegments) {
-      yield {
-        track: initSegment.id,
-        segment: "init",
-        data: initSegment.buffer,
-        complete: false
-      };
-    }
-    const fragmentStartSamples = {};
-    let finishedReading = false;
-    const allTracksFinished = () => {
-      for (const fragmentedTrack of this.fragmentedTracks) {
-        if (!trackInfo[fragmentedTrack.id]?.complete) {
-          return false;
-        }
-      }
-      return true;
-    };
-    while (!(finishedReading && allTracksFinished())) {
-      for (const fragTrak of this.fragmentedTracks) {
-        const trak = fragTrak.trak;
-        if (trak.nextSample === void 0) {
-          throw new Error("trak.nextSample is undefined");
-        }
-        if (trak.samples === void 0) {
-          throw new Error("trak.samples is undefined");
-        }
-        eachSample: while (trak.nextSample < trak.samples.length) {
-          let result = void 0;
-          if (trak?.samples[trak.nextSample]) {
-            fragmentStartSamples[fragTrak.id] ||= trak.samples[trak.nextSample];
-          }
-          try {
-            result = this.createFragment(
-              fragTrak.id,
-              trak.nextSample,
-              fragTrak.segmentStream
-            );
-          } catch (error) {
-            console.log("Failed to createFragment", error);
-          }
-          if (result) {
-            fragTrak.segmentStream = result;
-            trak.nextSample++;
-          } else {
-            finishedReading = await this.waitForMoreSamples();
-            break eachSample;
-          }
-          const nextSample = trak.samples[trak.nextSample];
-          const emitSegment = (
-            // if rapAlignement is true, we emit a fragment when we have a rap sample coming up next
-            fragTrak.rapAlignement === true && nextSample?.is_sync || // if rapAlignement is false, we emit a fragment when we have the required number of samples
-            !fragTrak.rapAlignement && trak.nextSample % fragTrak.nb_samples === 0 || // // if this is the last sample, we emit the fragment
-            // finished ||
-            // if we have more samples than the number of samples requested, we emit the fragment
-            trak.nextSample >= trak.samples.length
-          );
-          if (emitSegment) {
-            if (trak.nextSample >= trak.samples.length) {
-              trackInfo[fragTrak.id].complete = true;
-            }
-            const startSample = fragmentStartSamples[fragTrak.id];
-            const endSample = trak.samples[trak.nextSample - 1];
-            if (!startSample || !endSample) {
-              throw new Error("startSample or endSample is undefined");
-            }
-            yield {
-              track: fragTrak.id,
-              segment: trackInfo[fragTrak.id].index,
-              data: fragTrak.segmentStream.buffer,
-              complete: trackInfo[fragTrak.id].complete,
-              cts: startSample.cts,
-              dts: startSample.dts,
-              duration: endSample.dts - startSample.dts + endSample.duration
-            };
-            trackInfo[fragTrak.id].index += 1;
-            fragTrak.segmentStream = null;
-            delete fragmentStartSamples[fragTrak.id];
-          }
-        }
-      }
-      finishedReading = await this.waitForMoreSamples();
-    }
-  }
-  waitForMoreSamples() {
-    if (this._hasSeenLastSamples) {
-      return Promise.resolve(true);
-    }
-    return new Promise((resolve) => {
-      this.waitingForSamples.push(resolve);
-    });
-  }
-  processSamples(last) {
-    this._hasSeenLastSamples = last;
-    for (const observer of this.waitingForSamples) {
-      observer(last);
-    }
-    this.waitingForSamples = [];
-  }
-}
-export {
-  MP4File
-};

package/dist/lib/util/execPromise.mjs

@@ -1,6 +0,0 @@
-import { exec } from "child_process";
-import { promisify } from "util";
-const execPromise = promisify(exec);
-export {
-  execPromise
-};