diff --git a/src/lib/ai-edition/timeline/audio-placement.test.ts b/src/lib/ai-edition/timeline/audio-placement.test.ts
index 89917efab..f29f620dc 100644
--- a/src/lib/ai-edition/timeline/audio-placement.test.ts
+++ b/src/lib/ai-edition/timeline/audio-placement.test.ts
@@ -1,6 +1,11 @@
import { describe, expect, it } from "vitest";
import type { AxcutAudioRegion, AxcutClip, AxcutTrimRange } from "../schema";
-import { placeAudioRegions, resolveAudioPlayback } from "./audio-placement";
+import {
+ audioContentBounds,
+ audioGhostExtent,
+ placeAudioRegions,
+ resolveAudioPlayback,
+} from "./audio-placement";
function clip(over: Partial
= {}): AxcutClip {
return {
@@ -228,3 +233,60 @@ describe("resolveAudioPlayback", () => {
expect(resolveAudioPlayback([], 0)).toEqual({ targetTimeSec: 0, shouldPlay: false });
});
});
+
+describe("audioContentBounds — where a resize must stop at the file's own edges", () => {
+ it("stops the left edge where the in-point would hit the file's start", () => {
+ // Pill at 10–20s playing the file from 4s: only 4s of tape exist to the left.
+ const b = audioContentBounds(4, 10, 120, 10, 20);
+ expect(b).not.toBeNull();
+ expect(b?.minStartT).toBe(6);
+ // The right edge can still reach the file's end: 4+10=14 played, 106 left.
+ expect(b?.maxEndT).toBe(126);
+ });
+
+ it("clamps the left bound to the timeline's own start", () => {
+ // More in-point than timeline seconds before the pill: the lane starts at 0.
+ expect(audioContentBounds(30, 10, 120, 10, 20)?.minStartT).toBe(0);
+ });
+
+ it("stops the right edge where the played window runs off the file's end", () => {
+ // Pill at 0–10s playing 100–110 of a 115s file: only 5s of tape remain.
+ const b = audioContentBounds(100, 10, 115, 0, 10);
+ expect(b?.maxEndT).toBe(15);
+ expect(b?.minStartT).toBe(0);
+ });
+
+ it("leaves both edges free while the pill is a window inside the file", () => {
+ const b = audioContentBounds(10, 10, 120, 5, 15);
+ expect(b?.minStartT).toBe(0);
+ expect(b?.maxEndT).toBe(115);
+ });
+
+ it("returns null while the duration is unknown — a failed probe must not freeze the pill", () => {
+ expect(audioContentBounds(10, 10, null, 5, 15)).toBeNull();
+ expect(audioContentBounds(10, 10, 0, 5, 15)).toBeNull();
+ });
+});
+
+describe("audioGhostExtent — the rest of the tape around the pill", () => {
+ it("spans from the file's start to its end, mapped onto the timeline", () => {
+ // Pill at 10–20s playing 4–14s of a 120s file: the tape runs from 6s (where
+ // 0:00 sits) to 126s (where the file ends).
+ const g = audioGhostExtent(4, 10, 120, 10, 20, 300);
+ expect(g).toEqual({ startT: 6, endT: 126, sourceStartSec: 0, sourceEndSec: 120 });
+ });
+
+ it("clips to the timeline's bounds and reports the visible source window", () => {
+ // Same pill on a 60s timeline: the tape's tail is cut at 60s = source 54s.
+ const g = audioGhostExtent(4, 10, 120, 10, 20, 60);
+ expect(g).toEqual({ startT: 6, endT: 60, sourceStartSec: 0, sourceEndSec: 54 });
+ });
+
+ it("is null when the pill already plays the whole file", () => {
+ expect(audioGhostExtent(0, 120, 120, 0, 120, 300)).toBeNull();
+ });
+
+ it("is null while the duration is unknown", () => {
+ expect(audioGhostExtent(4, 10, null, 10, 20, 300)).toBeNull();
+ });
+});
diff --git a/src/lib/ai-edition/timeline/audio-placement.ts b/src/lib/ai-edition/timeline/audio-placement.ts
index 539f21aef..91e1d7eca 100644
--- a/src/lib/ai-edition/timeline/audio-placement.ts
+++ b/src/lib/ai-edition/timeline/audio-placement.ts
@@ -28,6 +28,56 @@ import {
hasCompleteClipAnchor,
} from "./timelineMap";
+/**
+ * Where an audio pill's own content stops: the LEFT edge cannot move before the point
+ * where the in-point would reach the file's start, the RIGHT edge not past where the
+ * played window would run off the file's end. Resizing is a crop, and a crop cannot
+ * crop past the tape — before these bounds the edges stretched into implicit silence
+ * (and a left-edge overrun silently extended the tail, since the out-point is derived
+ * as `offset + span`). Null while the duration is unknown: a failed probe must not
+ * freeze the pill.
+ */
+export function audioContentBounds(
+ offsetSec: number,
+ spanSec: number,
+ durationSec: number | null | undefined,
+ pillStartT: number,
+ pillEndT: number,
+): { minStartT: number; maxEndT: number } | null {
+ if (durationSec == null || !(durationSec > 0)) return null;
+ const minStartT = Math.max(0, pillStartT - Math.max(0, offsetSec));
+ const maxEndT = pillEndT + Math.max(0, durationSec - (offsetSec + spanSec));
+ return { minStartT, maxEndT };
+}
+
+/**
+ * The file's extent around an audio pill, as the lane can draw it: where the content
+ * still available on each side sits on the timeline ([startT, endT], clipped to the
+ * timeline's own bounds), and which source window that stretch shows. This is the
+ * "rest of the tape" a resize reveals — the pill is a window, this is what is behind
+ * its edges. Null when the duration is unknown or the pill already spans the whole
+ * file.
+ */
+export function audioGhostExtent(
+ offsetSec: number,
+ spanSec: number,
+ durationSec: number | null | undefined,
+ pillStartT: number,
+ pillEndT: number,
+ totalT: number,
+): { startT: number; endT: number; sourceStartSec: number; sourceEndSec: number } | null {
+ if (durationSec == null || !(durationSec > 0)) return null;
+ const startT = Math.max(0, pillStartT - Math.max(0, offsetSec));
+ const endT = Math.min(totalT, pillEndT + Math.max(0, durationSec - (offsetSec + spanSec)));
+ if (endT - startT <= pillEndT - pillStartT + 1e-6) return null;
+ return {
+ startT,
+ endT,
+ sourceStartSec: offsetSec - (pillStartT - startT),
+ sourceEndSec: offsetSec + (endT - pillStartT),
+ };
+}
+
/** One fragment of one audio pill, resolved onto the output programme. */
export interface AudioPlacement {
/** The pill the fragment belongs to — the id the ruler, the inspector and the agent