@antiphony/shared 0.4.0 → 0.5.1

package/dist/cjs/types/audio.d.cts

@@ -123,9 +123,9 @@ declare const AudioEmbedSchema: z.ZodObject<{
         mimeType: string;
         size: number;
     };
+    waveform?: number[] | undefined;
     durationMs?: number | undefined;
     alt?: string | undefined;
-    waveform?: number[] | undefined;
 }, {
     $type: "dev.antiphony.embed.audio";
     audio: {
@@ -136,9 +136,9 @@ declare const AudioEmbedSchema: z.ZodObject<{
         mimeType: string;
         size: number;
     };
+    waveform?: number[] | undefined;
     durationMs?: number | undefined;
     alt?: string | undefined;
-    waveform?: number[] | undefined;
 }>;
 type AudioEmbed = z.infer<typeof AudioEmbedSchema>;
 /**
@@ -217,6 +217,18 @@ type TimedTranscript = z.infer<typeof TimedTranscriptSchema>;
  */
 declare const AudioEmbedViewSchema: z.ZodObject<{
     $type: z.ZodLiteral<"dev.antiphony.embed.audio#view">;
+    /**
+     * `url`, `durationMs` and `waveform` are RESOLVED, not copied: once
+     * processing has produced an audio variant they describe that variant
+     * rather than the bytes the client uploaded. They always agree with one
+     * another — a duration and a set of peaks are only meaningful against the
+     * audio `url` actually points at.
+     *
+     * A client that stored `durationMs` at upload time should therefore expect
+     * it to change (trim removes leading/trailing silence), and should render
+     * these three as a set rather than caching them independently. The record's
+     * originals are immutable and unaffected; this is a read-time resolution.
+     */
     url: z.ZodString;
     durationMs: z.ZodOptional<z.ZodNumber>;
     alt: z.ZodOptional<z.ZodString>;
@@ -261,28 +273,36 @@ declare const AudioEmbedViewSchema: z.ZodObject<{
         text?: string | undefined;
     }>>;
     /**
-     * Per-stage audio-processing status (transcribe / denoise), when the app
-     * opted into processing on create. Absent otherwise. A `pending` stage
-     * means the client should poll (or re-render) for the result. When
-     * `denoise === 'ready'`, `url` above already resolves to the cleaned
-     * audio variant. See `types/processing.ts`.
+     * Per-stage audio-processing status (denoise / trim / transcribe /
+     * waveform), when the app opted into processing. Absent otherwise. A
+     * `pending` stage means the client should poll (or re-render) for the
+     * result — including a stage that returns to `pending` after having been
+     * `ready`, which is how a recompute surfaces. Once a byte-mutating stage
+     * completes, `url`/`durationMs`/`waveform` above already resolve to the
+     * processed audio variant. See `types/processing.ts`.
      */
     processing: z.ZodOptional<z.ZodObject<{
         transcribe: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
         denoise: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
+        trim: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
+        waveform: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
     }, "strip", z.ZodTypeAny, {
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-    }, {
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
         transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+    }, {
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     $type: "dev.antiphony.embed.audio#view";
     url: string;
+    waveform?: number[] | undefined;
     durationMs?: number | undefined;
     alt?: string | undefined;
-    waveform?: number[] | undefined;
     transcript?: {
         segments: {
             startMs: number;
@@ -292,15 +312,17 @@ declare const AudioEmbedViewSchema: z.ZodObject<{
         text?: string | undefined;
     } | undefined;
     processing?: {
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
     } | undefined;
 }, {
     $type: "dev.antiphony.embed.audio#view";
     url: string;
+    waveform?: number[] | undefined;
     durationMs?: number | undefined;
     alt?: string | undefined;
-    waveform?: number[] | undefined;
     transcript?: {
         segments: {
             startMs: number;
@@ -310,8 +332,10 @@ declare const AudioEmbedViewSchema: z.ZodObject<{
         text?: string | undefined;
     } | undefined;
     processing?: {
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
     } | undefined;
 }>;
 type AudioEmbedView = z.infer<typeof AudioEmbedViewSchema>;
@@ -370,17 +394,43 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
     processing: z.ZodOptional<z.ZodObject<{
         transcribe: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
         denoise: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
-        denoisedBlobCid: z.ZodOptional<z.ZodString>;
+        trim: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
+        waveform: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
+    } & {
+        reprocess: z.ZodOptional<z.ZodBoolean>;
+    } & {
+        processedBlobCid: z.ZodOptional<z.ZodString>;
+        processedMimeType: z.ZodOptional<z.ZodString>;
+        processedDurationMs: z.ZodOptional<z.ZodNumber>;
+        denoiseModel: z.ZodOptional<z.ZodString>;
+        waveformPeaks: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        leaseUntil: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodString, z.ZodNumber, z.ZodDate]>, Date, unknown>>;
         updatedAt: z.ZodEffects<z.ZodUnion<[z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodString, z.ZodNumber, z.ZodDate]>, Date, unknown>;
     }, "strip", z.ZodTypeAny, {
         updatedAt: Date;
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-        denoisedBlobCid?: string | undefined;
-    }, {
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
         transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        reprocess?: boolean | undefined;
+        processedBlobCid?: string | undefined;
+        processedMimeType?: string | undefined;
+        processedDurationMs?: number | undefined;
+        denoiseModel?: string | undefined;
+        waveformPeaks?: number[] | undefined;
+        leaseUntil?: Date | undefined;
+    }, {
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-        denoisedBlobCid?: string | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        reprocess?: boolean | undefined;
+        processedBlobCid?: string | undefined;
+        processedMimeType?: string | undefined;
+        processedDurationMs?: number | undefined;
+        denoiseModel?: string | undefined;
+        waveformPeaks?: number[] | undefined;
+        leaseUntil?: unknown;
         updatedAt?: unknown;
     }>>;
     /** User-authored text (bsky-semantic). May be empty for pure-audio posts. NEVER the transcript. */
@@ -433,9 +483,9 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
             mimeType: string;
             size: number;
         };
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
     }, {
         $type: "dev.antiphony.embed.audio";
         audio: {
@@ -446,9 +496,9 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
             mimeType: string;
             size: number;
         };
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
     }>>;
     /** Present iff this post is a reply (StrongRef root + parent). */
     reply: z.ZodOptional<z.ZodObject<{
@@ -507,9 +557,17 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
     createdAt: Date;
     processing?: {
         updatedAt: Date;
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-        denoisedBlobCid?: string | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        reprocess?: boolean | undefined;
+        processedBlobCid?: string | undefined;
+        processedMimeType?: string | undefined;
+        processedDurationMs?: number | undefined;
+        denoiseModel?: string | undefined;
+        waveformPeaks?: number[] | undefined;
+        leaseUntil?: Date | undefined;
     } | undefined;
     authorDid?: string | undefined;
     orgId?: string | null | undefined;
@@ -536,9 +594,9 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
             mimeType: string;
             size: number;
         };
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
     } | undefined;
     langs?: string[] | undefined;
     selfLabels?: string[] | undefined;
@@ -550,9 +608,17 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
     authorId: string;
     kind: "prompt" | "reply";
     processing?: {
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-        denoisedBlobCid?: string | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        reprocess?: boolean | undefined;
+        processedBlobCid?: string | undefined;
+        processedMimeType?: string | undefined;
+        processedDurationMs?: number | undefined;
+        denoiseModel?: string | undefined;
+        waveformPeaks?: number[] | undefined;
+        leaseUntil?: unknown;
         updatedAt?: unknown;
     } | undefined;
     authorDid?: string | undefined;
@@ -580,9 +646,9 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
             mimeType: string;
             size: number;
         };
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
     } | undefined;
     langs?: string[] | undefined;
     selfLabels?: string[] | undefined;
@@ -597,9 +663,17 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
     createdAt: Date;
     processing?: {
         updatedAt: Date;
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-        denoisedBlobCid?: string | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        reprocess?: boolean | undefined;
+        processedBlobCid?: string | undefined;
+        processedMimeType?: string | undefined;
+        processedDurationMs?: number | undefined;
+        denoiseModel?: string | undefined;
+        waveformPeaks?: number[] | undefined;
+        leaseUntil?: Date | undefined;
     } | undefined;
     authorDid?: string | undefined;
     orgId?: string | null | undefined;
@@ -626,9 +700,9 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
             mimeType: string;
             size: number;
         };
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
     } | undefined;
     langs?: string[] | undefined;
     selfLabels?: string[] | undefined;
@@ -640,9 +714,17 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
     authorId: string;
     kind: "prompt" | "reply";
     processing?: {
-        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
         denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-        denoisedBlobCid?: string | undefined;
+        trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        reprocess?: boolean | undefined;
+        processedBlobCid?: string | undefined;
+        processedMimeType?: string | undefined;
+        processedDurationMs?: number | undefined;
+        denoiseModel?: string | undefined;
+        waveformPeaks?: number[] | undefined;
+        leaseUntil?: unknown;
         updatedAt?: unknown;
     } | undefined;
     authorDid?: string | undefined;
@@ -670,9 +752,9 @@ declare const AudioPostRecordSchema: z.ZodEffects<z.ZodObject<{
             mimeType: string;
             size: number;
         };
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
     } | undefined;
     langs?: string[] | undefined;
     selfLabels?: string[] | undefined;
@@ -1014,6 +1096,18 @@ declare const AudioPostViewSchema: z.ZodObject<{
     /** Hydrated audio embed (signed URL + lifted transcript). */
     embed: z.ZodOptional<z.ZodObject<{
         $type: z.ZodLiteral<"dev.antiphony.embed.audio#view">;
+        /**
+         * `url`, `durationMs` and `waveform` are RESOLVED, not copied: once
+         * processing has produced an audio variant they describe that variant
+         * rather than the bytes the client uploaded. They always agree with one
+         * another — a duration and a set of peaks are only meaningful against the
+         * audio `url` actually points at.
+         *
+         * A client that stored `durationMs` at upload time should therefore expect
+         * it to change (trim removes leading/trailing silence), and should render
+         * these three as a set rather than caching them independently. The record's
+         * originals are immutable and unaffected; this is a read-time resolution.
+         */
         url: z.ZodString;
         durationMs: z.ZodOptional<z.ZodNumber>;
         alt: z.ZodOptional<z.ZodString>;
@@ -1058,28 +1152,36 @@ declare const AudioPostViewSchema: z.ZodObject<{
             text?: string | undefined;
         }>>;
         /**
-         * Per-stage audio-processing status (transcribe / denoise), when the app
-         * opted into processing on create. Absent otherwise. A `pending` stage
-         * means the client should poll (or re-render) for the result. When
-         * `denoise === 'ready'`, `url` above already resolves to the cleaned
-         * audio variant. See `types/processing.ts`.
+         * Per-stage audio-processing status (denoise / trim / transcribe /
+         * waveform), when the app opted into processing. Absent otherwise. A
+         * `pending` stage means the client should poll (or re-render) for the
+         * result — including a stage that returns to `pending` after having been
+         * `ready`, which is how a recompute surfaces. Once a byte-mutating stage
+         * completes, `url`/`durationMs`/`waveform` above already resolve to the
+         * processed audio variant. See `types/processing.ts`.
          */
         processing: z.ZodOptional<z.ZodObject<{
             transcribe: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
             denoise: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
+            trim: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
+            waveform: z.ZodOptional<z.ZodEnum<["pending", "ready", "failed", "skipped"]>>;
         }, "strip", z.ZodTypeAny, {
-            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
             denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
-        }, {
+            trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
             transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
+        }, {
             denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         $type: "dev.antiphony.embed.audio#view";
         url: string;
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
         transcript?: {
             segments: {
                 startMs: number;
@@ -1089,15 +1191,17 @@ declare const AudioPostViewSchema: z.ZodObject<{
             text?: string | undefined;
         } | undefined;
         processing?: {
-            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
             denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
         } | undefined;
     }, {
         $type: "dev.antiphony.embed.audio#view";
         url: string;
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
         transcript?: {
             segments: {
                 startMs: number;
@@ -1107,8 +1211,10 @@ declare const AudioPostViewSchema: z.ZodObject<{
             text?: string | undefined;
         } | undefined;
         processing?: {
-            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
             denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
         } | undefined;
     }>>;
     viewer: z.ZodObject<{
@@ -1162,9 +1268,9 @@ declare const AudioPostViewSchema: z.ZodObject<{
     embed?: {
         $type: "dev.antiphony.embed.audio#view";
         url: string;
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
         transcript?: {
             segments: {
                 startMs: number;
@@ -1174,8 +1280,10 @@ declare const AudioPostViewSchema: z.ZodObject<{
             text?: string | undefined;
         } | undefined;
         processing?: {
-            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
             denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
         } | undefined;
     } | undefined;
 }, {
@@ -1209,9 +1317,9 @@ declare const AudioPostViewSchema: z.ZodObject<{
     embed?: {
         $type: "dev.antiphony.embed.audio#view";
         url: string;
+        waveform?: number[] | undefined;
         durationMs?: number | undefined;
         alt?: string | undefined;
-        waveform?: number[] | undefined;
         transcript?: {
             segments: {
                 startMs: number;
@@ -1221,8 +1329,10 @@ declare const AudioPostViewSchema: z.ZodObject<{
             text?: string | undefined;
         } | undefined;
         processing?: {
-            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
             denoise?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            trim?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            transcribe?: "pending" | "ready" | "failed" | "skipped" | undefined;
+            waveform?: "pending" | "ready" | "failed" | "skipped" | undefined;
         } | undefined;
     } | undefined;
 }>;

package/dist/cjs/types/processing.cjs

@@ -0,0 +1,174 @@
+'use strict';
+
+var zod = require('zod');
+
+// types/processing.ts
+var FirestoreTimestampSchema = zod.z.union([
+  zod.z.custom((data) => {
+    return data && typeof data === "object" && (typeof data.toDate === "function" || "seconds" in data && "nanoseconds" in data);
+  }),
+  zod.z.string(),
+  zod.z.number(),
+  zod.z.date()
+]).transform((data, ctx) => {
+  let date;
+  if (data instanceof Date) {
+    date = data;
+  } else if (typeof data === "string") {
+    date = new Date(data);
+  } else if (typeof data === "number") {
+    date = new Date(data);
+  } else if (typeof data.toDate === "function") {
+    date = data.toDate();
+  } else {
+    const timestamp = data;
+    date = new Date(timestamp.seconds * 1e3 + timestamp.nanoseconds / 1e6);
+  }
+  if (Number.isNaN(date.getTime())) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "FirestoreTimestamp coerced to Invalid Date"
+    });
+    return zod.z.NEVER;
+  }
+  return date;
+});
+
+// types/processing.ts
+var ProcessingStageStatusSchema = zod.z.enum(["pending", "ready", "failed", "skipped"]);
+var PROCESSING_STAGES = ["denoise", "trim", "transcribe", "waveform"];
+var ProcessingStageSchema = zod.z.enum(PROCESSING_STAGES);
+var BYTE_MUTATING_STAGES = ["denoise", "trim"];
+var DERIVED_STAGES = ["transcribe", "waveform"];
+var ProcessingRequestSchema = zod.z.object({
+  transcribe: zod.z.boolean().optional(),
+  denoise: zod.z.boolean().optional(),
+  trim: zod.z.boolean().optional(),
+  waveform: zod.z.boolean().optional(),
+  /**
+   * Whether a completed byte-mutating stage should invalidate and recompute
+   * the derived artifacts that describe the old audio. Defaults to **true**
+   * — a transcript of superseded audio is wrong, not merely stale.
+   *
+   * `false` opts out, for an app that would rather keep the existing
+   * transcript than pay to regenerate it. It does NOT name a stage, so a
+   * request carrying only `reprocess` requests no work.
+   */
+  reprocess: zod.z.boolean().optional()
+});
+var ProcessingStageMapSchema = zod.z.object({
+  transcribe: ProcessingStageStatusSchema.optional(),
+  denoise: ProcessingStageStatusSchema.optional(),
+  trim: ProcessingStageStatusSchema.optional(),
+  waveform: ProcessingStageStatusSchema.optional()
+});
+var ResolvedProcessingSchema = ProcessingStageMapSchema.extend({
+  reprocess: zod.z.boolean().optional()
+});
+var ProcessingStateSchema = ResolvedProcessingSchema.extend({
+  /**
+   * Content CID of the processed audio variant — the composed output of every
+   * byte-mutating stage that has completed. The record's own
+   * `embed.audio.ref.$link` stays the ORIGINAL CID (immutable content
+   * address); only the read-time view swaps playback to this variant.
+   */
+  processedBlobCid: zod.z.string().optional(),
+  /**
+   * MIME type of the processed variant. Present because providers may
+   * TRANSCODE — the ElevenLabs Voice Isolator returns MP3 regardless of what
+   * it is given — so the variant's type cannot be assumed to match
+   * `embed.audio.mimeType`. Anything reading the variant's bytes must use
+   * this, not the embed's.
+   */
+  processedMimeType: zod.z.string().optional(),
+  /**
+   * Duration of the processed variant, when a byte-mutating stage changed it
+   * (i.e. trim). Absent when the variant's duration matches the original.
+   */
+  processedDurationMs: zod.z.number().int().min(0).optional(),
+  /**
+   * Which denoiser produced the variant's denoise contribution — provenance,
+   * the counterpart to a transcript record's `model`.
+   *
+   * Lives here because a cleaned variant, unlike a transcript, has no record
+   * of its own to carry it: it is a blob CID on this state. Without it,
+   * changing denoisers leaves no way to tell which variants predate the
+   * switch, so nothing can identify what to re-run.
+   *
+   * Named for the STAGE, not the variant (`processedModel`), because it
+   * describes one link of the byte-mutating chain rather than the composed
+   * artifact. Trim contributes to the same variant and has no model, and a
+   * later external link would want its own field rather than to overwrite
+   * this one.
+   *
+   * Written on every successful denoise, never cleared — it moves with
+   * `processedBlobCid`, which is only ever set, never reset. A denoise that
+   * FAILS leaves both alone, which is correct: the variant still holds the
+   * previous denoiser's output, so the previous model still describes it.
+   *
+   * Internal, like the other variant fields — `toProcessingView` projects
+   * stages only, so this never reaches a client.
+   */
+  denoiseModel: zod.z.string().optional(),
+  /**
+   * Peaks for the processed variant, once the `waveform` stage completes.
+   * Same normalization and bounds as `embed.waveform` (0–100, max 1000), so
+   * a view can never carry a larger payload than the record allows.
+   */
+  waveformPeaks: zod.z.array(zod.z.number().int().min(0).max(100)).max(1e3).optional(),
+  /**
+   * When the current runner's exclusive claim on this post expires.
+   *
+   * Queue delivery is at-least-once, so the same job can arrive twice and
+   * run CONCURRENTLY. `process()` is idempotent under sequential retry — it
+   * acts on `pending` and re-does nothing already settled — but two passes
+   * interleaved is a different failure: both read the same `pending` state,
+   * both bill the provider for the same stage, and both write
+   * `processedBlobCid`, so the surviving variant is whichever finished last
+   * and the other's blob is orphaned.
+   *
+   * A runner claims this field transactionally before doing any work and
+   * clears it when finished; a second runner finding it unexpired declines
+   * and returns. It is an EXPIRY, not a boolean lock, because the holder can
+   * die mid-run (instance recycled, process killed) with no chance to
+   * release — a plain flag would strand the post permanently, where a lapsed
+   * lease lets the next delivery pick it up.
+   *
+   * Internal, like the variant fields above: `toProcessingView` projects
+   * stages only, so this never reaches a client.
+   */
+  leaseUntil: FirestoreTimestampSchema.optional(),
+  updatedAt: FirestoreTimestampSchema
+});
+var ProcessingViewSchema = ProcessingStageMapSchema;
+function toProcessingView(state) {
+  const view = {};
+  for (const stage of PROCESSING_STAGES) {
+    if (state[stage] !== void 0) view[stage] = state[stage];
+  }
+  return view;
+}
+function resolveAudioVariant(canonical, state) {
+  var _a;
+  if (!state) return canonical;
+  const hasVariant = state.processedBlobCid !== void 0;
+  const peaksAreCurrent = state.waveform === "ready" && state.waveformPeaks !== void 0;
+  return {
+    blobCid: hasVariant ? state.processedBlobCid : canonical.blobCid,
+    durationMs: hasVariant ? (_a = state.processedDurationMs) != null ? _a : canonical.durationMs : canonical.durationMs,
+    waveform: peaksAreCurrent ? state.waveformPeaks : canonical.waveform
+  };
+}
+
+exports.BYTE_MUTATING_STAGES = BYTE_MUTATING_STAGES;
+exports.DERIVED_STAGES = DERIVED_STAGES;
+exports.PROCESSING_STAGES = PROCESSING_STAGES;
+exports.ProcessingRequestSchema = ProcessingRequestSchema;
+exports.ProcessingStageMapSchema = ProcessingStageMapSchema;
+exports.ProcessingStageSchema = ProcessingStageSchema;
+exports.ProcessingStageStatusSchema = ProcessingStageStatusSchema;
+exports.ProcessingStateSchema = ProcessingStateSchema;
+exports.ProcessingViewSchema = ProcessingViewSchema;
+exports.ResolvedProcessingSchema = ResolvedProcessingSchema;
+exports.resolveAudioVariant = resolveAudioVariant;
+exports.toProcessingView = toProcessingView;