@camstack/addon-pipeline 1.2.285 → 1.2.286

package/dist/stream-broker/index.js

@@ -26692,6 +26692,14 @@ var ServerMessageSchema = require_dist.discriminatedUnion("t", [
 		clipId: require_dist.string().min(1),
 		durationMs: require_dist.number().positive()
 	}),
+	require_dist.object({
+		t: require_dist.literal("clipTransport"),
+		clipId: require_dist.string().min(1),
+		/** `forward` = only ahead of the playhead. `free` = anywhere. */
+		seek: require_dist._enum(["forward", "free"]),
+		/** Frame-step BACKWARD is meaningful. Forward always is. */
+		stepBack: require_dist.boolean()
+	}),
 	require_dist.object({
 		t: require_dist.literal("clipAudio"),
 		clipId: require_dist.string().min(1),
@@ -26722,11 +26730,49 @@ function serializeServerMessage(msg) {
 //#endregion
 //#region src/stream-broker/recorded/feed-clock.ts
 /**
+* The ORIGIN two tracks are measured from — the base and the source anchor,
+* shared, so the offset between video and audio survives a discontinuity.
+*
+* ## Why this exists
+*
+* `markDiscontinuity` re-bases on the last output. With one instance per
+* track, that last output is the TRACK'S own, and the two differ by however
+* far apart the interleave left them — so every seek replaced the real A/V
+* offset with that gap, in the same direction each time. Measured on the
+* clock alone it grows by a fixed step each time and never comes back; how
+* big that step is, is the interleave's business — 10–23 ms a seek on a
+* synthetic fixture, **900 ms over three seeks on a real clip**.
+*
+* Calling `markSeek()` on both instances "together" did not help and could
+* not: it is not the CALL that has to be shared, it is the ORIGIN. With one,
+* `out_video − out_audio` is `(vPts − aPts) / rate` — exactly the source
+* offset, which is the entire content of lip sync — and there is nothing left
+* to keep in step.
+*
+* `lastOutMs` stays per-track: monotonicity is a promise to ONE receiver
+* track, and clamping video against audio's last stamp would move video.
+*/
+var FeedOrigin = class {
+	/** Output ms the current run is measured from. */
+	outBaseMs = 0;
+	/** Source ms the current run is measured from; `null` until the next stamp. */
+	srcAnchorMs = null;
+	/**
+	* The furthest EITHER track has been stamped. What a discontinuity clears,
+	* so the gap is opened past both — and so two clocks marking the same
+	* discontinuity in a row produce one gap, not two.
+	*/
+	highWaterMs = 0;
+};
+/**
 * Maps arbitrary, possibly-resetting source PTS (ms) onto a strictly increasing
 * output clock at `rateHz` (default 90 kHz video; pass 8000 for PCMU audio). On
 * seek the output keeps advancing while the source anchor re-bases, so
-* per-segment PTS resets never rewind the track. Video and audio use SEPARATE
-* instances that `markSeek()` together to stay A/V aligned across boundaries.
+* per-segment PTS resets never rewind the track.
+*
+* Video and audio are separate instances SHARING one {@link FeedOrigin} — see
+* there for what happens when they do not. An instance constructed without one
+* gets its own, so a lone clock behaves exactly as it always did.
 *
 * Playback rate: `setRate(r)` divides SOURCE elapsed time by `r` on the output
 * timeline (2× → half the output spacing → the receiver plays frames twice as
@@ -26736,20 +26782,21 @@ function serializeServerMessage(msg) {
 */
 var MonotonicClock = class {
 	rateHz;
-	srcAnchorMs = null;
 	lastSrcMs = null;
-	outBaseMs = 0;
 	lastOutMs = 0;
 	rate = 1;
-	constructor(rateHz = 9e4) {
+	origin;
+	constructor(rateHz = 9e4, origin) {
 		this.rateHz = rateHz;
+		this.origin = origin ?? new FeedOrigin();
 	}
 	stamp(srcPtsMs) {
-		if (this.srcAnchorMs === null) this.srcAnchorMs = srcPtsMs;
+		if (this.origin.srcAnchorMs === null) this.origin.srcAnchorMs = srcPtsMs;
 		this.lastSrcMs = srcPtsMs;
-		const elapsed = Math.max(0, (srcPtsMs - this.srcAnchorMs) / this.rate);
-		const outMs = this.outBaseMs + elapsed;
+		const elapsed = Math.max(0, (srcPtsMs - this.origin.srcAnchorMs) / this.rate);
+		const outMs = this.origin.outBaseMs + elapsed;
 		this.lastOutMs = Math.max(this.lastOutMs, outMs);
+		this.origin.highWaterMs = Math.max(this.origin.highWaterMs, this.lastOutMs);
 		return Math.round(this.lastOutMs * this.rateHz / 1e3);
 	}
 	/**
@@ -26773,8 +26820,8 @@ var MonotonicClock = class {
 	* rate-scaled.
 	*/
 	markDiscontinuity(gapMs) {
-		this.outBaseMs = this.lastOutMs + gapMs;
-		this.srcAnchorMs = null;
+		this.origin.outBaseMs = this.origin.highWaterMs + gapMs;
+		this.origin.srcAnchorMs = null;
 		this.lastSrcMs = null;
 	}
 	/**
@@ -26786,9 +26833,9 @@ var MonotonicClock = class {
 	*/
 	setRate(rate) {
 		if (!(rate > 0) || rate === this.rate) return;
-		if (this.srcAnchorMs !== null && this.lastSrcMs !== null) {
-			this.outBaseMs = this.lastOutMs;
-			this.srcAnchorMs = this.lastSrcMs;
+		if (this.origin.srcAnchorMs !== null && this.lastSrcMs !== null) {
+			this.origin.outBaseMs = this.lastOutMs;
+			this.origin.srcAnchorMs = this.lastSrcMs;
 		}
 		this.rate = rate;
 	}
@@ -27627,7 +27674,14 @@ function emptyPlayCensus() {
 }
 var RecordedFeeder = class {
 	deps;
-	clock = new MonotonicClock();
+	/**
+	* ONE origin for both tracks. Two independent ones replaced the real A/V
+	* offset with the interleave gap at every seek, in the same direction each
+	* time — measured at 23 ms per seek on the clock alone and 900 ms over
+	* three seeks on a real clip. See `FeedOrigin`.
+	*/
+	feedOrigin = new FeedOrigin();
+	clock = new MonotonicClock(9e4, this.feedOrigin);
 	/** Audio clock (PCMU 8 kHz / Opus 48 kHz); re-anchored together with video. */
 	audioClock;
 	clockHasAdvanced = false;
@@ -27810,7 +27864,7 @@ var RecordedFeeder = class {
 	lastAnnouncedState = null;
 	constructor(deps) {
 		this.deps = deps;
-		this.audioClock = new MonotonicClock(deps.audioClockRateHz ?? 8e3);
+		this.audioClock = new MonotonicClock(deps.audioClockRateHz ?? 8e3, this.feedOrigin);
 		this.scrubCache = deps.fragmentCache ?? new ScrubFragmentCache();
 	}
 	/**
@@ -30077,9 +30131,46 @@ var TimelineSession = class {
 		this.lastPositionMs = null;
 		const feeder = this.enterRecorded();
 		await feeder.seek(offsetMs);
+		this.reportClipTransport(clipId, feeder);
 		await Promise.all([this.reportClipDuration(clipId, feeder), this.reportClipAudio(clipId, feeder)]);
 	}
 	/**
+	* Tell the viewer what this clip can be driven to do.
+	*
+	* A clip served from the provider's stream is forward-only; one fetched as
+	* a file is not. Without the answer the viewer draws the same progress bar
+	* for both, and on the stream a backward drag is refused and the position
+	* re-sent — a control that visibly undoes the operator's gesture, which
+	* reads as broken rather than as unavailable (D62).
+	*
+	* A feeder that does not say sends nothing: silence is "the freedom you
+	* always had", and claiming `free` for a feeder that never answered would
+	* be this surface inventing a capability.
+	*/
+	reportClipTransport(clipId, feeder) {
+		const report = feeder.transport;
+		if (report === void 0) {
+			this.deps.onLog?.("clip playback: transport not reported — this feeder cannot say", {
+				deviceId: this.deps.deviceId,
+				clipId
+			});
+			return;
+		}
+		if (this.clip?.clipId !== clipId) return;
+		this.deps.onLog?.("clip playback: transport reported", {
+			deviceId: this.deps.deviceId,
+			clipId,
+			seek: report.seek,
+			stepBack: report.stepBack
+		});
+		this.deps.session.sendControl(serializeServerMessage({
+			t: "clipTransport",
+			clipId,
+			seek: report.seek,
+			stepBack: report.stepBack
+		}));
+	}
+	/**
 	* Tell the viewer whether this clip has sound.
 	*
 	* Silence has three causes the operator cannot tell apart by listening —
@@ -31617,6 +31708,16 @@ function createClipStreamFeeder(deps) {
 }
 var ClipStreamFeeder = class {
 	deps;
+	/**
+	* Forward-only, and no backward frame-step: the bytes behind the head were
+	* never kept, and the camera offers no replay-from-offset. Stated here so
+	* the viewer can DISABLE those verbs rather than offer them and have every
+	* use refused — the whole content of this report.
+	*/
+	transport = {
+		seek: "forward",
+		stepBack: false
+	};
 	phase = "idle";
 	connection = null;
 	demuxer;

package/dist/stream-broker/index.mjs

@@ -26688,6 +26688,14 @@ var ServerMessageSchema = discriminatedUnion("t", [
 		clipId: string().min(1),
 		durationMs: number().positive()
 	}),
+	object({
+		t: literal("clipTransport"),
+		clipId: string().min(1),
+		/** `forward` = only ahead of the playhead. `free` = anywhere. */
+		seek: _enum(["forward", "free"]),
+		/** Frame-step BACKWARD is meaningful. Forward always is. */
+		stepBack: boolean()
+	}),
 	object({
 		t: literal("clipAudio"),
 		clipId: string().min(1),
@@ -26718,11 +26726,49 @@ function serializeServerMessage(msg) {
 //#endregion
 //#region src/stream-broker/recorded/feed-clock.ts
 /**
+* The ORIGIN two tracks are measured from — the base and the source anchor,
+* shared, so the offset between video and audio survives a discontinuity.
+*
+* ## Why this exists
+*
+* `markDiscontinuity` re-bases on the last output. With one instance per
+* track, that last output is the TRACK'S own, and the two differ by however
+* far apart the interleave left them — so every seek replaced the real A/V
+* offset with that gap, in the same direction each time. Measured on the
+* clock alone it grows by a fixed step each time and never comes back; how
+* big that step is, is the interleave's business — 10–23 ms a seek on a
+* synthetic fixture, **900 ms over three seeks on a real clip**.
+*
+* Calling `markSeek()` on both instances "together" did not help and could
+* not: it is not the CALL that has to be shared, it is the ORIGIN. With one,
+* `out_video − out_audio` is `(vPts − aPts) / rate` — exactly the source
+* offset, which is the entire content of lip sync — and there is nothing left
+* to keep in step.
+*
+* `lastOutMs` stays per-track: monotonicity is a promise to ONE receiver
+* track, and clamping video against audio's last stamp would move video.
+*/
+var FeedOrigin = class {
+	/** Output ms the current run is measured from. */
+	outBaseMs = 0;
+	/** Source ms the current run is measured from; `null` until the next stamp. */
+	srcAnchorMs = null;
+	/**
+	* The furthest EITHER track has been stamped. What a discontinuity clears,
+	* so the gap is opened past both — and so two clocks marking the same
+	* discontinuity in a row produce one gap, not two.
+	*/
+	highWaterMs = 0;
+};
+/**
 * Maps arbitrary, possibly-resetting source PTS (ms) onto a strictly increasing
 * output clock at `rateHz` (default 90 kHz video; pass 8000 for PCMU audio). On
 * seek the output keeps advancing while the source anchor re-bases, so
-* per-segment PTS resets never rewind the track. Video and audio use SEPARATE
-* instances that `markSeek()` together to stay A/V aligned across boundaries.
+* per-segment PTS resets never rewind the track.
+*
+* Video and audio are separate instances SHARING one {@link FeedOrigin} — see
+* there for what happens when they do not. An instance constructed without one
+* gets its own, so a lone clock behaves exactly as it always did.
 *
 * Playback rate: `setRate(r)` divides SOURCE elapsed time by `r` on the output
 * timeline (2× → half the output spacing → the receiver plays frames twice as
@@ -26732,20 +26778,21 @@ function serializeServerMessage(msg) {
 */
 var MonotonicClock = class {
 	rateHz;
-	srcAnchorMs = null;
 	lastSrcMs = null;
-	outBaseMs = 0;
 	lastOutMs = 0;
 	rate = 1;
-	constructor(rateHz = 9e4) {
+	origin;
+	constructor(rateHz = 9e4, origin) {
 		this.rateHz = rateHz;
+		this.origin = origin ?? new FeedOrigin();
 	}
 	stamp(srcPtsMs) {
-		if (this.srcAnchorMs === null) this.srcAnchorMs = srcPtsMs;
+		if (this.origin.srcAnchorMs === null) this.origin.srcAnchorMs = srcPtsMs;
 		this.lastSrcMs = srcPtsMs;
-		const elapsed = Math.max(0, (srcPtsMs - this.srcAnchorMs) / this.rate);
-		const outMs = this.outBaseMs + elapsed;
+		const elapsed = Math.max(0, (srcPtsMs - this.origin.srcAnchorMs) / this.rate);
+		const outMs = this.origin.outBaseMs + elapsed;
 		this.lastOutMs = Math.max(this.lastOutMs, outMs);
+		this.origin.highWaterMs = Math.max(this.origin.highWaterMs, this.lastOutMs);
 		return Math.round(this.lastOutMs * this.rateHz / 1e3);
 	}
 	/**
@@ -26769,8 +26816,8 @@ var MonotonicClock = class {
 	* rate-scaled.
 	*/
 	markDiscontinuity(gapMs) {
-		this.outBaseMs = this.lastOutMs + gapMs;
-		this.srcAnchorMs = null;
+		this.origin.outBaseMs = this.origin.highWaterMs + gapMs;
+		this.origin.srcAnchorMs = null;
 		this.lastSrcMs = null;
 	}
 	/**
@@ -26782,9 +26829,9 @@ var MonotonicClock = class {
 	*/
 	setRate(rate) {
 		if (!(rate > 0) || rate === this.rate) return;
-		if (this.srcAnchorMs !== null && this.lastSrcMs !== null) {
-			this.outBaseMs = this.lastOutMs;
-			this.srcAnchorMs = this.lastSrcMs;
+		if (this.origin.srcAnchorMs !== null && this.lastSrcMs !== null) {
+			this.origin.outBaseMs = this.lastOutMs;
+			this.origin.srcAnchorMs = this.lastSrcMs;
 		}
 		this.rate = rate;
 	}
@@ -27623,7 +27670,14 @@ function emptyPlayCensus() {
 }
 var RecordedFeeder = class {
 	deps;
-	clock = new MonotonicClock();
+	/**
+	* ONE origin for both tracks. Two independent ones replaced the real A/V
+	* offset with the interleave gap at every seek, in the same direction each
+	* time — measured at 23 ms per seek on the clock alone and 900 ms over
+	* three seeks on a real clip. See `FeedOrigin`.
+	*/
+	feedOrigin = new FeedOrigin();
+	clock = new MonotonicClock(9e4, this.feedOrigin);
 	/** Audio clock (PCMU 8 kHz / Opus 48 kHz); re-anchored together with video. */
 	audioClock;
 	clockHasAdvanced = false;
@@ -27806,7 +27860,7 @@ var RecordedFeeder = class {
 	lastAnnouncedState = null;
 	constructor(deps) {
 		this.deps = deps;
-		this.audioClock = new MonotonicClock(deps.audioClockRateHz ?? 8e3);
+		this.audioClock = new MonotonicClock(deps.audioClockRateHz ?? 8e3, this.feedOrigin);
 		this.scrubCache = deps.fragmentCache ?? new ScrubFragmentCache();
 	}
 	/**
@@ -30073,9 +30127,46 @@ var TimelineSession = class {
 		this.lastPositionMs = null;
 		const feeder = this.enterRecorded();
 		await feeder.seek(offsetMs);
+		this.reportClipTransport(clipId, feeder);
 		await Promise.all([this.reportClipDuration(clipId, feeder), this.reportClipAudio(clipId, feeder)]);
 	}
 	/**
+	* Tell the viewer what this clip can be driven to do.
+	*
+	* A clip served from the provider's stream is forward-only; one fetched as
+	* a file is not. Without the answer the viewer draws the same progress bar
+	* for both, and on the stream a backward drag is refused and the position
+	* re-sent — a control that visibly undoes the operator's gesture, which
+	* reads as broken rather than as unavailable (D62).
+	*
+	* A feeder that does not say sends nothing: silence is "the freedom you
+	* always had", and claiming `free` for a feeder that never answered would
+	* be this surface inventing a capability.
+	*/
+	reportClipTransport(clipId, feeder) {
+		const report = feeder.transport;
+		if (report === void 0) {
+			this.deps.onLog?.("clip playback: transport not reported — this feeder cannot say", {
+				deviceId: this.deps.deviceId,
+				clipId
+			});
+			return;
+		}
+		if (this.clip?.clipId !== clipId) return;
+		this.deps.onLog?.("clip playback: transport reported", {
+			deviceId: this.deps.deviceId,
+			clipId,
+			seek: report.seek,
+			stepBack: report.stepBack
+		});
+		this.deps.session.sendControl(serializeServerMessage({
+			t: "clipTransport",
+			clipId,
+			seek: report.seek,
+			stepBack: report.stepBack
+		}));
+	}
+	/**
 	* Tell the viewer whether this clip has sound.
 	*
 	* Silence has three causes the operator cannot tell apart by listening —
@@ -31613,6 +31704,16 @@ function createClipStreamFeeder(deps) {
 }
 var ClipStreamFeeder = class {
 	deps;
+	/**
+	* Forward-only, and no backward frame-step: the bytes behind the head were
+	* never kept, and the camera offers no replay-from-offset. Stated here so
+	* the viewer can DISABLE those verbs rather than offer them and have every
+	* use refused — the whole content of this report.
+	*/
+	transport = {
+		seek: "forward",
+		stepBack: false
+	};
 	phase = "idle";
 	connection = null;
 	demuxer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.285",
+  "version": "1.2.286",
   "description": "Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",