+ Occupied card space
+
+ @@ -760,13 +724,6 @@ export function ContextMenu() { })}
, ); - const choices = watchedState.loading - ? [] - : summary?.status === "watched" - ? [false] - : summary?.status === "unwatched" - ? [true] - : [true, false]; choices.forEach((on, index) => items.push(
{mark && mark !== failedMark ? (
- 
setFailedMark(mark)}
- />
+ <>
+
+ setFailedMark(mark)}
+ />
+
) : (
) => {
event.preventDefault();
event.stopPropagation();
- const target = event.target instanceof Element
- ? event.target.closest("button, [href], [tabindex]:not([tabindex='-1'])")
- : null;
+ const target =
+ event.target instanceof Element
+ ? event.target.closest("button, [href], [tabindex]:not([tabindex='-1'])")
+ : null;
anchor.current = target && event.currentTarget.contains(target) ? target : event.currentTarget;
setTarget({
item,
@@ -187,8 +173,10 @@ export function useMusicItemMenu(handlers: Handlers) {
return {
open,
close,
- openFor: (item: MusicCatalogItem, index = 0) => (event: MouseEvent) =>
- open(item, index, event),
+ openFor:
+ (item: MusicCatalogItem, index = 0) =>
+ (event: MouseEvent) =>
+ open(item, index, event),
isOpen: target !== null,
menu: (
{
const context = src.homeServer;
if (!context) throw new Error("This is not home-server playback.");
@@ -50,10 +45,17 @@ export function useLastPlaybackContinuation() {
const view = useView();
const { activeProfile } = useProfiles();
const { user } = useAuth();
- const revision = useSyncExternalStore(subscribePlayback, snapshotVersion, snapshotVersion);
- const target = useMemo(() => readLastActualPlayback(), [revision, activeProfile?.id, user?._id]);
+ const revision = useSyncExternalStore(
+ subscribePlayback,
+ getPlaybackRevision,
+ getPlaybackRevision,
+ );
const currentActor = capturePlaybackActor();
const actorKey = JSON.stringify(currentActor);
+ const target = useMemo(
+ () => readLastActualPlayback(),
+ [revision, activeProfile?.id, user?._id, actorKey],
+ );
const operation = useRef<{ actorKey: string; token: object | null; mounted: boolean }>({
actorKey,
token: null,
diff --git a/src/lib/addon-configuration-key.ts b/src/lib/addon-configuration-key.ts
index 27d825677..423ad8407 100644
--- a/src/lib/addon-configuration-key.ts
+++ b/src/lib/addon-configuration-key.ts
@@ -1,8 +1,40 @@
import { sha256 } from "@noble/hashes/sha256";
import { bytesToHex } from "@noble/hashes/utils";
+import type { AddonOrigin } from "./cinemeta";
export function addonConfigurationKey(base: string): string | undefined {
if (!/^https?:\/\//i.test(base)) return undefined;
const normalized = base.replace(/\/manifest\.json$/, "");
return bytesToHex(sha256(new TextEncoder().encode(normalized)));
}
+
+export function persistableAddonOrigin(origin: unknown): AddonOrigin | undefined {
+ if (!origin || typeof origin !== "object") return undefined;
+ const value = origin as {
+ id?: unknown;
+ name?: unknown;
+ logo?: unknown;
+ base?: unknown;
+ configurationKey?: unknown;
+ };
+ if (typeof value.id !== "string" || !value.id) return undefined;
+ // Plugin catalogue identifiers pin saved rows to their provider. Network transport URLs can
+ // contain credentials; resolve those from the installed addon configuration instead.
+ const base =
+ typeof value.base === "string" &&
+ /^harbor-plugin:\/\/[A-Za-z0-9._:-]+(?:\/[A-Za-z0-9._:-]+)*$/.test(value.base)
+ ? value.base
+ : undefined;
+ const configurationKey =
+ (typeof value.base === "string" ? addonConfigurationKey(value.base) : undefined) ??
+ (typeof value.configurationKey === "string" && /^[a-f0-9]{64}$/.test(value.configurationKey)
+ ? value.configurationKey
+ : undefined);
+ return {
+ id: value.id,
+ name: typeof value.name === "string" && value.name ? value.name : value.id,
+ logo: typeof value.logo === "string" ? value.logo : undefined,
+ ...(base ? { base } : {}),
+ ...(configurationKey ? { configurationKey } : {}),
+ };
+}
diff --git a/src/lib/cinemeta.ts b/src/lib/cinemeta.ts
index 41a291b86..a3f9981fb 100644
--- a/src/lib/cinemeta.ts
+++ b/src/lib/cinemeta.ts
@@ -1,6 +1,6 @@
import { withMetaCache } from "@/lib/cinemeta-cache";
import { safeFetch as fetch } from "@/lib/safe-fetch";
-import { addonConfigurationKey } from "@/lib/addon-configuration-key";
+export { persistableAddonOrigin } from "./addon-configuration-key";
const CINEMETA = "https://v3-cinemeta.strem.io";
@@ -87,37 +87,6 @@ export type Meta = {
}>;
};
-export function persistableAddonOrigin(origin: unknown): AddonOrigin | undefined {
- if (!origin || typeof origin !== "object") return undefined;
- const value = origin as {
- id?: unknown;
- name?: unknown;
- logo?: unknown;
- base?: unknown;
- configurationKey?: unknown;
- };
- if (typeof value.id !== "string" || !value.id) return undefined;
- // Plugin catalogue identifiers pin saved rows to their provider. Network transport URLs can
- // contain credentials; resolve those from the installed addon configuration instead.
- const base =
- typeof value.base === "string" &&
- /^harbor-plugin:\/\/[A-Za-z0-9._:-]+(?:\/[A-Za-z0-9._:-]+)*$/.test(value.base)
- ? value.base
- : undefined;
- const configurationKey =
- (typeof value.base === "string" ? addonConfigurationKey(value.base) : undefined) ??
- (typeof value.configurationKey === "string" && /^[a-f0-9]{64}$/.test(value.configurationKey)
- ? value.configurationKey
- : undefined);
- return {
- id: value.id,
- name: typeof value.name === "string" && value.name ? value.name : value.id,
- logo: typeof value.logo === "string" ? value.logo : undefined,
- ...(base ? { base } : {}),
- ...(configurationKey ? { configurationKey } : {}),
- };
-}
-
export function hasEmbeddedStreams(videos: Meta["videos"]): boolean {
return videos?.some((v) => Array.isArray(v.streams) && v.streams.length > 0) === true;
}
diff --git a/src/lib/context-actions.ts b/src/lib/context-actions.ts
index d63dde782..6eada7c52 100644
--- a/src/lib/context-actions.ts
+++ b/src/lib/context-actions.ts
@@ -28,7 +28,6 @@ export type ContextAction = {
checked?: boolean;
dismiss?: "on-success" | "keep-open";
confirmation?: ActionConfirmation;
- quickCopy?: boolean;
searchable?: boolean;
searchPlaceholder?: string;
submenuVariant?: "navigation";
diff --git a/src/lib/context-menu.tsx b/src/lib/context-menu.tsx
index f3fe4a8d9..d6ce6a815 100644
--- a/src/lib/context-menu.tsx
+++ b/src/lib/context-menu.tsx
@@ -75,7 +75,6 @@ export type ContextMenuTarget = ContentContext & {
| { kind: "ebook"; id: string }
| { kind: "nav"; itemId?: NavItemId; view?: View; label?: string; onOpen?: () => void }
| { kind: "edit"; element: HTMLElement | null; selection: string }
- | { kind: "backdrop"; metaId: string; url: string }
| {
kind: "subtitle";
label: string;
diff --git a/src/lib/context-page-background.ts b/src/lib/context-page-background.ts
index 8d6afd77d..b8c1fa88b 100644
--- a/src/lib/context-page-background.ts
+++ b/src/lib/context-page-background.ts
@@ -6,6 +6,9 @@ const OWNED_CONTENT = [
"select",
"option",
"iframe",
+ "img",
+ "picture",
+ "svg",
"canvas",
"video",
"audio",
@@ -16,6 +19,8 @@ const OWNED_CONTENT = [
"[role='textbox']",
"[data-harbor-context-layer]",
"[data-harbor-player]",
+ "[data-harbor-image-viewer]",
+ "[data-title-backdrop]",
"[data-ebook-page]",
"[data-bp-root]",
"[data-bp-focusable]",
@@ -33,3 +38,29 @@ export function isPageContextBackground(target: Element | null): boolean {
)
);
}
+
+/** A generic action target is not page space. Only the trusted page binding can
+ * opt in, and content under the pointer always keeps its own context. */
+export function isBackgroundMenuTarget(
+ target:
+ | {
+ kind: string;
+ scope?: "page-background";
+ navigation?: boolean;
+ image?: unknown;
+ link?: string;
+ selection?: string;
+ }
+ | null
+ | undefined,
+): boolean {
+ return (
+ !!target &&
+ target.kind === "actions" &&
+ target.scope === "page-background" &&
+ target.navigation !== false &&
+ !target.image &&
+ !target.link &&
+ !target.selection
+ );
+}
diff --git a/src/lib/context-quick-actions.ts b/src/lib/context-quick-actions.ts
index f1db7f031..dceeb8f41 100644
--- a/src/lib/context-quick-actions.ts
+++ b/src/lib/context-quick-actions.ts
@@ -1,4 +1,6 @@
import { findAction, type ContextAction } from "./context-actions";
+import type { ContextMenuTarget } from "./context-menu";
+import { isBackgroundMenuTarget } from "./context-page-background";
export function omitContextActions(
actions: ContextAction[],
@@ -16,22 +18,22 @@ export function partitionContextActions(
entity: ContextAction[],
content: ContextAction[],
navigation: ContextAction[],
+ target?: ContextMenuTarget,
): { quick: ContextAction[]; entity: ContextAction[]; content: ContextAction[] } {
- const find = findAction;
- const copy = [
- entity.find((action) => action.quickCopy),
- find(content, "image:copy"),
- find(content, "link:copy"),
- find(content, "selection:copy"),
- ].find((action) => action && !action.disabled);
- const quick = [find(navigation, "page:back"), copy, find(navigation, "page:go:settings")].filter(
- (action): action is ContextAction => !!action,
+ const quick = (
+ isBackgroundMenuTarget(target)
+ ? [findAction(navigation, "page:back"), findAction(navigation, "page:go:settings")]
+ : []
+ ).filter((action): action is ContextAction => !!action);
+ // Page commands are exclusively rendered in the background strip/footer.
+ // Item copy commands remain in their original command list.
+ const moved = new Set(
+ entity.filter((action) => action.id.startsWith("page:")).map((action) => action.id),
);
- const moved = new Set(quick.map((action) => action.id));
return {
quick,
entity: omitContextActions(entity, moved),
- content: omitContextActions(content, moved),
+ content,
};
}
diff --git a/src/lib/continue-card-actions.ts b/src/lib/continue-card-actions.ts
index eedf235cc..0ac47a88c 100644
--- a/src/lib/continue-card-actions.ts
+++ b/src/lib/continue-card-actions.ts
@@ -33,7 +33,7 @@ export function createContinueCardActions(options: {
dismiss?: () => void | CwDismissResult | Promise;
onDismissed?: (result: void | CwDismissResult) => void;
onError?: (error: unknown) => void;
- icons?: { play: ReactNode; sources: ReactNode; dismiss: ReactNode };
+ icons?: { sources: ReactNode; dismiss: ReactNode };
}) {
const identity = continueCardIdentity(options.item);
const listeners = new Set<() => void>();
@@ -92,15 +92,6 @@ export function createContinueCardActions(options: {
const disabled = pending || !isValid() || waitingForAir();
const reason = waitingForAir() ? options.t("This episode has not aired yet.") : undefined;
return [
- {
- id: `continue:play:${identity}`,
- label: options.t("Continue watching"),
- icon: options.icons?.play,
- disabled,
- reason,
- restoreFocus: false,
- run: () => run("play"),
- },
{
id: `continue:sources:${identity}`,
label: options.t("Choose another source"),
@@ -110,30 +101,24 @@ export function createContinueCardActions(options: {
restoreFocus: false,
run: () => run("sources"),
},
+ ...(options.dismiss
+ ? [
+ {
+ id: `continue:dismiss:${identity}`,
+ label: options.t("Remove from Continue Watching"),
+ icon: options.icons?.dismiss,
+ disabled: pending || removed || !options.isCurrent(),
+ restoreFocus: false,
+ run: () => run("dismiss"),
+ },
+ ]
+ : []),
];
},
};
- const extra: ActionSource = {
- isValid,
- subscribe,
- actions: () =>
- options.dismiss
- ? [
- {
- id: `continue:dismiss:${identity}`,
- label: options.t("Remove from Continue Watching"),
- icon: options.icons?.dismiss,
- disabled: pending || removed || !options.isCurrent(),
- restoreFocus: false,
- run: () => run("dismiss"),
- },
- ]
- : [],
- };
return {
isValid,
primary,
- extra,
subscribe,
isPending: () => pending,
play: () => run("play"),
diff --git a/src/lib/i18n/locales/ar/context-actions.ts b/src/lib/i18n/locales/ar/context-actions.ts
index aa7be4688..109bea07b 100644
--- a/src/lib/i18n/locales/ar/context-actions.ts
+++ b/src/lib/i18n/locales/ar/context-actions.ts
@@ -17,6 +17,12 @@ const contextActions: Record = {
"Play this same video from the beginning?": "تشغيل الفيديو نفسه من البداية؟",
"Opening playback…": "جارٍ فتح التشغيل…",
"Continue last watched": "متابعة آخر مشاهدة",
+ "Resume last watched": "استكمال آخر مشاهدة",
+ "The saved audio track could not be restored. Choose an audio track.":
+ "تعذّر استعادة مسار الصوت المحفوظ. اختر مسار صوت.",
+ "The saved subtitle could not be restored. Choose a subtitle.":
+ "تعذّر استعادة الترجمة المحفوظة. اختر ترجمة.",
+ "The saved subtitle timing could not be restored.": "تعذّر استعادة توقيت الترجمة المحفوظ.",
"Local video": "فيديو محلي",
"Open my profile": "فتح ملفي الشخصي",
"Add to page": "إضافة إلى صفحة",
@@ -512,6 +518,8 @@ const contextActions: Record = {
"هناك فيديو آخر قيد التشغيل. عُد إلى المشغّل أولًا.",
"The last video file is missing or unavailable.": "ملف الفيديو الأخير مفقود أو غير متاح.",
"The last playback source is no longer available.": "لم يعد مصدر آخر مشاهدة متاحًا.",
+ "Open this video from its source or enter the link again. Its network address was not saved.":
+ "افتح الفيديو من مصدره أو أدخل الرابط مجددًا. لم يُحفظ عنوانه الشبكي.",
"Playback changed. Open the menu again.": "تغيّر التشغيل. افتح القائمة مجددًا.",
"Playback controls are not available in this session.":
"أدوات التحكم بالتشغيل غير متاحة في هذه الجلسة.",
diff --git a/src/lib/i18n/locales/context-actions-fallback.ts b/src/lib/i18n/locales/context-actions-fallback.ts
index 3c6100da2..80d6855fe 100644
--- a/src/lib/i18n/locales/context-actions-fallback.ts
+++ b/src/lib/i18n/locales/context-actions-fallback.ts
@@ -19,6 +19,13 @@ const contextActionsFallback: Record = {
"Play this same video from the beginning?": "Play this same video from the beginning?",
"Opening playback…": "Opening playback…",
"Continue last watched": "Continue last watched",
+ "Resume last watched": "Resume last watched",
+ "The saved audio track could not be restored. Choose an audio track.":
+ "The saved audio track could not be restored. Choose an audio track.",
+ "The saved subtitle could not be restored. Choose a subtitle.":
+ "The saved subtitle could not be restored. Choose a subtitle.",
+ "The saved subtitle timing could not be restored.":
+ "The saved subtitle timing could not be restored.",
"Local video": "Local video",
"Open my profile": "Open my profile",
"Add to page": "Add to page",
@@ -541,6 +548,8 @@ const contextActionsFallback: Record = {
"The last video file is missing or unavailable.",
"The last playback source is no longer available.":
"The last playback source is no longer available.",
+ "Open this video from its source or enter the link again. Its network address was not saved.":
+ "Open this video from its source or enter the link again. Its network address was not saved.",
"Playback changed. Open the menu again.": "Playback changed. Open the menu again.",
"Playback controls are not available in this session.":
"Playback controls are not available in this session.",
diff --git a/src/lib/membership-actions.ts b/src/lib/membership-actions.ts
index ad60d9cbb..c5c409cbd 100644
--- a/src/lib/membership-actions.ts
+++ b/src/lib/membership-actions.ts
@@ -221,7 +221,7 @@ export function buildMembershipActionSource(options: Options): ActionSource {
const actions: ContextAction[] = [
{
id: "membership:add",
- label: t("Add to"),
+ label: t("Add to list"),
icon: options.commandIcon?.("add"),
group: "membership",
disabled: !available,
diff --git a/src/lib/playback-history.ts b/src/lib/playback-history.ts
index d843c2338..267622524 100644
--- a/src/lib/playback-history.ts
+++ b/src/lib/playback-history.ts
@@ -2,13 +2,33 @@ import { useSyncExternalStore } from "react";
import type { AddonProgress } from "./streams/addons";
import type { PlayerSrc } from "./view";
import type { PlaybackAudioChoice } from "./player/audio-choice";
+import type { PlaybackSubtitleChoice } from "./player/subtitle-choice";
+import {
+ persistablePlaybackSource,
+ persistablePlaybackSubtitle,
+ persistablePlaybackUrl,
+ playbackUrlFingerprint,
+ persistablePlaybackFields,
+ persistablePlaybackIdentity,
+ persistablePlaybackPreference,
+} from "./player/playback-history-source";
import { noteNotify } from "./render-cause";
+import { subtitleMediaKey, subtitleStreamKey } from "./subtitles/subtitle-memory";
+import {
+ activeScopedProfileId,
+ isNuvioProviderActive,
+ stremioProfileId,
+} from "./active-profile-id";
+import { cwProfileScope } from "./cw-profile";
+
+type ActualPlaybackState = { actual?: ActualPlayback };
export type PlaybackEntry = {
infoHash?: string | null;
fileIdx?: number | null;
addonId?: string | null;
url?: string | null;
+ urlFingerprint?: string;
title?: string | null;
parsedTitle?: string | null;
resolution?: string | null;
@@ -21,12 +41,16 @@ export type PlaybackEntry = {
savedAt: number;
/** Written by observed player activity, never by source selection or watched edits. */
actual?: ActualPlayback;
+ /** Same history, with observed ownership retained when private CW is enabled. */
+ actualByProfile?: Record;
};
export type PlaybackActor = {
profileId: string;
storageProfileId: string;
accountId: string | null;
+ provider?: "nuvio";
+ privateCw?: boolean;
};
export type ActualPlayback = {
@@ -37,8 +61,12 @@ export type ActualPlayback = {
durationMs: number;
completed: boolean;
src: Omit;
+ sourceFingerprint?: string;
requiresSourceRefresh?: boolean;
audioTrack?: PlaybackAudioChoice;
+ subtitle?: PlaybackSubtitleChoice;
+ subDelaySec?: number;
+ audioDelaySec?: number;
};
export type PlaybackContinuation = {
@@ -46,9 +74,13 @@ export type PlaybackContinuation = {
positionMs: number;
source: Omit;
sourceKey: string;
+ target?: { metaId: string; season?: number; episode?: number };
actor: PlaybackActor;
restart?: boolean;
audioTrack?: PlaybackAudioChoice;
+ subtitle?: PlaybackSubtitleChoice;
+ subDelaySec?: number;
+ audioDelaySec?: number;
};
const STORAGE_KEY_PREFIX = "harbor.playback-history.v1.";
@@ -58,8 +90,39 @@ const TTL_MS = 30 * 24 * 60 * 60 * 1000;
const MAX_ENTRIES = 200;
const listeners = new Set<() => void>();
+let playbackRevision = 0;
+
+export function getPlaybackRevision(): number {
+ return playbackRevision;
+}
+
+function notifyPlayback(): void {
+ playbackRevision += 1;
+ noteNotify("store:playback");
+ listeners.forEach((listener) => listener());
+}
+
+function nuvioAccountId(): string | null {
+ try {
+ const raw =
+ localStorage.getItem("harbor.nuvio.state.v1") ?? localStorage.getItem("harbor.nuvio.state");
+ const userId = JSON.parse(raw ?? "null")?.session?.user?.id;
+ return typeof userId === "string" && userId ? userId : null;
+ } catch {
+ return null;
+ }
+}
export function capturePlaybackActor(): PlaybackActor {
+ if (isNuvioProviderActive()) {
+ const profileId = activeScopedProfileId();
+ return {
+ profileId,
+ storageProfileId: profileId,
+ accountId: nuvioAccountId(),
+ provider: "nuvio",
+ };
+ }
const storageProfileId = activeProfileId();
try {
const state = JSON.parse(localStorage.getItem(PROFILES_KEY) ?? "null") as {
@@ -74,6 +137,7 @@ export function capturePlaybackActor(): PlaybackActor {
profileId: state?.activeId ?? storageProfileId,
storageProfileId,
accountId: session?.user?._id ?? null,
+ ...(cwProfileScope().private ? { privateCw: true } : {}),
};
} catch {
return { profileId: storageProfileId, storageProfileId, accountId: null };
@@ -85,30 +149,14 @@ export function isPlaybackActorCurrent(actor: PlaybackActor): boolean {
return (
current.profileId === actor.profileId &&
current.storageProfileId === actor.storageProfileId &&
- current.accountId === actor.accountId
+ current.accountId === actor.accountId &&
+ current.provider === actor.provider &&
+ !!current.privateCw === !!actor.privateCw
);
}
function activeProfileId(): string {
- try {
- const raw = localStorage.getItem(PROFILES_KEY);
- if (!raw) return "";
- const s = JSON.parse(raw) as {
- activeId?: string;
- profiles?: Array<{ id?: string; isPrimary?: boolean; shareStremioWith?: string | null }>;
- };
- const profiles = Array.isArray(s.profiles) ? s.profiles : [];
- const active = profiles.find((p) => p.id === s.activeId) ?? null;
- const own = active?.id ?? profiles.find((p) => p?.isPrimary)?.id ?? "";
- if (!own) return "";
- if (active && typeof active.shareStremioWith === "string" && active.shareStremioWith) {
- const shared = profiles.find((p) => p.id === active.shareStremioWith);
- if (shared?.id) return shared.id;
- }
- return own;
- } catch {
- return "";
- }
+ return stremioProfileId();
}
function primaryProfileId(): string {
@@ -125,11 +173,15 @@ function primaryProfileId(): string {
}
function storeKey(): string {
+ if (isNuvioProviderActive()) {
+ return `${STORAGE_KEY_PREFIX}nuvio.${encodeURIComponent(nuvioAccountId() ?? "anon")}.${activeScopedProfileId()}`;
+ }
const id = activeProfileId();
return id ? STORAGE_KEY_PREFIX + id : LEGACY_STORAGE_KEY;
}
function migrateLegacy(): void {
+ if (isNuvioProviderActive()) return;
try {
const legacy = localStorage.getItem(LEGACY_STORAGE_KEY);
if (!legacy) return;
@@ -143,32 +195,163 @@ function migrateLegacy(): void {
}
}
+const scopeEvents = [
+ "storage",
+ "harbor:active-profile-changed",
+ "harbor:profiles-updated",
+ "harbor:settings-changed",
+ "harbor:nuvio-profile-changed",
+ "harbor:nuvio-state-changed",
+ "harbor:account-provider-changed",
+];
+let stopScopeEvents: (() => void) | null = null;
+
export function subscribePlayback(fn: () => void): () => void {
+ if (!stopScopeEvents && typeof window !== "undefined") {
+ const target = window;
+ let actorKey = JSON.stringify(capturePlaybackActor());
+ const onScopeChange = () => {
+ const next = JSON.stringify(capturePlaybackActor());
+ if (next === actorKey) return;
+ actorKey = next;
+ notifyPlayback();
+ };
+ for (const event of scopeEvents) target.addEventListener(event, onScopeChange);
+ stopScopeEvents = () => {
+ for (const event of scopeEvents) target.removeEventListener(event, onScopeChange);
+ };
+ }
listeners.add(fn);
return () => {
listeners.delete(fn);
+ if (listeners.size === 0) {
+ stopScopeEvents?.();
+ stopScopeEvents = null;
+ }
};
}
+function samePlaybackOwner(actual: ActualPlayback, actor: PlaybackActor): boolean {
+ return (
+ validActualPlayback(actual) &&
+ Date.now() - actual.playedAt <= TTL_MS &&
+ actual.actor.provider === actor.provider &&
+ actual.actor.storageProfileId === actor.storageProfileId &&
+ actual.actor.accountId === actor.accountId
+ );
+}
+
+function retainedActualProfiles(
+ entry: PlaybackEntry | undefined,
+ actor: PlaybackActor,
+): Record {
+ let profileIds = new Set([actor.profileId]);
+ if (!actor.provider) {
+ try {
+ const roster = JSON.parse(localStorage.getItem(PROFILES_KEY) ?? "null") as {
+ profiles?: Array<{ id: string }>;
+ } | null;
+ profileIds = new Set([
+ actor.profileId,
+ ...(roster?.profiles ?? []).map((profile) => profile.id),
+ ]);
+ } catch {
+ // Keep existing slots if the roster is temporarily unavailable.
+ profileIds = new Set([actor.profileId, ...Object.keys(entry?.actualByProfile ?? {})]);
+ }
+ }
+ return Object.fromEntries(
+ Object.entries(entry?.actualByProfile ?? {}).filter(
+ ([profileId, state]) =>
+ profileIds.has(profileId) &&
+ !!state?.actual &&
+ validActualPlayback(state.actual) &&
+ state.actual.actor.profileId === profileId &&
+ Date.now() - state.actual.playedAt <= TTL_MS,
+ ),
+ );
+}
+
+function ownActualState(
+ entry: PlaybackEntry | undefined,
+ actor: PlaybackActor,
+): ActualPlaybackState {
+ const own = entry?.actualByProfile?.[actor.profileId];
+ if (
+ own?.actual &&
+ own.actual.actor?.profileId === actor.profileId &&
+ samePlaybackOwner(own.actual, actor)
+ )
+ return { actual: own.actual };
+ // Old shared entries establish private ownership only through the observed actor.
+ return entry?.actual?.actor?.profileId === actor.profileId &&
+ samePlaybackOwner(entry.actual, actor)
+ ? { actual: entry.actual }
+ : {};
+}
+
+function selectedActualState(
+ entry: PlaybackEntry | undefined,
+ actor: PlaybackActor,
+): ActualPlaybackState {
+ const state = actor.privateCw ? ownActualState(entry, actor) : entry;
+ return state?.actual && samePlaybackOwner(state.actual, actor) ? { actual: state.actual } : {};
+}
+
function entryKey(metaId: string, season?: number, episode?: number): string {
+ metaId = persistablePlaybackIdentity(metaId);
if (typeof season === "number" && typeof episode === "number") {
return `${metaId}|s${season}e${episode}`;
}
return metaId;
}
-function readAll(): Record {
+function legacyEntryKey(key: string, entry: PlaybackEntry): string {
+ const observations = [
+ entry.actual,
+ ...Object.values(entry.actualByProfile ?? {}).map((state) => state?.actual),
+ ];
+ for (const actual of observations) {
+ const id = actual?.src?.meta?.id;
+ if (typeof id !== "string") continue;
+ const episode = actual?.src?.episode;
+ const suffix =
+ typeof episode?.season === "number" && typeof episode?.episode === "number"
+ ? `|s${episode.season}e${episode.episode}`
+ : "";
+ if (key === `${id}${suffix}`) return entryKey(id, episode?.season, episode?.episode);
+ }
+ if (typeof entry.url === "string" && key === `url:${entry.url}`) return entryKey(key);
+ const suffix = /^(.*)(\|s\d+e\d+)$/.exec(key);
+ return suffix
+ ? `${persistablePlaybackIdentity(suffix[1])}${suffix[2]}`
+ : persistablePlaybackIdentity(key);
+}
+
+function readAll(includeExpired = false): Record {
migrateLegacy();
try {
const raw = localStorage.getItem(storeKey());
if (!raw) return {};
const parsed = JSON.parse(raw) as Record;
const now = Date.now();
- const fresh: Record = {};
+ const fresh: Record = Object.create(null);
+ let scrubbed = false;
for (const [k, v] of Object.entries(parsed)) {
- if (!v?.savedAt) continue;
- if (now - v.savedAt > TTL_MS) continue;
- fresh[k] = v;
+ if (!v) continue;
+ const key = legacyEntryKey(k, v);
+ const safe = persistableEntry(v, key);
+ scrubbed ||= key !== k || JSON.stringify(safe) !== JSON.stringify(v);
+ if (!includeExpired && (!v.savedAt || now - v.savedAt > TTL_MS)) continue;
+ const previous = fresh[key];
+ fresh[key] = previous ? mergeHistoryEntries(previous, safe) : safe;
+ }
+ if (scrubbed) {
+ try {
+ localStorage.setItem(storeKey(), JSON.stringify(fresh));
+ } catch {
+ // Reads remain safe when storage is unavailable; a later read can retry.
+ }
}
return fresh;
} catch {
@@ -176,6 +359,33 @@ function readAll(): Record {
}
}
+function newerActual(
+ a: ActualPlayback | undefined,
+ b: ActualPlayback | undefined,
+): ActualPlayback | undefined {
+ if (!a || !validActualPlayback(a)) return b;
+ if (!b || !validActualPlayback(b)) return a;
+ return a.playedAt >= b.playedAt ? a : b;
+}
+
+// A partially migrated key can coexist with its old URL-derived spelling.
+// Preserve each profile's observed session when those keys converge.
+function mergeHistoryEntries(a: PlaybackEntry, b: PlaybackEntry): PlaybackEntry {
+ const profiles: Record = Object.assign(
+ Object.create(null),
+ a.actualByProfile,
+ );
+ for (const [id, state] of Object.entries(b.actualByProfile ?? {})) {
+ const actual = newerActual(profiles[id]?.actual, state.actual);
+ profiles[id] = { ...state, ...(actual ? { actual } : {}) };
+ }
+ return {
+ ...(a.savedAt >= b.savedAt ? a : b),
+ actual: newerActual(a.actual, b.actual),
+ ...(Object.keys(profiles).length ? { actualByProfile: profiles } : {}),
+ };
+}
+
function writeAll(map: Record): void {
try {
const keys = Object.keys(map);
@@ -183,25 +393,17 @@ function writeAll(map: Record): void {
const sorted = Object.entries(map).sort((a, b) => b[1].savedAt - a[1].savedAt);
map = Object.fromEntries(sorted.slice(0, MAX_ENTRIES));
}
- localStorage.setItem(storeKey(), JSON.stringify(map));
+ localStorage.setItem(storeKey(), JSON.stringify(persistableEntries(map)));
} catch {
// A failed replacement must leave the last persisted source/session intact.
return;
}
- noteNotify("store:playback");
- listeners.forEach((l) => l());
+ notifyPlayback();
}
export function playbackHistoryRawKeys(): string[] {
- migrateLegacy();
- try {
- const raw = localStorage.getItem(storeKey());
- if (!raw) return [];
- const parsed = JSON.parse(raw) as Record;
- return Object.keys(parsed);
- } catch {
- return [];
- }
+ // Statistics inspect every retained key; only regular history reads apply TTL.
+ return Object.keys(readAll(true));
}
export function savePlayback(
@@ -222,12 +424,20 @@ export function savePlayback(
parsedTitle: entry.parsedTitle ?? prev.parsedTitle,
savedAt: Date.now(),
}
- : { ...entry, actual: prev?.actual, savedAt: Date.now() };
+ : {
+ ...entry,
+ actual: prev?.actual,
+ actualByProfile: prev?.actualByProfile,
+ savedAt: Date.now(),
+ };
writeAll(all);
}
export function recordActualPlayback(playback: ActualPlayback): boolean {
- if (!isPlaybackActorCurrent(playback.actor) || !validActualPlayback(playback)) return false;
+ if (!isPlaybackActorCurrent(playback.actor)) return false;
+ const safe = persistableActualPlayback(playback);
+ if (!safe || !validActualPlayback(safe)) return false;
+ playback = safe;
const all = readAll();
const key = entryKey(
playback.src.meta.id,
@@ -235,47 +445,82 @@ export function recordActualPlayback(playback: ActualPlayback): boolean {
playback.src.episode?.episode,
);
const previous = all[key];
- const previousActual = previous?.actual;
+ const previousOwn = ownActualState(previous, playback.actor);
+ const previousActual = previousOwn.actual;
// mpv can clear its track list at natural EOF. That is not a new audio
// choice; keep only the last observed choice from this exact session.
- const actual =
+ const sameEndedSession =
playback.completed &&
- !playback.audioTrack &&
- previousActual?.audioTrack &&
+ previousActual &&
validActualPlayback(previousActual) &&
previousActual.id === playback.id &&
- isPlaybackActorCurrent(previousActual.actor) &&
- playbackSourceKey(previousActual.src) === playbackSourceKey(playback.src)
- ? { ...playback, audioTrack: previousActual.audioTrack }
- : playback;
+ actualPlaybackSourceKey(previousActual) === actualPlaybackSourceKey(playback);
+ const actual = sameEndedSession
+ ? {
+ ...playback,
+ audioTrack: playback.audioTrack ?? previousActual.audioTrack,
+ subtitle: playback.subtitle ?? previousActual.subtitle,
+ subDelaySec: playback.subDelaySec ?? previousActual.subDelaySec,
+ audioDelaySec: playback.audioDelaySec ?? previousActual.audioDelaySec,
+ }
+ : playback;
+ const shared = previous?.actual;
+ const updateShared =
+ !shared || !samePlaybackOwner(shared, playback.actor) || shared.playedAt <= actual.playedAt;
+ const updateOwn = !previousActual || previousActual.playedAt <= actual.playedAt;
const next = {
...all,
[key]: {
...previous,
title: previous?.title ?? playback.src.meta.name,
savedAt: Math.max(previous?.savedAt ?? 0, playback.playedAt),
- actual,
+ actual: updateShared ? actual : shared,
+ actualByProfile: {
+ ...retainedActualProfiles(previous, playback.actor),
+ ...(updateOwn
+ ? {
+ [playback.actor.profileId]: {
+ actual,
+ },
+ }
+ : {}),
+ },
},
};
const entries = Object.entries(next).sort((a, b) => b[1].savedAt - a[1].savedAt);
try {
localStorage.setItem(
storeKey(),
- JSON.stringify(Object.fromEntries(entries.slice(0, MAX_ENTRIES))),
+ JSON.stringify(persistableEntries(Object.fromEntries(entries.slice(0, MAX_ENTRIES)))),
);
} catch {
return false;
}
- noteNotify("store:playback");
- listeners.forEach((listener) => listener());
+ notifyPlayback();
return true;
}
function validActualPlayback(value: ActualPlayback): boolean {
+ const server = value?.src?.homeServer;
+ const stream = value?.src?.streamRef;
+ const refreshable =
+ !!value?.requiresSourceRefresh &&
+ (!!value.sourceFingerprint ||
+ !!stream?.infoHash ||
+ (!!stream?.addonId && !!stream.parsedTitle && !!stream.size && stream.size > 0));
+ const serverIdentity =
+ !!server &&
+ [server.connectionId, server.itemId, server.versionId].every(
+ (id) => typeof id === "string" && !!id,
+ ) &&
+ ["original", "4k-40", "1080p-20", "1080p-12", "720p-4", "480p-2", "360p-0.7"].includes(
+ server.quality,
+ );
return (
!!value &&
typeof value.id === "string" &&
!!value.id &&
+ typeof value.completed === "boolean" &&
Number.isFinite(value.playedAt) &&
Number.isFinite(value.positionMs) &&
value.positionMs >= 0 &&
@@ -284,28 +529,126 @@ function validActualPlayback(value: ActualPlayback): boolean {
!!value.actor &&
typeof value.actor.storageProfileId === "string" &&
typeof value.src?.url === "string" &&
- !!value.src.url &&
+ (server ? serverIdentity : !!value.src.url || refreshable) &&
typeof value.src?.meta?.id === "string" &&
!!value.src.meta.id &&
typeof value.src.meta.name === "string"
);
}
+function persistableActualPlayback(value: ActualPlayback): ActualPlayback | undefined {
+ if (!validActualPlayback(value)) return undefined;
+ const src = persistablePlaybackSource(value.src);
+ const actor = persistablePlaybackFields(value.actor, [
+ "profileId",
+ "storageProfileId",
+ "accountId",
+ "provider",
+ "privateCw",
+ ]);
+ if (
+ typeof actor.profileId !== "string" ||
+ typeof actor.storageProfileId !== "string" ||
+ !(actor.accountId === null || typeof actor.accountId === "string") ||
+ (actor.provider !== undefined && actor.provider !== "nuvio")
+ )
+ return undefined;
+ const audio = value.audioTrack
+ ? persistablePlaybackFields(value.audioTrack, [
+ "id",
+ "lang",
+ "title",
+ "codec",
+ "channels",
+ "channelCount",
+ ])
+ : undefined;
+ const audioValid =
+ audio &&
+ typeof audio.id === "string" &&
+ (["lang", "title", "codec", "channels"] as const).every(
+ (key) => audio[key] === undefined || typeof audio[key] === "string",
+ ) &&
+ (audio.channelCount === undefined || typeof audio.channelCount === "number");
+ return {
+ id: persistablePlaybackIdentity(value.id),
+ actor,
+ playedAt: value.playedAt,
+ positionMs: value.positionMs,
+ durationMs: value.durationMs,
+ completed: value.completed,
+ src,
+ sourceFingerprint:
+ playbackUrlFingerprint(value.src) ??
+ (typeof value.sourceFingerprint === "string" && /^[a-f0-9]{64}$/.test(value.sourceFingerprint)
+ ? value.sourceFingerprint
+ : undefined),
+ requiresSourceRefresh:
+ value.requiresSourceRefresh === true ||
+ !!value.src.proxySessionId ||
+ !!Object.keys(value.src.headers ?? {}).length ||
+ !!src.streamRef?.infoHash ||
+ !!src.homeServer ||
+ !src.url ||
+ undefined,
+ audioTrack: audioValid ? audio : undefined,
+ subtitle: persistablePlaybackSubtitle(value.subtitle, value.src),
+ subDelaySec: Number.isFinite(value.subDelaySec) ? value.subDelaySec : undefined,
+ audioDelaySec: Number.isFinite(value.audioDelaySec) ? value.audioDelaySec : undefined,
+ };
+}
+
+function persistableEntry(entry: PlaybackEntry, key?: string): PlaybackEntry {
+ const preference = persistablePlaybackPreference(entry);
+ const metaId = entry.actual?.src?.meta?.id;
+ const opaque =
+ key?.startsWith("playback-private:") ||
+ (!!metaId && persistablePlaybackIdentity(metaId).startsWith("playback-private:"));
+ return {
+ ...preference,
+ ...(opaque ? { title: "Direct stream", parsedTitle: undefined } : {}),
+ ...(entry.actual ? { actual: persistableActualPlayback(entry.actual) } : {}),
+ ...(entry.actualByProfile
+ ? {
+ actualByProfile: Object.fromEntries(
+ Object.entries(entry.actualByProfile)
+ .filter(([, state]) => !!state?.actual)
+ .map(([id, state]) => [
+ persistablePlaybackIdentity(id),
+ {
+ ...(state?.actual ? { actual: persistableActualPlayback(state.actual) } : {}),
+ ...persistablePlaybackFields(
+ state as ActualPlaybackState & { dismissedActualId?: string },
+ ["dismissedActualId"],
+ ),
+ },
+ ]),
+ ),
+ }
+ : {}),
+ // Old versions wrote this inert field. It never controls visibility here.
+ ...persistablePlaybackFields(entry as PlaybackEntry & { dismissedActualId?: string }, [
+ "dismissedActualId",
+ ]),
+ };
+}
+
+function persistableEntries(entries: Record): Record {
+ return Object.fromEntries(
+ Object.entries(entries).map(([key, entry]) => [key, persistableEntry(entry, key)]),
+ );
+}
+
export function readLastActualPlayback(): ActualPlayback | null {
const actor = capturePlaybackActor();
- let last: ActualPlayback | null = null;
+ let last: ActualPlaybackState | null = null;
for (const entry of Object.values(readAll())) {
- const actual = entry.actual;
- if (
- !actual ||
- !validActualPlayback(actual) ||
- actual.actor.storageProfileId !== actor.storageProfileId ||
- actual.actor.accountId !== actor.accountId
- )
- continue;
- if (!last || actual.playedAt > last.playedAt) last = actual;
+ const state = selectedActualState(entry, actor);
+ const actual = state.actual;
+ if (!actual || Date.now() - actual.playedAt > TTL_MS) continue;
+ if (!last || actual.playedAt > last.actual!.playedAt) last = state;
}
- return last;
+ return last?.actual ?? null;
}
export function playbackSourceKey(
@@ -315,19 +658,120 @@ export function playbackSourceKey(
return `server:${src.homeServer.connectionId}:${src.homeServer.itemId}:${src.homeServer.versionId}`;
if (src.streamRef?.infoHash)
return `torrent:${src.streamRef.infoHash.toLowerCase()}:${src.streamRef.fileIdx ?? ""}`;
- return src.historyUrl ?? src.url;
+ const url = persistablePlaybackUrl(src.historyUrl ?? src.url);
+ if (url) return url;
+ const fingerprint = playbackUrlFingerprint(src);
+ if (fingerprint) return `private:${fingerprint}`;
+ const stream = src.streamRef;
+ // Older redacted sources may only have their verified release fields.
+ return stream?.addonId && stream.parsedTitle && stream.size && stream.size > 0
+ ? `release:${JSON.stringify([stream.addonId, stream.parsedTitle, stream.size, stream.fileIdx ?? null])}`
+ : "";
+}
+
+export function actualPlaybackSourceKey(playback: ActualPlayback): string {
+ return playback.sourceFingerprint
+ ? `private:${playback.sourceFingerprint}`
+ : playbackSourceKey(playback.src);
}
export function readActualPlaybackFor(src: PlayerSrc): ActualPlayback | null {
- const entry = readAll()[entryKey(src.meta.id, src.episode?.season, src.episode?.episode)]?.actual;
const actor = capturePlaybackActor();
- return entry &&
- validActualPlayback(entry) &&
- entry.actor.storageProfileId === actor.storageProfileId &&
- entry.actor.accountId === actor.accountId &&
- playbackSourceKey(entry.src) === playbackSourceKey(src)
- ? entry
- : null;
+ const entry = selectedActualState(
+ readAll()[entryKey(src.meta.id, src.episode?.season, src.episode?.episode)],
+ actor,
+ ).actual;
+ const sourceKey = playbackSourceKey(src);
+ return entry && sourceKey && actualPlaybackSourceKey(entry) === sourceKey ? entry : null;
+}
+
+/** Capture the observed session before an asynchronous subtitle cache write starts. */
+export function readActualPlaybackForSubtitle(
+ mediaKey: string,
+ streamKey: string | undefined,
+ notBefore: number,
+): ActualPlayback | null {
+ const actor = capturePlaybackActor();
+ const parts = /^(.*)\|([^|]*)\|([^|]*)$/.exec(mediaKey);
+ if (parts) mediaKey = `${persistablePlaybackIdentity(parts[1])}|${parts[2]}|${parts[3]}`;
+ if (streamKey) streamKey = persistablePlaybackIdentity(streamKey);
+ return (
+ Object.values(readAll())
+ .map((entry) => ownActualState(entry, actor).actual)
+ .find(
+ (actual) =>
+ actual &&
+ validActualPlayback(actual) &&
+ actual.actor.profileId === actor.profileId &&
+ actual.actor.storageProfileId === actor.storageProfileId &&
+ actual.actor.accountId === actor.accountId &&
+ actual.playedAt >= notBefore &&
+ subtitleMediaKey(
+ actual.src.meta.id,
+ actual.src.episode?.season,
+ actual.src.episode?.episode,
+ ) === mediaKey &&
+ (actual.subtitle?.streamKey ?? subtitleStreamKey(actual.src.streamRef)) === streamKey,
+ ) ?? null
+ );
+}
+
+/** Cache completion may improve a source pointer, never playback recency or a newer session. */
+export function cacheActualPlaybackSubtitle(
+ target: ActualPlayback,
+ original: PlaybackSubtitleChoice,
+ cached: PlaybackSubtitleChoice,
+): boolean {
+ if (
+ !isPlaybackActorCurrent(target.actor) ||
+ !cached.imported ||
+ !cached.source ||
+ /^(https?|blob|data|memory):/i.test(cached.source)
+ )
+ return false;
+ const all = readAll();
+ const key = entryKey(target.src.meta.id, target.src.episode?.season, target.src.episode?.episode);
+ const entry = all[key];
+ const own = ownActualState(entry, target.actor);
+ const actual = own.actual;
+ const savedOriginal = persistablePlaybackSubtitle(original, target.src);
+ if (
+ !entry ||
+ !actual ||
+ !validActualPlayback(actual) ||
+ actual.id !== target.id ||
+ actualPlaybackSourceKey(actual) !== actualPlaybackSourceKey(target) ||
+ !actual.subtitle ||
+ actual.subtitle.off ||
+ !(
+ (actual.subtitle.source && actual.subtitle.source === savedOriginal?.source) ||
+ (actual.subtitle.sourceFingerprint &&
+ actual.subtitle.sourceFingerprint === savedOriginal?.sourceFingerprint)
+ ) ||
+ actual.subtitle.streamKey !== savedOriginal?.streamKey ||
+ actual.subtitle.subId !== savedOriginal?.subId ||
+ actual.subtitle.provider !== savedOriginal?.provider
+ )
+ return false;
+ const patched = {
+ ...actual,
+ subtitle: { ...actual.subtitle, ...cached, fpsOverride: actual.subtitle.fpsOverride },
+ };
+ all[key] = {
+ ...entry,
+ ...(entry.actual?.id === actual.id ? { actual: patched } : {}),
+ actualByProfile: {
+ ...entry.actualByProfile,
+ [target.actor.profileId]: { ...own, actual: patched },
+ },
+ };
+ try {
+ localStorage.setItem(storeKey(), JSON.stringify(persistableEntries(all)));
+ } catch {
+ return false;
+ }
+ notifyPlayback();
+ return true;
}
export function readPlayback(
@@ -343,7 +787,13 @@ export function clearPlayback(metaId: string, season?: number, episode?: number)
const all = readAll();
const key = entryKey(metaId, season, episode);
const actual = all[key]?.actual;
- if (actual) all[key] = { savedAt: actual.playedAt, title: actual.src.meta.name, actual };
+ if (actual || all[key]?.actualByProfile)
+ all[key] = {
+ savedAt: all[key].savedAt,
+ title: actual?.src.meta.name ?? all[key].title,
+ actual,
+ actualByProfile: all[key].actualByProfile,
+ };
else delete all[key];
writeAll(all);
}
@@ -352,7 +802,10 @@ function offeredBy(
s: { addonId?: string | null; contributors?: Array<{ id: string }> },
addonId: string,
): boolean {
- return s.addonId === addonId || s.contributors?.some((c) => c.id === addonId) === true;
+ return (
+ (s.addonId && persistablePlaybackIdentity(s.addonId) === addonId) ||
+ s.contributors?.some((c) => persistablePlaybackIdentity(c.id) === addonId) === true
+ );
}
/** True when the stream came from the given addon or one of its contributors. */
@@ -368,13 +821,15 @@ export function streamOfferedByAddon(
* addon. Debrid library copies and aggregator duplicates share the torrent hash,
* so a plain hash match would otherwise select whichever row came first.
*/
-export function findPreferredSourceMatch;
- resolution?: string | null;
- releaseGroupNormalized?: string | null;
- audioLanguages?: string[] | null;
-}>(
+export function findPreferredSourceMatch<
+ T extends {
+ addonId?: string | null;
+ contributors?: Array<{ id: string }>;
+ resolution?: string | null;
+ releaseGroupNormalized?: string | null;
+ audioLanguages?: string[] | null;
+ },
+>(
streams: T[],
entry: PlaybackEntry,
match: (stream: T, entry: PlaybackEntry) => boolean,
@@ -422,6 +877,7 @@ export function streamMatchesEntry(
return true;
}
if (e.url && s.url) return s.url === e.url;
+ if (e.urlFingerprint && s.url) return playbackUrlFingerprint({ url: s.url }) === e.urlFingerprint;
return false;
}
@@ -478,6 +934,7 @@ export function playbackEntries(): Array<{
}
export function readLastSeriesPlayback(metaId: string): PlaybackEntry | null {
+ metaId = persistablePlaybackIdentity(metaId);
const all = readAll();
const prefix = `${metaId}|`;
let best: PlaybackEntry | null = null;
diff --git a/src/lib/player/actual-playback.ts b/src/lib/player/actual-playback.ts
index b30366915..20a9dd7e8 100644
--- a/src/lib/player/actual-playback.ts
+++ b/src/lib/player/actual-playback.ts
@@ -4,6 +4,17 @@ import type { PlayerSnapshot } from "./bridge";
import { isLivePlaybackSrc } from "./live-src";
import { isNaturalEnd } from "./playback-end";
import { playbackAudioChoice } from "./audio-choice";
+import { playbackSubtitleChoice, type PlaybackSubtitleChoice } from "./subtitle-choice";
+import {
+ persistablePlaybackSource,
+ persistablePlaybackSubtitle,
+ playbackUrlFingerprint,
+} from "./playback-history-source";
+import {
+ subtitleMediaKey,
+ subtitleStreamKey,
+ type RememberedSub,
+} from "../subtitles/subtitle-memory";
export function actualPlaybackSnapshot(
src: PlayerSrc,
@@ -11,6 +22,7 @@ export function actualPlaybackSnapshot(
positionSec: number,
session: { id: string; actor: PlaybackActor },
at = Date.now(),
+ rememberedSubtitle?: RememberedSub | null,
): ActualPlayback | null {
if (
isLivePlaybackSrc(src) ||
@@ -22,21 +34,29 @@ export function actualPlaybackSnapshot(
!src.url
)
return null;
- // Runtime-only handles cannot survive restarting Harbor. Keep the original
- // source identity and send proxy/torrent sources through normal preparation.
- const {
- continuation: _continuation,
- playbackTraceId: _trace,
- proxySessionId,
- attempt: _attempt,
- autoFired: _auto,
- startPositionMs: _start,
- startPaused: _paused,
- startFromZero: _zero,
- ...saved
- } = src;
- const { videos: _videos, description: _description, ...meta } = src.meta;
+ const saved = persistablePlaybackSource(src);
const selectedAudio = snapshot.audioTracks.find((track) => track.selected);
+ const selectedSubtitle = snapshot.subtitleTracks.find((track) => track.selected);
+ const tracksClearedAtEnd =
+ snapshot.status === "ended" &&
+ snapshot.audioTracks.length === 0 &&
+ snapshot.subtitleTracks.length === 0;
+ const subtitle: PlaybackSubtitleChoice | undefined = selectedSubtitle
+ ? playbackSubtitleChoice(selectedSubtitle, rememberedSubtitle, {
+ mediaKey: subtitleMediaKey(src.meta.id, src.episode?.season, src.episode?.episode),
+ streamKey: subtitleStreamKey(src.streamRef),
+ })
+ : snapshot.status === "ended" && snapshot.subtitleTracks.length === 0
+ ? undefined
+ : { off: true };
+ if (subtitle?.source) subtitle.streamKey = subtitleStreamKey(src.streamRef);
+ if (
+ subtitle &&
+ selectedSubtitle &&
+ Number.isFinite(snapshot.subtitleFps) &&
+ (snapshot.subtitleFps === 0 || (snapshot.subtitleFps! >= 1 && snapshot.subtitleFps! <= 240))
+ )
+ subtitle.fpsOverride = snapshot.subtitleFps;
return {
...session,
playedAt: at,
@@ -45,8 +65,23 @@ export function actualPlaybackSnapshot(
// Watched/progress thresholds do not mean the player finished. A paused
// near-end session must still continue from its actual position.
completed: isNaturalEnd(snapshot, positionSec),
- src: { ...saved, meta, url: src.historyUrl ?? src.url },
- requiresSourceRefresh: !!proxySessionId || !!src.streamRef?.infoHash || !!src.homeServer,
+ src: saved,
+ sourceFingerprint: playbackUrlFingerprint(src),
+ requiresSourceRefresh:
+ !!src.proxySessionId ||
+ !!Object.keys(src.headers ?? {}).length ||
+ !!src.streamRef?.infoHash ||
+ !!src.homeServer ||
+ !saved.url,
audioTrack: selectedAudio ? playbackAudioChoice(selectedAudio) : undefined,
+ subtitle: persistablePlaybackSubtitle(subtitle, src),
+ subDelaySec:
+ !tracksClearedAtEnd && Number.isFinite(snapshot.subDelaySec)
+ ? snapshot.subDelaySec
+ : undefined,
+ audioDelaySec:
+ !tracksClearedAtEnd && Number.isFinite(snapshot.audioDelaySec)
+ ? snapshot.audioDelaySec
+ : undefined,
};
}
diff --git a/src/lib/player/bridge.ts b/src/lib/player/bridge.ts
index 65f35da74..af7aa7289 100644
--- a/src/lib/player/bridge.ts
+++ b/src/lib/player/bridge.ts
@@ -74,6 +74,8 @@ export type PlayerSnapshot = {
chapters: Chapter[];
subDelaySec: number;
audioDelaySec: number;
+ /** Observed native correction; undefined when the engine does not expose it. Zero means no correction. */
+ subtitleFps?: number;
subText: string;
subStartSec: number;
secondarySubText: string;
diff --git a/src/lib/player/continue-playback.ts b/src/lib/player/continue-playback.ts
index 2158aa8dd..c9e095a61 100644
--- a/src/lib/player/continue-playback.ts
+++ b/src/lib/player/continue-playback.ts
@@ -1,5 +1,6 @@
import {
playbackSourceKey,
+ actualPlaybackSourceKey,
streamMatchesEntry,
type ActualPlayback,
type PlaybackActor,
@@ -8,6 +9,7 @@ import {
import type { Meta } from "../cinemeta";
import type { PlayEpisode, PlayerSrc } from "../view";
import { isLocalUrl } from "./local-url";
+import { persistablePlaybackIdentity } from "./playback-history-source";
export type ContinuationServices = {
isCurrent: (actor: PlaybackActor) => boolean;
@@ -37,6 +39,37 @@ export function continuationStream 0 &&
+ source.size === saved.size
+ );
+}
+
export function continuationFor(
target: ActualPlayback,
actor: PlaybackActor,
@@ -47,8 +80,16 @@ export function continuationFor(
actor,
restart,
positionMs: restart ? 0 : target.positionMs,
- sourceKey: playbackSourceKey(target.src),
+ sourceKey: actualPlaybackSourceKey(target),
+ target: {
+ metaId: target.src.meta.id,
+ season: target.src.episode?.season,
+ episode: target.src.episode?.episode,
+ },
audioTrack: target.audioTrack,
+ subtitle: target.subtitle,
+ subDelaySec: target.subDelaySec,
+ audioDelaySec: target.audioDelaySec,
source: {
...target.src.streamRef,
url: target.src.historyUrl ?? target.src.url,
@@ -76,8 +117,9 @@ export async function continueActualPlayback(
const active = services.active();
if (active) {
if (
- playbackSourceKey(active.src) !== playbackSourceKey(target.src) ||
- active.src.meta.id !== target.src.meta.id ||
+ !playbackSourceKey(active.src) ||
+ playbackSourceKey(active.src) !== actualPlaybackSourceKey(target) ||
+ persistablePlaybackIdentity(active.src.meta.id) !== target.src.meta.id ||
active.src.episode?.season !== target.src.episode?.season ||
active.src.episode?.episode !== target.src.episode?.episode
) {
@@ -87,14 +129,29 @@ export async function continueActualPlayback(
return "returned";
}
const continuation = continuationFor(target, actor, options.restart);
- const prepared = (src: PlayerSrc): PlayerSrc => ({
- ...src,
- continuation,
- resume: true,
- startPositionMs: continuation.positionMs,
- startFromZero: options.restart === true,
- startPaused: false,
- });
+ const prepared = (src: PlayerSrc): PlayerSrc => {
+ const subtitle = continuation.subtitle;
+ const restored =
+ src.homeServer && subtitle?.homeServerSubtitleId
+ ? {
+ ...continuation,
+ subtitle: {
+ ...subtitle,
+ // Server subtitle URLs are authenticated transport, not saved identity.
+ source: src.subtitles?.find((track) => track.id === subtitle.homeServerSubtitleId)
+ ?.url,
+ },
+ }
+ : continuation;
+ return {
+ ...src,
+ continuation: restored,
+ resume: true,
+ startPositionMs: continuation.positionMs,
+ startFromZero: options.restart === true,
+ startPaused: false,
+ };
+ };
const pick = () => {
valid();
services.openPicker(target.src.meta, target.src.episode, {
@@ -120,6 +177,10 @@ export async function continueActualPlayback(
services.openPlayer(prepared(src));
return "player-opened";
}
+ if (target.src.meta.id.startsWith("playback-private:"))
+ throw new Error(
+ "Open this video from its source or enter the link again. Its network address was not saved.",
+ );
if (target.requiresSourceRefresh || target.src.streamRef?.infoHash) return pick();
if (!/^https?:\/\//i.test(target.src.url))
throw new Error("The last playback source is no longer available.");
diff --git a/src/lib/player/mpv-properties.ts b/src/lib/player/mpv-properties.ts
index 12c40ccaa..0dc50989c 100644
--- a/src/lib/player/mpv-properties.ts
+++ b/src/lib/player/mpv-properties.ts
@@ -81,8 +81,9 @@ async function waitForMpvSubtitleFpsTransitions(): Promise {
export async function writeMpvSubtitleFps(
choice: SubtitleFpsChoice,
generation: number,
+ isCurrent: () => boolean = () => true,
): Promise {
- await coordinator.apply(choice, () => generation === subtitleFpsGeneration);
+ await coordinator.apply(choice, () => generation === subtitleFpsGeneration && isCurrent());
}
export async function resetMpvSubtitleFpsForTransition(
diff --git a/src/lib/player/mpv.ts b/src/lib/player/mpv.ts
index c48c5f479..63d57b4bb 100644
--- a/src/lib/player/mpv.ts
+++ b/src/lib/player/mpv.ts
@@ -983,6 +983,8 @@ export function createMpvBridge(mpvOptions?: MpvOptions): PlayerBridge {
}
if (name === "sub-delay" && typeof data === "number") snap.subDelaySec = data;
if (name === "audio-delay" && typeof data === "number") snap.audioDelaySec = data;
+ if (name === "sub-fps" && typeof data === "number" && Number.isFinite(data))
+ snap.subtitleFps = data;
if (name === "sub-text") {
snap.subText = !primarySubtitleOff && typeof data === "string" ? data : "";
}
@@ -1185,6 +1187,7 @@ export function createMpvBridge(mpvOptions?: MpvOptions): PlayerBridge {
snap.errorMessage = null;
snap.audioTracks = [];
snap.subtitleTracks = [];
+ snap.subtitleFps = undefined;
primarySubtitleOff = false;
snap.subText = "";
snap.subStartSec = 0;
diff --git a/src/lib/player/playback-history-source.ts b/src/lib/player/playback-history-source.ts
new file mode 100644
index 000000000..52e1d9c33
--- /dev/null
+++ b/src/lib/player/playback-history-source.ts
@@ -0,0 +1,344 @@
+import { persistableAddonOrigin } from "../addon-configuration-key";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex } from "@noble/hashes/utils";
+import type { PlayerSrc } from "../view";
+import type { PlaybackSubtitleChoice } from "./subtitle-choice";
+import type { PlaybackEntry } from "../playback-history";
+import { isLocalUrl } from "./local-url";
+
+const MAX_URL_ENCODING_DEPTH = 8;
+
+// Names and labels are not an alternative place to retain a transport URL.
+function safeString(value: string): string | undefined {
+ if (/^file:\/\//i.test(value) && persistablePlaybackUrl(value)) return value;
+ if (/^local[:-]/i.test(value) && persistablePlaybackUrl(value.slice(6))) return value;
+ if (/^harbor-plugin:\/\/[A-Za-z0-9._:-]+(?:\/[A-Za-z0-9._:-]+)*$/.test(value)) return value;
+ let decoded = value;
+ for (let depth = 0; depth < MAX_URL_ENCODING_DEPTH; depth++) {
+ if (/(?:https?|rtmps?|rtsp|mms|ftp|sftp|wss?):\s*[/\\]|\/\//i.test(decoded)) return undefined;
+ const next = decoded.replace(/%([a-f0-9]{2})/gi, (_, hex) =>
+ String.fromCharCode(parseInt(hex, 16)),
+ );
+ if (next === decoded) return value;
+ decoded = next;
+ }
+ // Do not let deeper or deliberately layered encoding bypass the bounded scan.
+ return undefined;
+}
+
+/** Select only scalar fields; nested transport objects never enter history. */
+function fields(value: T, keys: readonly K[]): Pick {
+ const entries: Array<[K, unknown]> = [];
+ for (const key of keys) {
+ const item = value[key];
+ if (typeof item === "string") {
+ const safe = safeString(item);
+ if (safe !== undefined) entries.push([key, safe]);
+ } else if (
+ typeof item === "boolean" ||
+ item === null ||
+ (typeof item === "number" && Number.isFinite(item))
+ ) {
+ entries.push([key, item]);
+ } else if (Array.isArray(item) && item.every((part) => typeof part === "string")) {
+ entries.push([key, item.filter((part) => safeString(part) !== undefined)]);
+ }
+ }
+ return Object.fromEntries(entries) as Pick;
+}
+
+export { fields as persistablePlaybackFields };
+
+export function playbackTransportFingerprint(value: string | undefined): string | undefined {
+ return value ? bytesToHex(sha256(new TextEncoder().encode(value))) : undefined;
+}
+
+/** URL-derived item IDs cannot double as a second copy of the transport. */
+export function persistablePlaybackIdentity(value: string): string {
+ if (typeof value !== "string") return "";
+ return safeString(value) === undefined
+ ? `playback-private:${playbackTransportFingerprint(value)}`
+ : value;
+}
+
+export function persistablePlaybackKey(value: string): string {
+ const match = /^(.*)(\|(?:s\d+(?:e\d+)?|all))$/.exec(value);
+ return match
+ ? `${persistablePlaybackIdentity(match[1])}${match[2]}`
+ : persistablePlaybackIdentity(value);
+}
+
+export function persistablePlaybackUrl(value: string | undefined): string | undefined {
+ if (typeof value !== "string" || !isLocalUrl(value) || value.startsWith("//")) return undefined;
+ if (/^file:/i.test(value)) {
+ try {
+ const url = new URL(value);
+ if (url.username || url.password || url.search || url.hash) return undefined;
+ } catch {
+ return undefined;
+ }
+ }
+ return value;
+}
+
+function artworkUrl(value: string | undefined): string | undefined {
+ if (
+ value &&
+ /^https:\/\/image\.tmdb\.org\/t\/p\/(?:original|[wh]\d+)\/[A-Za-z0-9_-]+\.(?:jpg|png|webp|svg)$/.test(
+ value,
+ )
+ )
+ return value;
+ return persistablePlaybackUrl(value);
+}
+
+/** The source preference has the same URL policy as the observed session. */
+export function persistablePlaybackPreference(entry: PlaybackEntry): PlaybackEntry {
+ const textKeys = [
+ "infoHash",
+ "addonId",
+ "title",
+ "parsedTitle",
+ "resolution",
+ "releaseGroup",
+ "source",
+ "bingeGroup",
+ ] as const;
+ const text = fields(entry, textKeys);
+ for (const key of textKeys)
+ if (text[key] != null && typeof text[key] !== "string") delete text[key];
+ const numbers = fields(entry, ["fileIdx", "size", "savedAt"]);
+ for (const key of ["fileIdx", "size", "savedAt"] as const)
+ if (numbers[key] != null && typeof numbers[key] !== "number") delete numbers[key];
+ return {
+ ...text,
+ ...numbers,
+ ...(Array.isArray(entry.audioLanguages)
+ ? {
+ audioLanguages: entry.audioLanguages.filter(
+ (value) => typeof value === "string" && safeString(value) !== undefined,
+ ),
+ }
+ : {}),
+ ...(Array.isArray(entry.cachedSlugs)
+ ? {
+ cachedSlugs: entry.cachedSlugs.filter(
+ (value) => typeof value === "string" && safeString(value) !== undefined,
+ ),
+ }
+ : {}),
+ ...(typeof entry.addonId === "string"
+ ? { addonId: persistablePlaybackIdentity(entry.addonId) }
+ : {}),
+ url: persistablePlaybackUrl(entry.url ?? undefined),
+ urlFingerprint:
+ typeof entry.url === "string" && entry.url && !persistablePlaybackUrl(entry.url)
+ ? playbackTransportFingerprint(entry.url)
+ : typeof entry.urlFingerprint === "string" && /^[a-f0-9]{64}$/.test(entry.urlFingerprint)
+ ? entry.urlFingerprint
+ : undefined,
+ };
+}
+
+/** Compare a redacted source with a live session without retaining its URL. */
+export function playbackUrlFingerprint(
+ src: Pick,
+): string | undefined {
+ const url = src.historyUrl ?? src.url;
+ return !src.homeServer && !src.streamRef?.infoHash && url && !persistablePlaybackUrl(url)
+ ? playbackTransportFingerprint(url)
+ : undefined;
+}
+
+/** Persist source identity, never a complete runtime PlayerSrc. */
+export function persistablePlaybackSource(src: PlayerSrc): Omit {
+ const origin = persistableAddonOrigin(src.meta.addonOrigin);
+ const privateIdentity = persistablePlaybackIdentity(src.meta.id);
+ const badge = src.meta.providerBadge
+ ? fields(src.meta.providerBadge, ["name", "tint"])
+ : undefined;
+ const badgeLogo = artworkUrl(src.meta.providerBadge?.logo);
+ const opaque = privateIdentity !== src.meta.id || privateIdentity.startsWith("playback-private:");
+ return {
+ ...fields(src, [
+ "title",
+ "subtitle",
+ "imdbId",
+ "imdbIdVerified",
+ "notWebReady",
+ "isAnime",
+ "suppressCloudSync",
+ "episodeEnd",
+ ]),
+ meta: {
+ ...fields(src.meta, [
+ "id",
+ "type",
+ "name",
+ "poster",
+ "background",
+ "logo",
+ "originalLanguage",
+ "country",
+ "malId",
+ "animeFormat",
+ "releaseInfo",
+ "releaseDate",
+ "inTheaters",
+ "imdbRating",
+ "adult",
+ "sourceRank",
+ "tmdbScore",
+ "pluginQuality",
+ "listingYear",
+ "runtime",
+ "genres",
+ "isCollection",
+ ]),
+ id: privateIdentity,
+ name: opaque ? "Direct stream" : (safeString(src.meta.name) ?? ""),
+ ...(src.meta.poster ? { poster: artworkUrl(src.meta.poster) } : {}),
+ ...(src.meta.background ? { background: artworkUrl(src.meta.background) } : {}),
+ ...(src.meta.logo ? { logo: artworkUrl(src.meta.logo) } : {}),
+ ...(origin
+ ? { addonOrigin: fields(origin, ["id", "name", "logo", "base", "configurationKey"]) }
+ : {}),
+ ...(badge && typeof badge.name === "string" && typeof badge.tint === "string" && badgeLogo
+ ? {
+ providerBadge: {
+ ...badge,
+ logo: badgeLogo,
+ },
+ }
+ : {}),
+ ...(src.meta.listingExtras
+ ? {
+ listingExtras: fields(src.meta.listingExtras, [
+ "rest",
+ "languages",
+ "quality",
+ "resolutions",
+ "hdr",
+ ]),
+ }
+ : {}),
+ ...(src.meta.behaviorHints
+ ? { behaviorHints: fields(src.meta.behaviorHints, ["defaultVideoId"]) }
+ : {}),
+ },
+ url: src.homeServer ? "" : (persistablePlaybackUrl(src.historyUrl ?? src.url) ?? ""),
+ ...(opaque ? { title: "Direct stream", subtitle: undefined } : {}),
+ ...(src.episode
+ ? {
+ episode: {
+ ...fields(src.episode, [
+ "season",
+ "episode",
+ "name",
+ "imdbId",
+ "imdbSeason",
+ "imdbEpisode",
+ "absoluteNumber",
+ "tvdbEpisodeId",
+ "kitsuStreamId",
+ "sourceMetaId",
+ "videoId",
+ "still",
+ "overview",
+ "rating",
+ "airDate",
+ "runtime",
+ ]),
+ ...(src.episode.still ? { still: artworkUrl(src.episode.still) } : {}),
+ },
+ }
+ : {}),
+ ...(src.episodeSpan
+ ? { episodeSpan: fields(src.episodeSpan, ["season", "episode", "episodeEnd"]) }
+ : {}),
+ ...(src.streamRef
+ ? {
+ streamRef: {
+ ...fields(src.streamRef, [
+ "resolvedFilename",
+ "infoHash",
+ "fileIdx",
+ "addonId",
+ "name",
+ "addonName",
+ "title",
+ "parsedTitle",
+ "resolution",
+ "quality",
+ "releaseGroup",
+ "source",
+ "audioLanguages",
+ "size",
+ "bingeGroup",
+ "cachedSlugs",
+ ]),
+ ...(src.streamRef.addonId
+ ? { addonId: persistablePlaybackIdentity(src.streamRef.addonId) }
+ : {}),
+ },
+ }
+ : {}),
+ ...(src.homeServer
+ ? { homeServer: fields(src.homeServer, ["connectionId", "itemId", "versionId", "quality"]) }
+ : {}),
+ };
+}
+
+export function persistablePlaybackSubtitle(
+ choice: PlaybackSubtitleChoice | undefined,
+ src: PlayerSrc,
+): PlaybackSubtitleChoice | undefined {
+ if (!choice) return undefined;
+ if (choice.off) return { off: true };
+ const saved = fields(choice, [
+ "lang",
+ "title",
+ "trackId",
+ "subId",
+ "provider",
+ "release",
+ "format",
+ "encoding",
+ "downloadAuthKind",
+ "providerDerived",
+ "localTrusted",
+ "matchScore",
+ "matchConfidence",
+ "streamKey",
+ "imported",
+ "external",
+ "codec",
+ "forced",
+ "hearingImpaired",
+ "fpsOverride",
+ "homeServerSubtitleId",
+ ]);
+ if (typeof choice.streamKey === "string")
+ saved.streamKey = persistablePlaybackIdentity(choice.streamKey);
+ const sourceFingerprint =
+ choice.source && !persistablePlaybackUrl(choice.source)
+ ? playbackTransportFingerprint(choice.source)
+ : typeof choice.sourceFingerprint === "string" &&
+ /^[a-f0-9]{64}$/.test(choice.sourceFingerprint)
+ ? choice.sourceFingerprint
+ : undefined;
+ const retained = { ...saved, ...(sourceFingerprint ? { sourceFingerprint } : {}) };
+ const serverSubtitle =
+ src.homeServer && choice.source
+ ? src.subtitles?.find((track) => track.url === choice.source)
+ : undefined;
+ const homeServerSubtitleId = saved.homeServerSubtitleId ?? serverSubtitle?.id;
+ if (src.homeServer) {
+ delete retained.trackId;
+ // A server track ID is stable only when supplied by its source catalogue.
+ if (homeServerSubtitleId) return { ...retained, homeServerSubtitleId };
+ if (serverSubtitle) return retained;
+ }
+ const source = persistablePlaybackUrl(choice.source);
+ return source ? { ...retained, source } : retained;
+}
diff --git a/src/lib/player/subtitle-choice.ts b/src/lib/player/subtitle-choice.ts
new file mode 100644
index 000000000..7905ade9e
--- /dev/null
+++ b/src/lib/player/subtitle-choice.ts
@@ -0,0 +1,173 @@
+import type { TrackInfo } from "./bridge";
+import {
+ lookupSubtitleOrigin,
+ rememberedFromChoice,
+ type RememberedSub,
+} from "../subtitles/subtitle-memory";
+import { normalizeLang } from "../subtitles/language";
+import { selectedSubtitleCacheName } from "../subtitles/selected-subtitle-cache";
+import { playbackTransportFingerprint } from "./playback-history-source";
+
+export type PlaybackSubtitleChoice = Omit & {
+ external?: boolean;
+ codec?: string;
+ forced?: boolean;
+ hearingImpaired?: boolean;
+ fpsOverride?: number;
+ homeServerSubtitleId?: string;
+ sourceFingerprint?: string;
+};
+
+function durableSource(source?: string): string | undefined {
+ const original = source && (lookupSubtitleOrigin(source) ?? source);
+ return original && !/^(blob|data|memory):/i.test(original) ? original : undefined;
+}
+
+function sameSource(source: string | undefined, saved: string): boolean {
+ return durableSource(source)?.replace(/\\/g, "/") === durableSource(saved)?.replace(/\\/g, "/");
+}
+
+type SubtitleCacheContext = { mediaKey: string; streamKey?: string };
+
+function matchesCachedSubtitleOrigin(
+ choice: Pick,
+ source: string | undefined,
+ remembered?: RememberedSub | null,
+ context?: SubtitleCacheContext,
+): boolean {
+ const file = remembered?.source?.split(/[\\/]/).pop() ?? "";
+ const format = /^selected-[a-f0-9]{8}\.(srt|vtt|ass|ssa)$/i.exec(file)?.[1]?.toLowerCase() as
+ | "srt"
+ | "vtt"
+ | "ass"
+ | "ssa"
+ | undefined;
+ if (
+ !context ||
+ !remembered?.imported ||
+ remembered.off ||
+ !format ||
+ !/^(?:[a-z]:[\\/]|[\\/]|file:\/\/)/i.test(remembered.source ?? "") ||
+ remembered.streamKey !== context.streamKey ||
+ remembered.subId !== choice.subId ||
+ remembered.provider !== choice.provider
+ )
+ return false;
+
+ // An exact origin URL can verify the managed cache filename. Redacted
+ // histories instead prove the same origin using its SHA-256 fingerprint,
+ // captured when the remote subtitle was copied into the local cache.
+ if (source)
+ return (
+ file ===
+ selectedSubtitleCacheName(context.mediaKey, context.streamKey, { ...choice, source }, format)
+ );
+ return (
+ !!choice.sourceFingerprint &&
+ /^[a-f0-9]{64}$/.test(choice.sourceFingerprint) &&
+ remembered.sourceFingerprint === choice.sourceFingerprint
+ );
+}
+
+/** A late cache may finish after the actual session was flushed on exit. */
+export function restorablePlaybackSubtitleChoice(
+ saved: PlaybackSubtitleChoice,
+ remembered: RememberedSub | null,
+ context: SubtitleCacheContext,
+): PlaybackSubtitleChoice {
+ if (
+ !remembered ||
+ saved.off ||
+ !saved.external ||
+ saved.streamKey !== context.streamKey ||
+ !matchesCachedSubtitleOrigin(saved, durableSource(saved.source), remembered, context)
+ )
+ return saved;
+ const { updatedAt: _cacheTime, ...cached } = remembered;
+ return { ...saved, ...cached, external: true, fpsOverride: saved.fpsOverride };
+}
+
+export function playbackSubtitleChoice(
+ track: TrackInfo,
+ remembered?: RememberedSub | null,
+ context?: SubtitleCacheContext,
+): PlaybackSubtitleChoice {
+ const choice = rememberedFromChoice({
+ ...track,
+ title: track.title ?? track.label,
+ source:
+ durableSource(track.originalUrl) ??
+ durableSource(track.externalFilename) ??
+ durableSource(track.url),
+ });
+ // A prepared blob is never a persistent subtitle source, even when no origin is known.
+ choice.source = durableSource(choice.source);
+ const matchesCachedOrigin = matchesCachedSubtitleOrigin(
+ track,
+ choice.source,
+ remembered,
+ context,
+ );
+ const sameRemembered =
+ remembered &&
+ !remembered.off &&
+ (matchesCachedOrigin ||
+ (remembered.source &&
+ [track.originalUrl, track.externalFilename, track.url].some((source) =>
+ sameSource(source, remembered.source!),
+ )) ||
+ (remembered.subId &&
+ remembered.subId === track.subId &&
+ remembered.provider === track.provider &&
+ (!remembered.lang || normalizeLang(remembered.lang) === normalizeLang(track.lang ?? ""))) ||
+ (!track.external &&
+ remembered.trackId === track.id &&
+ normalizeLang(remembered.lang ?? "") === normalizeLang(track.lang ?? "") &&
+ remembered.title === (track.title ?? track.label)));
+ return {
+ ...(sameRemembered ? { ...remembered, updatedAt: undefined } : choice),
+ source: (sameRemembered ? durableSource(remembered?.source) : undefined) ?? choice.source,
+ external: track.external || undefined,
+ codec: track.codec,
+ forced: track.forced,
+ hearingImpaired: track.hearingImpaired,
+ };
+}
+
+export function selectPlaybackSubtitle(
+ tracks: TrackInfo[],
+ choice: PlaybackSubtitleChoice,
+): TrackInfo | null {
+ if (choice.off) return null;
+ const norm = (value?: string) => (value ?? "").trim().toLowerCase();
+ const matches = tracks.filter((track) => {
+ if (choice.external) {
+ return (
+ !!track.external &&
+ ((!!choice.source &&
+ [track.originalUrl, track.url, track.externalFilename].some((source) =>
+ sameSource(source, choice.source!),
+ )) ||
+ (!choice.source &&
+ !!choice.sourceFingerprint &&
+ [track.originalUrl, track.url, track.externalFilename].some(
+ (source) =>
+ playbackTransportFingerprint(durableSource(source)) === choice.sourceFingerprint,
+ )) ||
+ (!!choice.subId &&
+ choice.subId === track.subId &&
+ choice.provider === track.provider &&
+ (!choice.lang || normalizeLang(choice.lang) === normalizeLang(track.lang ?? ""))))
+ );
+ }
+ return (
+ !track.external &&
+ normalizeLang(track.lang ?? "") === normalizeLang(choice.lang ?? "") &&
+ norm(track.title ?? track.label) === norm(choice.title) &&
+ (!choice.codec || norm(track.codec) === norm(choice.codec)) &&
+ (choice.forced === undefined || !!track.forced === choice.forced) &&
+ (choice.hearingImpaired === undefined || !!track.hearingImpaired === choice.hearingImpaired)
+ );
+ });
+ return matches.length === 1 ? matches[0] : null;
+}
diff --git a/src/lib/season-lock.ts b/src/lib/season-lock.ts
index 175d54a56..585d8d20d 100644
--- a/src/lib/season-lock.ts
+++ b/src/lib/season-lock.ts
@@ -1,4 +1,9 @@
import type { PlaybackEntry } from "./playback-history";
+import {
+ persistablePlaybackIdentity,
+ persistablePlaybackKey,
+ persistablePlaybackPreference,
+} from "./player/playback-history-source";
export type SeasonLockEntry = PlaybackEntry & { seriesWide?: boolean };
@@ -6,7 +11,18 @@ const STORAGE_KEY = "harbor.season-lock.v1";
const TTL_MS = 120 * 24 * 60 * 60 * 1000;
const MAX_ENTRIES = 300;
+function persistableLock(key: string, value: SeasonLockEntry): SeasonLockEntry {
+ return {
+ ...persistablePlaybackPreference(value),
+ ...(key.startsWith("playback-private:")
+ ? { title: "Direct stream", parsedTitle: undefined }
+ : {}),
+ ...(typeof value.seriesWide === "boolean" ? { seriesWide: value.seriesWide } : {}),
+ };
+}
+
function seasonKey(metaId: string, season?: number | null): string {
+ metaId = persistablePlaybackIdentity(metaId);
return season != null ? `${metaId}|s${season}` : `${metaId}|all`;
}
@@ -17,11 +33,16 @@ function readAll(): Record {
const parsed = JSON.parse(raw) as Record;
const now = Date.now();
const fresh: Record = {};
+ let scrubbed = false;
for (const [k, v] of Object.entries(parsed)) {
- if (!v?.savedAt) continue;
- if (now - v.savedAt > TTL_MS) continue;
- fresh[k] = v;
+ if (!v) continue;
+ const key = persistablePlaybackKey(k);
+ const safe = persistableLock(key, v);
+ scrubbed ||= key !== k || JSON.stringify(safe) !== JSON.stringify(v);
+ if (!v.savedAt || now - v.savedAt > TTL_MS) continue;
+ if (!fresh[key] || safe.savedAt >= fresh[key].savedAt) fresh[key] = safe;
}
+ if (scrubbed) writeAll(fresh);
return fresh;
} catch {
return {};
@@ -34,7 +55,17 @@ function writeAll(map: Record): void {
const sorted = Object.entries(map).sort((a, b) => b[1].savedAt - a[1].savedAt);
map = Object.fromEntries(sorted.slice(0, MAX_ENTRIES));
}
- localStorage.setItem(STORAGE_KEY, JSON.stringify(map));
+ localStorage.setItem(
+ STORAGE_KEY,
+ JSON.stringify(
+ Object.fromEntries(
+ Object.entries(map).map(([key, value]) => [
+ persistablePlaybackKey(key),
+ persistableLock(persistablePlaybackKey(key), value),
+ ]),
+ ),
+ ),
+ );
} catch {}
}
@@ -45,7 +76,7 @@ export function saveSeasonLock(
seriesWide?: boolean,
): void {
const all = readAll();
- all[seriesWide ? `${metaId}|all` : seasonKey(metaId, season)] = {
+ all[seasonKey(metaId, seriesWide ? null : season)] = {
...entry,
seriesWide,
savedAt: Date.now(),
@@ -54,12 +85,14 @@ export function saveSeasonLock(
}
export function readSeasonLock(metaId: string, season?: number | null): SeasonLockEntry | null {
+ metaId = persistablePlaybackIdentity(metaId);
const all = readAll();
const perSeason = season != null ? all[`${metaId}|s${season}`] : null;
return perSeason ?? all[`${metaId}|all`] ?? null;
}
export function clearSeasonLock(metaId: string, season?: number | null): void {
+ metaId = persistablePlaybackIdentity(metaId);
const all = readAll();
if (season != null) delete all[`${metaId}|s${season}`];
delete all[`${metaId}|all`];
diff --git a/src/lib/subtitles/selected-subtitle-cache.ts b/src/lib/subtitles/selected-subtitle-cache.ts
index 7f8b24e12..4a35ad511 100644
--- a/src/lib/subtitles/selected-subtitle-cache.ts
+++ b/src/lib/subtitles/selected-subtitle-cache.ts
@@ -1,6 +1,7 @@
import type { SubChoiceInput } from "./subtitle-memory";
import type { SubCue } from "./parser";
import { toSrt, toVtt } from "./serialize";
+import { playbackTransportFingerprint } from "../player/playback-history-source";
const MAX_SELECTED_SUBTITLE_CHARS = 8 * 1024 * 1024;
@@ -60,6 +61,17 @@ export function selectedSubtitleCacheName(
return `selected-${stableHash(identity)}.${format}`;
}
+/** An exact, non-reversible identity links a redacted history selection to its cached bytes. */
+export function subtitleCacheOriginFingerprint(choice: SubChoiceInput): string | undefined {
+ if (
+ typeof choice.sourceFingerprint === "string" &&
+ /^[a-f0-9]{64}$/.test(choice.sourceFingerprint)
+ )
+ return choice.sourceFingerprint;
+ const origin = choice.source ?? choice.url ?? choice.originalUrl;
+ return origin && /^https?:\/\//i.test(origin) ? playbackTransportFingerprint(origin) : undefined;
+}
+
export async function cacheSelectedSubtitle(input: CacheInput): Promise {
if (typeof window === "undefined" || !("__TAURI_INTERNALS__" in window)) return null;
const readablePath = localPath(input.playableUrl) ?? localPath(input.choice.source);
@@ -102,6 +114,9 @@ export async function cacheSelectedSubtitle(input: CacheInput): Promise;
@@ -89,7 +92,7 @@ export function subtitleStreamKey(
}
export function rememberedSubAppliesToStream(
- remembered: RememberedSub | null | undefined,
+ remembered: Omit | null | undefined,
streamRef: PlayerStreamRef | null | undefined,
): boolean {
if (!remembered) return false;
@@ -172,6 +175,11 @@ export function rememberedFromChoice(choice: SubChoiceInput): Omit | null | undefined,
+): remembered is Omit & { source: string } {
if (remembered?.imported !== true || !remembered.source) return false;
return !/^(https?|blob|data):/i.test(remembered.source);
}
@@ -213,7 +221,7 @@ export function subtitleSourceIsLocal(source: string | null | undefined): boolea
}
export function rememberedSubtitleLoadMetadata(
- remembered: RememberedSub,
+ remembered: Omit,
downloadAuth?: SubtitleLoadMetadata["downloadAuth"],
): SubtitleLoadMetadata {
return {
@@ -227,8 +235,8 @@ export function rememberedSubtitleLoadMetadata(
providerDerived:
remembered.localTrusted === true
? false
- : remembered.providerDerived ??
- (rememberedSubtitleIsLocal(remembered) ? false : Boolean(remembered.provider)),
+ : (remembered.providerDerived ??
+ (rememberedSubtitleIsLocal(remembered) ? false : Boolean(remembered.provider))),
subId: remembered.subId,
matchScore: remembered.matchScore,
matchConfidence: remembered.matchConfidence,
diff --git a/src/views/group/post-item.tsx b/src/views/group/post-item.tsx
index ae21c3de3..29efa94e6 100644
--- a/src/views/group/post-item.tsx
+++ b/src/views/group/post-item.tsx
@@ -142,7 +142,6 @@ export function PostItem({
id: `post:copy:${post.id}`,
label: t("Copy Text"),
icon: (null);
const panRef = useRef({ x: 0, y: 0 });
const zoomRef = useRef(1);
- const visiblePages = useRef>([]);
- const [image, setImage] = useState(null);
const t = useT();
const { open } = useContextMenu();
const contextTarget = (): ContextMenuTarget => ({
kind: "actions",
id: `reader-pages:${instanceName}`,
label: t("Visible pages"),
- actions: () =>
- visiblePages.current.map((page) => ({
- id: `reader-page:${instanceName}:${page.number}`,
- icon: (null);
const applyTransform = (smooth: boolean) => {
const el = wrapRef.current;
@@ -266,7 +248,6 @@ export function BookFlip({
ensureStyle();
let cancelled = false;
let inst: FlipInstance | null = null;
- visiblePages.current = [];
const origFetch = window.fetch;
const origOnPopState = window.onpopstate;
@@ -299,7 +280,6 @@ export function BookFlip({
const d = (e as CustomEvent).detail as { page?: string | number; name?: string } | undefined;
if (!d || d.name !== instanceName) return;
const spread = String(d.page);
- visiblePages.current = visibleReaderPages(pages, spread);
const first = Number(spread.split("-")[0]);
if (!Number.isFinite(first) || first <= 0) return;
report.current(first - 1, spread);
@@ -484,10 +464,7 @@ export function BookFlip({
return (
setImage(null)}
- />
- )}
);
}
diff --git a/src/views/manga/manga-reader/reader-context.ts b/src/views/manga/manga-reader/reader-context.ts
deleted file mode 100644
index aa4a3e320..000000000
--- a/src/views/manga/manga-reader/reader-context.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export function visibleReaderPages(
- pages: string[],
- spread: string,
-): Array<{ number: number; src: string }> {
- if (!/^\d+(?:-\d+)?$/.test(spread)) return [];
- const numbers = [...new Set(spread.split("-").map(Number))];
- if (
- numbers.some((number) => number < 1 || number > pages.length) ||
- (numbers.length === 2 && Math.abs(numbers[0] - numbers[1]) !== 1)
- )
- return [];
- return numbers.map((number) => ({ number, src: pages[number - 1] }));
-}
diff --git a/src/views/player/hooks/use-actual-playback.ts b/src/views/player/hooks/use-actual-playback.ts
index 5070cd675..3d7e33aa3 100644
--- a/src/views/player/hooks/use-actual-playback.ts
+++ b/src/views/player/hooks/use-actual-playback.ts
@@ -9,6 +9,7 @@ import { actualPlaybackSnapshot } from "@/lib/player/actual-playback";
import { getPlaybackPosition, subscribePlaybackClock } from "@/lib/player/playback-clock";
import type { PlayerSnapshot } from "@/lib/player/bridge";
import type { PlayerSrc } from "@/lib/view";
+import { readRememberedSub, subtitleMediaKey } from "@/lib/subtitles/subtitle-memory";
/** The player, not a menu or a metadata write, owns actual playback recency. */
export function useActualPlayback(src: PlayerSrc, snap: PlayerSnapshot): void {
@@ -22,9 +23,25 @@ export function useActualPlayback(src: PlayerSrc, snap: PlayerSnapshot): void {
useEffect(() => {
const session = { id: crypto.randomUUID(), actor: capturePlaybackActor() };
let last: ActualPlayback | null = null;
+ let observedPlaying = false;
let lastSavedAt = 0;
let previousPosition = getPlaybackPosition();
+ const rememberedSubtitle = () =>
+ readRememberedSub(subtitleMediaKey(src.meta.id, src.episode?.season, src.episode?.episode));
const save = () => {
+ const actor = capturePlaybackActor();
+ if (
+ last &&
+ !!actor.privateCw !== !!session.actor.privateCw &&
+ actor.profileId === session.actor.profileId &&
+ actor.storageProfileId === session.actor.storageProfileId &&
+ actor.accountId === session.actor.accountId &&
+ actor.provider === session.actor.provider
+ ) {
+ // A privacy preference does not create another play or transfer its owner.
+ session.actor = actor;
+ last = { ...last, actor };
+ }
if (last && recordActualPlayback(last)) lastSavedAt = Date.now();
};
const saveCurrent = () => {
@@ -37,6 +54,7 @@ export function useActualPlayback(src: PlayerSrc, snap: PlayerSnapshot): void {
last.positionMs / 1000,
session,
last.playedAt,
+ rememberedSubtitle(),
) ?? last;
}
save();
@@ -45,31 +63,47 @@ export function useActualPlayback(src: PlayerSrc, snap: PlayerSnapshot): void {
const observe = () => {
const current = latest.current;
if (current.key !== key || !loaded.current.armed) return;
+ if (current.snap.status === "playing" && current.snap.firstFrameReady) observedPlaying = true;
+ if (!observedPlaying) return;
const position = getPlaybackPosition();
// Buffer/cache updates share the clock subscription. They are not plays.
if (position === previousPosition) return;
previousPosition = position;
- const next = actualPlaybackSnapshot(current.src, current.snap, position, session);
+ const next = actualPlaybackSnapshot(
+ current.src,
+ current.snap,
+ position,
+ session,
+ Date.now(),
+ rememberedSubtitle(),
+ );
if (!next) return;
last = next;
if (!lastSavedAt || Date.now() - lastSavedAt >= 4000) save();
};
const unsubscribe = subscribePlaybackClock(observe);
const onVisibility = () => {
- if (document.visibilityState === "hidden") save();
+ if (document.visibilityState === "hidden") saveCurrent();
};
- window.addEventListener("pagehide", save);
- window.addEventListener("beforeunload", save);
+ window.addEventListener("pagehide", saveCurrent);
+ window.addEventListener("beforeunload", saveCurrent);
document.addEventListener("visibilitychange", onVisibility);
return () => {
unsubscribe();
- window.removeEventListener("pagehide", save);
- window.removeEventListener("beforeunload", save);
+ window.removeEventListener("pagehide", saveCurrent);
+ window.removeEventListener("beforeunload", saveCurrent);
document.removeEventListener("visibilitychange", onVisibility);
saveCurrent();
};
}, [key]);
useEffect(() => {
if (snap.status !== "playing") flush.current();
- }, [snap.status]);
+ }, [
+ snap.status,
+ snap.subtitleTracks,
+ snap.audioTracks,
+ snap.subDelaySec,
+ snap.audioDelaySec,
+ snap.subtitleFps,
+ ]);
}
diff --git a/src/views/player/hooks/use-auto-retry.ts b/src/views/player/hooks/use-auto-retry.ts
index 6b66d2f0a..7ef862095 100644
--- a/src/views/player/hooks/use-auto-retry.ts
+++ b/src/views/player/hooks/use-auto-retry.ts
@@ -1,4 +1,11 @@
-import { useCallback, useEffect, useRef, useState, type RefObject } from "react";
+import {
+ useCallback,
+ useEffect,
+ useRef,
+ useState,
+ type RefObject,
+ type SetStateAction,
+} from "react";
import type { PlayerBridge, PlayerSnapshot } from "@/lib/player/bridge";
import {
getPlaybackBuffered,
@@ -13,7 +20,10 @@ import { registerStreamProxy } from "@/lib/stream-proxy";
import { buildTranscodedUrl, probeStremioServer } from "@/lib/stremio-server";
import type { DebridStore } from "@/lib/debrid/types";
import type { Meta } from "@/lib/cinemeta";
-import type { PlayerSrc, PlayEpisode } from "@/lib/view";
+import type { PlayerSrc, PlayEpisode, PickerOptions } from "@/lib/view";
+import { isPlaybackActorCurrent } from "@/lib/playback-history";
+import { continuationAppliesToSource } from "@/lib/player/continue-playback";
+import { playerLoadIdentity } from "@/lib/player/load-identity";
import {
BLACK_SCREEN_GRACE_MS,
MAX_AUTORETRY_ATTEMPTS,
@@ -24,11 +34,7 @@ import {
} from "../player-utils";
import { GENUINE_FAILURE_WINDOW_MS, type EngineStats } from "@/lib/torrent/engine-stats";
-type OpenPicker = (
- meta: Meta,
- episode?: PlayEpisode,
- opts?: { autoPlay?: boolean; attempt?: number },
-) => void;
+type OpenPicker = (meta: Meta, episode?: PlayEpisode, opts?: PickerOptions) => void;
export type SourceError = { status: number; host: string; exhausted?: boolean };
@@ -70,14 +76,18 @@ export function useAutoRetry(params: {
} = params;
const isLocal = isLocalUrl(src.url);
const isLive = src.meta.id.startsWith("iptv:");
+ const openingKey = JSON.stringify([
+ playerLoadIdentity(src, src.url, src.episode?.season, src.episode?.episode),
+ src.continuation?.id,
+ ]);
const ENGINE_FIRST_FRAME_GRACE_MS = 20_000;
const ENGINE_HARD_CEILING_MS = 75_000;
const ENGINE_COMPLETE_RELOAD_MS = 8_000;
const ENGINE_COMPLETE_FAILURE_MS = 20_000;
const urlAtRef = useRef(0);
- const urlSeenRef = useRef {
- contextOrigin.current = node;
- contextRef(node);
- }}
+ ref={contextRef}
tabIndex={0}
aria-label={t("Visible pages")}
className="relative h-full w-full overflow-hidden"
@@ -503,13 +480,6 @@ export function BookFlip({
>
- {image && (
- 
+
+
+
+
`);
- for (const id of ["dialog", "editor", "player", "reader", "custom", "frame"])
+ for (const id of ["dialog", "editor", "player", "reader", "custom", "frame", "image", "backdrop"])
assert.equal(isPageContextBackground(dom.window.document.getElementById(id)), false, id);
assert.equal(isPageContextBackground(null), false);
dom.window.close();
diff --git a/tests/context-quick-actions.test.ts b/tests/context-quick-actions.test.ts
index 12a7286e3..4670988ff 100644
--- a/tests/context-quick-actions.test.ts
+++ b/tests/context-quick-actions.test.ts
@@ -1,120 +1,75 @@
-// @ts-expect-error Node test types are outside browser config.
import assert from "node:assert/strict";
-// @ts-expect-error Node test types are outside browser config.
import test from "node:test";
import {
contextNavigationFooter,
partitionContextActions,
} from "../src/lib/context-quick-actions.ts";
-test("unsupported image copy is omitted from the strip without inventing paste", () => {
- const result = partitionContextActions(
- [],
- [{ id: "image:copy", label: "Copy Image", disabled: true }],
- [],
- );
- assert.deepEqual(result.quick, []);
-});
+const back = { id: "page:back", label: "Back", disabled: true };
+const settings = { id: "page:go:settings", label: "Settings", run: () => {} };
+const nav = [
+ back,
+ { id: "page:go-to", label: "Go to", children: [settings, { id: "page:go:home", label: "Home" }] },
+ { id: "page:my-profile", label: "Open my profile" },
+ { id: "page:refresh", label: "Refresh" },
+];
+const background = {
+ kind: "actions",
+ id: "page:home",
+ label: "Page actions",
+ scope: "page-background",
+ actions: () => nav,
+};
+const partition = partitionContextActions as (
+ ...args: any[]
+) => ReturnType