@editframe/assets 0.7.0-beta.11 → 0.7.0-beta.15

package/dist/{packages/assets/src/Probe.d.ts → Probe.d.ts}

@@ -1,3 +1,4 @@
+import { Readable } from 'node:stream';
 import * as z from "zod";
 export declare const AudioStreamSchema: z.ZodObject<{
     index: z.ZodNumber;
@@ -22,6 +23,7 @@ export declare const AudioStreamSchema: z.ZodObject<{
     bit_rate: z.ZodString;
     disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
+    duration: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -39,11 +41,11 @@ export declare const AudioStreamSchema: z.ZodObject<{
     start_pts: number;
     start_time: number;
     duration_ts: number;
-    duration: number;
     bit_rate: string;
     disposition: Record<string, unknown>;
     initial_padding?: number | undefined;
 }, {
+    duration: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -61,7 +63,6 @@ export declare const AudioStreamSchema: z.ZodObject<{
     start_pts: number;
     start_time: number;
     duration_ts: number;
-    duration: number;
     bit_rate: string;
     disposition: Record<string, unknown>;
     initial_padding?: number | undefined;
@@ -102,10 +103,10 @@ export declare const VideoStreamSchema: z.ZodObject<{
     height: number;
     coded_width: number;
     coded_height: number;
+    duration?: number | undefined;
     start_pts?: number | undefined;
     start_time?: number | undefined;
     duration_ts?: number | undefined;
-    duration?: number | undefined;
     bit_rate?: string | undefined;
 }, {
     index: number;
@@ -122,10 +123,10 @@ export declare const VideoStreamSchema: z.ZodObject<{
     height: number;
     coded_width: number;
     coded_height: number;
+    duration?: number | undefined;
     start_pts?: number | undefined;
     start_time?: number | undefined;
     duration_ts?: number | undefined;
-    duration?: number | undefined;
     bit_rate?: string | undefined;
 }>;
 export type VideoStreamSchema = z.infer<typeof VideoStreamSchema>;
@@ -152,6 +153,7 @@ declare const StreamSchema: z.ZodDiscriminatedUnion<"codec_type", [z.ZodObject<{
     bit_rate: z.ZodString;
     disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
+    duration: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -169,11 +171,11 @@ declare const StreamSchema: z.ZodDiscriminatedUnion<"codec_type", [z.ZodObject<{
     start_pts: number;
     start_time: number;
     duration_ts: number;
-    duration: number;
     bit_rate: string;
     disposition: Record<string, unknown>;
     initial_padding?: number | undefined;
 }, {
+    duration: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -191,7 +193,6 @@ declare const StreamSchema: z.ZodDiscriminatedUnion<"codec_type", [z.ZodObject<{
     start_pts: number;
     start_time: number;
     duration_ts: number;
-    duration: number;
     bit_rate: string;
     disposition: Record<string, unknown>;
     initial_padding?: number | undefined;
@@ -230,10 +231,10 @@ declare const StreamSchema: z.ZodDiscriminatedUnion<"codec_type", [z.ZodObject<{
     height: number;
     coded_width: number;
     coded_height: number;
+    duration?: number | undefined;
     start_pts?: number | undefined;
     start_time?: number | undefined;
     duration_ts?: number | undefined;
-    duration?: number | undefined;
     bit_rate?: string | undefined;
 }, {
     index: number;
@@ -250,10 +251,10 @@ declare const StreamSchema: z.ZodDiscriminatedUnion<"codec_type", [z.ZodObject<{
     height: number;
     coded_width: number;
     coded_height: number;
+    duration?: number | undefined;
     start_pts?: number | undefined;
     start_time?: number | undefined;
     duration_ts?: number | undefined;
-    duration?: number | undefined;
     bit_rate?: string | undefined;
 }>]>;
 export type StreamSchema = z.infer<typeof StreamSchema>;
@@ -281,6 +282,7 @@ declare const ProbeSchema: z.ZodObject<{
         bit_rate: z.ZodString;
         disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
+        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -298,11 +300,11 @@ declare const ProbeSchema: z.ZodObject<{
         start_pts: number;
         start_time: number;
         duration_ts: number;
-        duration: number;
         bit_rate: string;
         disposition: Record<string, unknown>;
         initial_padding?: number | undefined;
     }, {
+        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -320,7 +322,6 @@ declare const ProbeSchema: z.ZodObject<{
         start_pts: number;
         start_time: number;
         duration_ts: number;
-        duration: number;
         bit_rate: string;
         disposition: Record<string, unknown>;
         initial_padding?: number | undefined;
@@ -359,10 +360,10 @@ declare const ProbeSchema: z.ZodObject<{
         height: number;
         coded_width: number;
         coded_height: number;
+        duration?: number | undefined;
         start_pts?: number | undefined;
         start_time?: number | undefined;
         duration_ts?: number | undefined;
-        duration?: number | undefined;
         bit_rate?: string | undefined;
     }, {
         index: number;
@@ -379,10 +380,10 @@ declare const ProbeSchema: z.ZodObject<{
         height: number;
         coded_width: number;
         coded_height: number;
+        duration?: number | undefined;
         start_pts?: number | undefined;
         start_time?: number | undefined;
         duration_ts?: number | undefined;
-        duration?: number | undefined;
         bit_rate?: string | undefined;
     }>]>, "many">;
     format: z.ZodObject<{
@@ -393,7 +394,7 @@ declare const ProbeSchema: z.ZodObject<{
         format_long_name: z.ZodString;
         start_time: z.ZodOptional<z.ZodString>;
         duration: z.ZodOptional<z.ZodString>;
-        size: z.ZodString;
+        size: z.ZodOptional<z.ZodString>;
         bit_rate: z.ZodOptional<z.ZodString>;
         probe_score: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
@@ -402,25 +403,38 @@ declare const ProbeSchema: z.ZodObject<{
         nb_programs: number;
         format_name: string;
         format_long_name: string;
-        size: string;
         probe_score: number;
-        start_time?: string | undefined;
         duration?: string | undefined;
+        start_time?: string | undefined;
         bit_rate?: string | undefined;
+        size?: string | undefined;
     }, {
         filename: string;
         nb_streams: number;
         nb_programs: number;
         format_name: string;
         format_long_name: string;
-        size: string;
         probe_score: number;
-        start_time?: string | undefined;
         duration?: string | undefined;
+        start_time?: string | undefined;
         bit_rate?: string | undefined;
+        size?: string | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
+    format: {
+        filename: string;
+        nb_streams: number;
+        nb_programs: number;
+        format_name: string;
+        format_long_name: string;
+        probe_score: number;
+        duration?: string | undefined;
+        start_time?: string | undefined;
+        bit_rate?: string | undefined;
+        size?: string | undefined;
+    };
     streams: ({
+        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -438,7 +452,6 @@ declare const ProbeSchema: z.ZodObject<{
         start_pts: number;
         start_time: number;
         duration_ts: number;
-        duration: number;
         bit_rate: string;
         disposition: Record<string, unknown>;
         initial_padding?: number | undefined;
@@ -457,26 +470,27 @@ declare const ProbeSchema: z.ZodObject<{
         height: number;
         coded_width: number;
         coded_height: number;
+        duration?: number | undefined;
         start_pts?: number | undefined;
         start_time?: number | undefined;
         duration_ts?: number | undefined;
-        duration?: number | undefined;
         bit_rate?: string | undefined;
     })[];
+}, {
     format: {
         filename: string;
         nb_streams: number;
         nb_programs: number;
         format_name: string;
         format_long_name: string;
-        size: string;
         probe_score: number;
-        start_time?: string | undefined;
         duration?: string | undefined;
+        start_time?: string | undefined;
         bit_rate?: string | undefined;
+        size?: string | undefined;
     };
-}, {
     streams: ({
+        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -494,7 +508,6 @@ declare const ProbeSchema: z.ZodObject<{
         start_pts: number;
         start_time: number;
         duration_ts: number;
-        duration: number;
         bit_rate: string;
         disposition: Record<string, unknown>;
         initial_padding?: number | undefined;
@@ -513,24 +526,12 @@ declare const ProbeSchema: z.ZodObject<{
         height: number;
         coded_width: number;
         coded_height: number;
+        duration?: number | undefined;
         start_pts?: number | undefined;
         start_time?: number | undefined;
         duration_ts?: number | undefined;
-        duration?: number | undefined;
         bit_rate?: string | undefined;
     })[];
-    format: {
-        filename: string;
-        nb_streams: number;
-        nb_programs: number;
-        format_name: string;
-        format_long_name: string;
-        size: string;
-        probe_score: number;
-        start_time?: string | undefined;
-        duration?: string | undefined;
-        bit_rate?: string | undefined;
-    };
 }>;
 export interface TrackSegment {
     cts: number;
@@ -548,6 +549,7 @@ interface AudioTrackFragmentIndex {
     sample_rate: number;
     sample_size: number;
     sample_count: number;
+    codec: string;
     initSegment: {
         offset: 0;
         size: number;
@@ -562,6 +564,7 @@ interface VideoTrackFragmentIndex {
     width: number;
     height: number;
     sample_count: number;
+    codec: string;
     initSegment: {
         offset: 0;
         size: number;
@@ -573,10 +576,12 @@ export declare class Probe {
     private absolutePath;
     data: z.infer<typeof ProbeSchema>;
     static probePath(absolutePath: string): Promise<Probe>;
+    static probeStream(stream: Readable): Promise<Probe>;
     constructor(absolutePath: string, rawData: any);
     get audioStreams(): AudioStreamSchema[];
     get videoStreams(): VideoStreamSchema[];
     get streams(): ({
+        duration: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -594,7 +599,6 @@ export declare class Probe {
         start_pts: number;
         start_time: number;
         duration_ts: number;
-        duration: number;
         bit_rate: string;
         disposition: Record<string, unknown>;
         initial_padding?: number | undefined;
@@ -613,10 +617,10 @@ export declare class Probe {
         height: number;
         coded_width: number;
         coded_height: number;
+        duration?: number | undefined;
         start_pts?: number | undefined;
         start_time?: number | undefined;
         duration_ts?: number | undefined;
-        duration?: number | undefined;
         bit_rate?: string | undefined;
     })[];
     get format(): {
@@ -625,11 +629,11 @@ export declare class Probe {
         nb_programs: number;
         format_name: string;
         format_long_name: string;
-        size: string;
         probe_score: number;
-        start_time?: string | undefined;
         duration?: string | undefined;
+        start_time?: string | undefined;
         bit_rate?: string | undefined;
+        size?: string | undefined;
     };
     get mustReencodeAudio(): boolean;
     get mustReencodeVideo(): boolean;
@@ -641,6 +645,6 @@ export declare class Probe {
     get mustProcess(): boolean;
     get ffmpegAudioOptions(): string[];
     get ffmpegVideoOptions(): string[];
-    createConformingReadstream(): import('stream').Readable;
+    createConformingReadstream(): Readable;
 }
 export {};

package/dist/{packages/assets/src/Probe.js → Probe.js}

@@ -1,8 +1,9 @@
-import { spawn } from "node:child_process";
+import { exec, spawn } from "node:child_process";
+import { promisify } from "node:util";
 import { createReadStream } from "node:fs";
 import * as z from "zod";
 import debug from "debug";
-import { execPromise } from "../../../lib/util/execPromise.js";
+const execPromise = promisify(exec);
 const log = debug("ef:assets:probe");
 const AudioStreamSchema = z.object({
   index: z.number(),
@@ -56,7 +57,7 @@ const ProbeFormatSchema = z.object({
   format_long_name: z.string(),
   start_time: z.string().optional(),
   duration: z.string().optional(),
-  size: z.string(),
+  size: z.string().optional(),
   bit_rate: z.string().optional(),
   probe_score: z.number()
 });
@@ -82,6 +83,51 @@ class Probe {
     const json = JSON.parse(probeResult.stdout);
     return new Probe(absolutePath, json);
   }
+  static async probeStream(stream) {
+    const probeCommand = "ffprobe -i pipe:0 -v error -show_format -show_streams -of json";
+    log("Probing", probeCommand);
+    const probe = spawn(
+      "ffprobe",
+      [
+        "-i",
+        "-",
+        "-v",
+        "error",
+        "-show_format",
+        "-show_streams",
+        "-of",
+        "json"
+      ],
+      {
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    const chunks = [];
+    probe.stderr.on("data", (data) => {
+      log(data.toString());
+    });
+    probe.stdout.on("data", (data) => {
+      chunks.push(data);
+    });
+    stream.pipe(probe.stdin);
+    probe.stdin.on("error", (error) => {
+      log("ffprobe stdin error", error);
+    });
+    const json = await new Promise((resolve, reject) => {
+      probe.stdout.on("end", () => {
+        stream.unpipe(probe.stdin);
+        stream.destroy();
+        try {
+          const buffer = Buffer.concat(chunks).toString("utf8");
+          log("Got probe from stream", buffer);
+          resolve(JSON.parse(buffer));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+    return new Probe("pipe:0", json);
+  }
   get audioStreams() {
     return this.data.streams.filter(
       (stream) => stream.codec_type === "audio"
@@ -160,6 +206,9 @@ class Probe {
     ];
   }
   createConformingReadstream() {
+    if (this.absolutePath === "pipe:0") {
+      throw new Error("Cannot create conforming readstream from pipe");
+    }
     if (!this.mustProcess) {
       return createReadStream(this.absolutePath);
     }
@@ -171,7 +220,7 @@ class Probe {
       "-f",
       "mp4",
       "-movflags",
-      "cmaf+frag_keyframe+empty_moov",
+      "cmaf+frag_keyframe+empty_moov+delay_moov",
       "pipe:1"
     ];
     log("Running ffmpeg", ffmpegConformanceArgs);
@@ -189,7 +238,7 @@ class Probe {
       "-f",
       "mp4",
       "-movflags",
-      "frag_keyframe+empty_moov",
+      "frag_keyframe+empty_moov+delay_moov",
       "pipe:1"
     ];
     log("Running ffmpeg", ffmpegFragmentArgs);

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { AudioStreamSchema, VideoStreamSchema, Probe } from './Probe.ts';
+export type { StreamSchema, TrackSegment, TrackFragmentIndex, } from './Probe.ts';
+export { md5FilePath, md5Directory, md5ReadStream } from './md5.ts';
+export { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, } from './tasks/generateTrackFragmentIndex.ts';
+export { generateTrack, generateTrackFromPath } from './tasks/generateTrack.ts';
+export { findOrCreateCaptions, generateCaptionDataFromPath, } from './tasks/findOrCreateCaptions.ts';
+export { cacheImage } from './tasks/cacheImage.ts';
+export type { TaskResult } from './idempotentTask.ts';
+export { VideoRenderOptions } from './VideoRenderOptions.ts';

package/dist/{packages/assets/src/index.js → index.js}

@@ -1,8 +1,8 @@
 import { AudioStreamSchema, Probe, VideoStreamSchema } from "./Probe.js";
 import { md5Directory, md5FilePath, md5ReadStream } from "./md5.js";
-import { generateTrackFragmentIndex } from "./tasks/generateTrackFragmentIndex.js";
-import { generateTrack } from "./tasks/generateTrack.js";
-import { findOrCreateCaptions } from "./tasks/findOrCreateCaptions.js";
+import { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath } from "./tasks/generateTrackFragmentIndex.js";
+import { generateTrack, generateTrackFromPath } from "./tasks/generateTrack.js";
+import { findOrCreateCaptions, generateCaptionDataFromPath } from "./tasks/findOrCreateCaptions.js";
 import { cacheImage } from "./tasks/cacheImage.js";
 import { VideoRenderOptions } from "./VideoRenderOptions.js";
 export {
@@ -12,8 +12,11 @@ export {
   VideoStreamSchema,
   cacheImage,
   findOrCreateCaptions,
+  generateCaptionDataFromPath,
   generateTrack,
   generateTrackFragmentIndex,
+  generateTrackFragmentIndexFromPath,
+  generateTrackFromPath,
   md5Directory,
   md5FilePath,
   md5ReadStream

package/dist/memoize.d.ts

@@ -0,0 +1,2 @@
+/** method decorator to memoize the value of a getter */
+export declare const memoize: <Target extends object, PropertyKey extends keyof Target>(_target: Target, _propertyKey: PropertyKey, descriptor: TypedPropertyDescriptor<Target[PropertyKey]>) => void;

package/dist/memoize.js

@@ -0,0 +1,14 @@
+const memoize = (_target, _propertyKey, descriptor) => {
+  const get = descriptor.get;
+  if (!get) return;
+  const memoized = /* @__PURE__ */ new WeakMap();
+  descriptor.get = function() {
+    if (!memoized.has(this)) {
+      memoized.set(this, get.call(this));
+    }
+    return memoized.get(this);
+  };
+};
+export {
+  memoize
+};

package/dist/{packages/assets/src/mp4FileWritable.d.ts → mp4FileWritable.d.ts}

@@ -1,4 +1,4 @@
 import { Writable } from 'node:stream';
-import { MP4File } from '../../../lib/av/MP4File';
+import { MP4File } from './MP4File.ts';
 
 export declare const mp4FileWritable: (mp4File: MP4File) => Writable;

package/dist/tasks/cacheImage.d.ts

@@ -0,0 +1 @@
+export declare const cacheImage: (cacheRoot: string, absolutePath: string) => Promise<import('../idempotentTask.ts').TaskResult>;

package/dist/tasks/findOrCreateCaptions.d.ts

@@ -0,0 +1,2 @@
+export declare const generateCaptionDataFromPath: (absolutePath: string) => Promise<string>;
+export declare const findOrCreateCaptions: (cacheRoot: string, absolutePath: string) => Promise<import('../idempotentTask.ts').TaskResult>;

package/dist/tasks/findOrCreateCaptions.js

@@ -0,0 +1,30 @@
+import { basename } from "node:path";
+import { promisify } from "node:util";
+import { exec } from "node:child_process";
+import debug from "debug";
+import { idempotentTask } from "../idempotentTask.js";
+const execPromise = promisify(exec);
+const log = debug("ef:generateCaptions");
+const generateCaptionDataFromPath = 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 generateCaptionDataTask = idempotentTask({
+  label: "captions",
+  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
+  runner: generateCaptionDataFromPath
+});
+const findOrCreateCaptions = async (cacheRoot, absolutePath) => {
+  try {
+    return await generateCaptionDataTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error finding or creating captions", error);
+    throw error;
+  }
+};
+export {
+  findOrCreateCaptions,
+  generateCaptionDataFromPath
+};

package/dist/tasks/generateTrack.d.ts

@@ -0,0 +1,5 @@
+import { PassThrough } from 'node:stream';
+
+export declare const generateTrackFromPath: (absolutePath: string, trackId: number) => Promise<PassThrough>;
+export declare const generateTrackTask: (rootDir: string, absolutePath: string, trackId: number) => Promise<import('../idempotentTask.ts').TaskResult>;
+export declare const generateTrack: (cacheRoot: string, absolutePath: string, url: string) => Promise<import('../idempotentTask.ts').TaskResult>;

package/dist/{packages/assets/src/tasks → tasks}/generateTrack.js

@@ -1,34 +1,35 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { MP4File } from "../../../../lib/av/MP4File.js";
+import { MP4File } from "../MP4File.js";
 import debug from "debug";
 import { mp4FileWritable } from "../mp4FileWritable.js";
 import { PassThrough } from "node:stream";
 import { basename } from "node:path";
 import { Probe } from "../Probe.js";
+const generateTrackFromPath = 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 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 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;
-  }
+  runner: generateTrackFromPath
 });
 const generateTrack = async (cacheRoot, absolutePath, url) => {
   try {
@@ -48,5 +49,7 @@ const generateTrack = async (cacheRoot, absolutePath, url) => {
   }
 };
 export {
-  generateTrack
+  generateTrack,
+  generateTrackFromPath,
+  generateTrackTask
 };

package/dist/tasks/generateTrackFragmentIndex.d.ts

@@ -0,0 +1,4 @@
+import { TrackFragmentIndex } from '../Probe.ts';
+
+export declare const generateTrackFragmentIndexFromPath: (absolutePath: string) => Promise<Record<number, TrackFragmentIndex>>;
+export declare const generateTrackFragmentIndex: (cacheRoot: string, absolutePath: string) => Promise<import('../idempotentTask.ts').TaskResult>;

package/dist/{packages/assets/src/tasks → tasks}/generateTrackFragmentIndex.js

@@ -1,5 +1,5 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { MP4File } from "../../../../lib/av/MP4File.js";
+import { MP4File } from "../MP4File.js";
 import debug from "debug";
 import { mp4FileWritable } from "../mp4FileWritable.js";
 import { basename } from "node:path";
@@ -36,7 +36,8 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
           height: videoTrack.video.height,
           timescale: track.timescale,
           sample_count: videoTrack.nb_samples,
-          duration: 0,
+          codec: videoTrack.codec,
+          duration: videoTrack.duration,
           initSegment: {
             offset: 0,
             size: fragment.data.byteLength
@@ -57,7 +58,8 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
           sample_size: audioTrack.audio.sample_size,
           sample_count: audioTrack.nb_samples,
           timescale: track.timescale,
-          duration: 0,
+          codec: audioTrack.codec,
+          duration: audioTrack.duration,
           initSegment: {
             offset: 0,
             size: fragment.data.byteLength
@@ -85,12 +87,15 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
       trackByteOffsets[fragment.track] += fragment.data.byteLength;
     }
   }
-  return JSON.stringify(trackFragmentIndexes, null, 2);
+  return trackFragmentIndexes;
 };
 const generateTrackFragmentIndexTask = idempotentTask({
   label: "trackFragmentIndex",
   filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
-  runner: generateTrackFragmentIndexFromPath
+  runner: async (absolutePath) => {
+    const index = await generateTrackFragmentIndexFromPath(absolutePath);
+    return JSON.stringify(index, null, 2);
+  }
 });
 const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
   try {
@@ -101,5 +106,6 @@ const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
   }
 };
 export {
-  generateTrackFragmentIndex
+  generateTrackFragmentIndex,
+  generateTrackFragmentIndexFromPath
 };