@linxin666/dsh-pet 0.3.20 → 0.3.21

package/lib/index.js

@@ -1171,6 +1171,37 @@ var PetLedger = class {
 		this.dirty = true;
 	}
 	/**
+	* Select one pet's frames2d skin; `undefined` clears the choice back to the
+	* pet's default look. Manifest validation stays a caller concern, exactly
+	* like setPetName's length check.
+	*/
+	setPetSkin(petId, skinId) {
+		const skins = this.current.skins;
+		if (skinId === void 0) {
+			if (skins[petId] === void 0) return;
+			const next = { ...skins };
+			delete next[petId];
+			this.current = {
+				...this.current,
+				skins: next
+			};
+		} else {
+			if (skins[petId] === skinId) return;
+			this.current = {
+				...this.current,
+				skins: {
+					...skins,
+					[petId]: skinId
+				}
+			};
+		}
+		this.dirty = true;
+	}
+	/** The persisted skin id for one pet (undefined = the pet's default look). */
+	petSkin(petId) {
+		return this.current.skins[petId];
+	}
+	/**
 	* Swap the reaction pools to another pet's custom remarks (called on pet
 	* selection). Slots the pet does not declare fall back to voice packs or built-ins.
 	*/
@@ -1370,6 +1401,7 @@ function emptyPersist() {
 	return {
 		petId: DEFAULT_PET_ID,
 		names: {},
+		skins: {},
 		affinity: emptyAffinity(),
 		treats: emptyTreatLedger(),
 		display: { ...defaultDisplayConfig },
@@ -1400,6 +1432,18 @@ function loadPetNames(parsed) {
 	}
 	return names;
 }
+/** Sanitize the per-pet skin selection map (string keys, non-empty trimmed values). */
+function loadPetSkins(parsed) {
+	const skins = {};
+	if (typeof parsed.skins !== "object" || parsed.skins === null) return skins;
+	for (const [id, value] of Object.entries(parsed.skins)) {
+		if (id === "" || typeof value !== "string") continue;
+		const skin = value.trim();
+		if (skin === "") continue;
+		skins[id] = skin;
+	}
+	return skins;
+}
 /** Clamp one count/score into [0, max]. */
 function clamp(value, max) {
 	return Math.min(max, Math.max(0, value));
@@ -1424,12 +1468,15 @@ function loadGameplay(parsed) {
 			if (key === "" || typeof value !== "number" || !Number.isFinite(value)) continue;
 			currencies[key] = Math.min(GAMEPLAY_LOAD_CURRENCY_CAP, Math.max(0, Math.floor(value)));
 		}
-		result[petId] = {
+		const item = {
 			stats,
 			currencies,
 			mode: record.mode === "work" || record.mode === "sleep" ? record.mode : null,
 			settledAt: clamp(finiteNum(record.settledAt, 0), Number.MAX_SAFE_INTEGER)
 		};
+		if (typeof record.incomeCarryMs === "number" && Number.isFinite(record.incomeCarryMs)) item.incomeCarryMs = Math.max(0, record.incomeCarryMs);
+		if (typeof record.restoreCarryMs === "number" && Number.isFinite(record.restoreCarryMs)) item.restoreCarryMs = Math.max(0, record.restoreCarryMs);
+		result[petId] = item;
 	}
 	return result;
 }
@@ -1469,6 +1516,7 @@ function loadPetPersist(dir = petHomeDir()) {
 		return {
 			petId,
 			names,
+			skins: loadPetSkins(parsed),
 			affinity,
 			treats,
 			display,
@@ -2335,7 +2383,10 @@ function settleGameplay(state, manifest, now, options) {
 		}
 	}
 	if (manifest.passiveIncome !== void 0) {
-		const ticks = Math.floor(elapsedMs / manifest.passiveIncome.intervalMs);
+		const incomeElapsed = elapsedMs + (state.incomeCarryMs ?? 0);
+		const interval = manifest.passiveIncome.intervalMs;
+		const ticks = Math.floor(incomeElapsed / interval);
+		state.incomeCarryMs = incomeElapsed % interval;
 		if (ticks > 0) {
 			const currency = manifest.passiveIncome.currency;
 			state.currencies[currency] = (state.currencies[currency] ?? 0) + ticks * manifest.passiveIncome.amount;
@@ -2343,13 +2394,16 @@ function settleGameplay(state, manifest, now, options) {
 		}
 	}
 	if (state.mode === "sleep" && manifest.sleep !== void 0) {
-		const ticks = Math.floor(elapsedMs / manifest.sleep.restore.intervalMs);
+		const restoreElapsed = elapsedMs + (state.restoreCarryMs ?? 0);
+		const interval = manifest.sleep.restore.intervalMs;
+		const ticks = Math.floor(restoreElapsed / interval);
+		state.restoreCarryMs = restoreElapsed % interval;
 		if (ticks > 0) {
 			const stat = manifest.sleep.restore.stat;
 			state.stats[stat] = (state.stats[stat] ?? 0) + ticks * manifest.sleep.restore.amount;
 			changed = true;
 		}
-	}
+	} else state.restoreCarryMs = 0;
 	state.settledAt = now;
 	clampGameplay(state, manifest);
 	return changed;
@@ -4794,6 +4848,40 @@ var PetService = class extends Service {
 			display: this.ledger.snapshot.display
 		};
 	}
+	/**
+	* The persisted skin for one entry, when the manifest still declares it: a
+	* stale id (skin removed from the manifest, pet swapped) reads as "default"
+	* rather than pinning a track the browser half cannot resolve.
+	*/
+	persistedSkin(entry) {
+		const stored = this.ledger.petSkin(entry.id);
+		if (stored === void 0) return void 0;
+		return entry.frames2d?.skins?.some((skin) => skin.id === stored) === true ? stored : void 0;
+	}
+	/**
+	* RPC: select the current pet's frames2d skin (`undefined` restores the
+	* pet's default look). The choice is stored per pet, so every later state
+	* view (reload, client restart, pet re-selection) serves it back.
+	*/
+	async setSkin(skin) {
+		const entry = this.activeEntry();
+		const declared = entry.frames2d?.skins ?? [];
+		if (skin === void 0) {
+			this.ledger.setPetSkin(entry.id, void 0);
+			this.flush();
+			return { ok: true };
+		}
+		if (!declared.some((candidate) => candidate.id === skin)) return {
+			ok: false,
+			error: "unknown-skin"
+		};
+		this.ledger.setPetSkin(entry.id, skin);
+		this.flush();
+		return {
+			ok: true,
+			skin
+		};
+	}
 	/** RPC: update display config (size / position). Values are clamped to whole pixels. */
 	async setConfig(patch) {
 		const next = {
@@ -4903,6 +4991,7 @@ var PetService = class extends Service {
 			gameplay = this.gameplayViewOf(state);
 		}
 		const announcement = this.announcement !== void 0 && announcementFresh(this.announcement, Date.now()) ? this.announcement : void 0;
+		const skin = this.persistedSkin(entry);
 		return {
 			animation: snapshot.animation,
 			...snapshot.bubble === void 0 ? {} : { bubble: snapshot.bubble },
@@ -4919,6 +5008,7 @@ var PetService = class extends Service {
 				description: entry.description
 			},
 			name: this.petName(),
+			...skin === void 0 ? {} : { skin },
 			treats: {
 				stocked: this.ledger.snapshot.treats.treats,
 				max: this.ledger.treatMax
@@ -5605,6 +5695,11 @@ function makePetRoutes(deps) {
 			if (typeof name !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-name"));
 			return service.setName(name);
 		}),
+		postRoute(ctx, "/api/pet/set-skin", (body) => {
+			const skin = body.skin;
+			if (skin !== void 0 && typeof skin !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-skin"));
+			return service.setSkin(skin === void 0 || skin === "" ? void 0 : skin);
+		}),
 		postRoute(ctx, "/api/pet/set-pet", (body) => {
 			const petId = body.petId;
 			if (typeof petId !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-pet"));

package/lib/types/client/gameplay-hud.d.ts

@@ -21,6 +21,14 @@ export interface GameplayApi {
     setMode: (mode: 'work' | 'sleep' | null) => Promise<PetGameplayVerbResult>;
     workTick: () => Promise<PetGameplayVerbResult>;
     buy: (item: string) => Promise<PetGameplayVerbResult>;
+    /**
+     * Persist the selected skin for the current pet (host-authoritative;
+     * `undefined` restores the pet's default look).
+     */
+    setSkin: (skin: string | undefined) => Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
 }
 /**
  * The per-pet coordination bus. The frames2d visual mount registers the
@@ -32,6 +40,13 @@ export interface GameplayBus {
     setTrack?: (track?: string) => void;
     /** Swap the pet's base idle track (skin switch); undefined restores default. */
     setIdleTrack?: (track?: string) => void;
+    /**
+     * The base idle track the HUD wants right now, latched on the bus so a
+     * renderer that registers late (or remounts: hidden/summoned, StrictMode's
+     * double mount) still applies the restored skin instead of snapping back to
+     * the default look. Mutating it never requires a re-render.
+     */
+    idleTrack?: string;
     tap?: (fx: number, fy: number) => void;
     /**
      * Card open/close request from the chrome (the hover panel's 玩法 action):

package/lib/types/client/gameplay-hud.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gameplay-hud.d.ts","sourceRoot":"","sources":["../../../src/client/gameplay-hud.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAsE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAA;AAC7G,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAqB,MAAM,gBAAgB,CAAA;AACtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,cAAc,CAAA;AAGtC,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;IACxD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;IAC1E,QAAQ,EAAE,MAAM,OAAO,CAAC,qBAAqB,CAAC,CAAA;IAC9C,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;CACtD;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,gFAAgF;IAChF,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;CACpC;AAYD,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,KAAK,EAAE;IACjC,UAAU,EAAE,aAAa,CAAA;IACzB,KAAK,EAAE,gBAAgB,CAAA;IACvB,GAAG,EAAE,WAAW,CAAA;IAChB,GAAG,EAAE,WAAW,CAAA;IAChB,IAAI,EAAE,UAAU,CAAA;IAChB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;CAC/B,GAAG,YAAY,GAAG,IAAI,CAwatB"}
+{"version":3,"file":"gameplay-hud.d.ts","sourceRoot":"","sources":["../../../src/client/gameplay-hud.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAsE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAA;AAC7G,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAqB,MAAM,gBAAgB,CAAA;AACtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,cAAc,CAAA;AAGtC,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;IACxD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;IAC1E,QAAQ,EAAE,MAAM,OAAO,CAAC,qBAAqB,CAAC,CAAA;IAC9C,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;IACrD;;;OAGG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChF;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,gFAAgF;IAChF,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;CACpC;AAYD,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,KAAK,EAAE;IACjC,UAAU,EAAE,aAAa,CAAA;IACzB,KAAK,EAAE,gBAAgB,CAAA;IACvB,GAAG,EAAE,WAAW,CAAA;IAChB,GAAG,EAAE,WAAW,CAAA;IAChB,IAAI,EAAE,UAAU,CAAA;IAChB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;CAC/B,GAAG,YAAY,GAAG,IAAI,CAodtB"}

package/lib/types/client/gameplay-hud.js

@@ -20,6 +20,8 @@ export function GameplayHud(props) {
     const def = definition.gameplay;
     const view = ui.snapshot?.gameplay;
     const phase = ui.snapshot?.phase ?? 'idle';
+    // Host-persisted skin selection for this pet (undefined = default look).
+    const persistedSkin = ui.snapshot?.skin;
     const [open, setOpen] = useState(false);
     const [page, setPage] = useState('root');
     // Currently selected skin id (base idle swap); undefined = default look.
@@ -247,12 +249,16 @@ export function GameplayHud(props) {
     }, [definition.id, def]);
     // Work loop: hold the work track, adjudicate one round per tick, play the
     // result track for its hold window, then resume. Leaving the mode
-    // releases the override so the phase mapping takes over.
+    // releases the override so the phase mapping takes over. A skin that
+    // declares gameplayTracks for the work states plays its own art instead.
     useEffect(() => {
         const work = def?.work;
         if (def === undefined || work === undefined || view?.mode !== 'work')
             return undefined;
-        bus.setTrack?.(work.state);
+        const skinGameplay = definition.frames2d?.skins?.find(skin => skin.id === skinIdRef.current)?.gameplayTracks;
+        /** The state's track, swapped for the skin's override when it declares one. */
+        const trackOf = (state) => skinGameplay?.[state] ?? state;
+        bus.setTrack?.(trackOf(work.state));
         let resultTimer = 0;
         const timer = window.setInterval(() => {
             if (busyRef.current)
@@ -260,15 +266,20 @@ export function GameplayHud(props) {
             busyRef.current = true;
             void api.workTick().then((result) => {
                 busyRef.current = false;
+                // Leaving work mode while the adjudication is in flight drops the late
+                // result: writing it back would show work rewards and play the result
+                // track for a mode the user has already left (#1495).
+                if (modeRef.current !== 'work')
+                    return;
                 applyResult(result);
                 if (result.ok !== true || result.outcome === undefined)
                     return;
-                const resultTrack = result.outcome === 'success' ? work.successState : work.failState;
+                const resultTrack = trackOf(result.outcome === 'success' ? work.successState : work.failState);
                 const hold = result.outcome === 'success' ? work.resultMs?.success ?? 1300 : work.resultMs?.fail ?? 1900;
                 bus.setTrack?.(resultTrack);
                 resultTimer = window.setTimeout(() => {
                     if (modeRef.current === 'work')
-                        bus.setTrack?.(work.state);
+                        bus.setTrack?.(trackOf(work.state));
                 }, hold);
             }, () => { busyRef.current = false; });
         }, work.tickMs);
@@ -277,8 +288,8 @@ export function GameplayHud(props) {
             window.clearTimeout(resultTimer);
             bus.setTrack?.(undefined);
         };
-        // eslint-disable-next-line react-hooks/exhaustive-deps -- the loop keys on the mode value
-    }, [definition.id, def, view?.mode]);
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- the loop keys on the mode and the selected skin
+    }, [definition.id, def, view?.mode, skinId]);
     // Sleep loop: hold the sleep track; restore is host-side (lazy settle).
     // While a skin with a gameplayTracks.sleep override is selected, the skin's
     // own track replaces the default sleep track (e.g. a skin-specific doze).
@@ -315,10 +326,41 @@ export function GameplayHud(props) {
     const setMode = (next) => {
         void api.setMode(next).then(applyResult, () => undefined);
     };
+    // Skin selection is persisted host-side (per pet): re-seed the menu from
+    // every fresh state view, so a page reload or client restart keeps the last
+    // choice instead of snapping back to the default look.
+    useEffect(() => {
+        setSkinId(persistedSkin);
+    }, [definition.id, persistedSkin]);
+    // Push the resolved base idle track into the renderer whenever the pet or
+    // the selection changes. The value is latched on the bus first: the visual
+    // may register later, or remount later (hidden/summoned), and reads the
+    // latch back on activation so a restored skin never falls back to default.
+    useEffect(() => {
+        const skin = definition.frames2d?.skins?.find(candidate => candidate.id === skinId);
+        bus.idleTrack = skin?.idleTrack;
+        bus.setIdleTrack?.(skin?.idleTrack);
+        // persistedSkin rides the deps so the host's value also re-pushes on
+        // arrival (a renderer that mounted early still converges).
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- one push per selection
+    }, [definition.id, skinId, persistedSkin]);
     const skins = definition.frames2d?.skins;
+    /** The base idle track one skin id resolves to (undefined = default look). */
+    const skinTrackOf = (id) => id === undefined ? undefined : definition.frames2d?.skins?.find(candidate => candidate.id === id)?.idleTrack;
     const selectSkin = (skin) => {
         setSkinId(skin?.id);
         bus.setIdleTrack?.(skin?.idleTrack);
+        // The host owns the choice: a refusal (unknown skin) restores both the
+        // menu highlight and the renderer to the value it still serves.
+        const restore = () => {
+            setSkinId(persistedSkin);
+            bus.setIdleTrack?.(skinTrackOf(persistedSkin));
+        };
+        void api.setSkin(skin?.id).then((result) => {
+            if (result.ok)
+                return;
+            restore();
+        }, restore);
     };
     return (_jsxs("div", { ref: hudRef, className: styles.gameplayHud, "data-dsh-pet-gameplay": definition.id, children: [floats.map(entry => (_jsx("div", { className: styles.gameplayFloat, children: entry.text }, entry.id))), mode !== null && (_jsx("div", { className: styles.gameplayModeChip, children: tr(mode === 'work' ? 'pet.gameplay.working' : 'pet.gameplay.sleeping') })), open && (_jsxs("div", { ref: cardRef, className: styles.gameplayCard, "data-page": page, children: [page === 'root' && (_jsxs(_Fragment, { children: [_jsx("div", { className: styles.gameplayBars, children: Object.entries(stats).map(([name, stat]) => {
                                     const value = view.stats[name] ?? 0;

package/lib/types/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGnE,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAA;AA8ElG,wEAAwE;AACxE,eAAO,MAAM,MAAM,UAA2E,CAAA;AAE9F,qEAAqE;AACrE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACxE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC7D,YAAY,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACtF,YAAY,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf;;;;WAIG;QACH,aAAa,CAAC,EAAE;YAAE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;SAAE,CAAA;KAC1E;CACF;AAoBD,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAiU9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGnE,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAA;AAiFlG,wEAAwE;AACxE,eAAO,MAAM,MAAM,UAA2E,CAAA;AAE9F,qEAAqE;AACrE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACxE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC7D,YAAY,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACtF,YAAY,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf;;;;WAIG;QACH,aAAa,CAAC,EAAE;YAAE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;SAAE,CAAA;KAC1E;CACF;AAuBD,wBAAgB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAqU9C"}

package/lib/types/client/index.js

@@ -15,6 +15,7 @@
 import { createElement } from 'react';
 import { createRoot } from 'react-dom/client';
 import { createPetStore } from "./pet-store.js";
+import { createWorkTickGate } from "./work-tick-gate.js";
 import { PetDockEntry } from "./PetDockEntry.js";
 import { defaultPetRendererRegistry } from "./renderers/registry.js";
 import { live2dRenderer } from "./renderers/live2d.js";
@@ -47,6 +48,7 @@ const petApi = {
     setConfig: (patch) => petFetch('/api/pet/set-config', patch),
     setName: (name) => petFetch('/api/pet/set-name', { name }),
     setPet: (petId) => petFetch('/api/pet/set-pet', { petId }),
+    setSkin: (skin) => petFetch('/api/pet/set-skin', skin === undefined ? {} : { skin }),
     gameplayTouch: (zone) => petFetch('/api/pet/gameplay/touch', zone === undefined ? {} : { zone }),
     gameplaySetMode: (mode) => petFetch('/api/pet/gameplay/mode', { mode }),
     gameplayWorkTick: () => petFetch('/api/pet/gameplay/work-tick', {}),
@@ -64,16 +66,18 @@ export const inject = ['slots', 'locale', 'connection', 'settingsScope', 'remote
  * first-level settings section.
  * @param ctx - client root context.
  */
+/** The page-wide work-tick gate; its window follows the active pet's cadence. */
+const workTickGate = createWorkTickGate();
 /**
- * Module-wide work-tick throttle (ms). Hot reloads can leave several
- * GameplayHud instances alive, each running its own 10s work interval;
- * without a shared gate every interval would call workTick and each stale
- * call re-rolls, re-grants treats and re-plays the success/fail track, so
- * the outcome appears to play several times per window. This shared marker
- * accepts the first adjudication of a window and silently suppresses the
- * duplicates that follow. Reset when (re-)entering work mode.
+ * The work cadence the active pet declares, when its registry entry is known.
+ * @param store - the pet store holding the host snapshot and the registry list.
+ * @returns the configured `gameplay.work.tickMs`, or undefined when unknown.
  */
-let lastWorkTickAt = 0;
+function activeWorkTickMs(store) {
+    const state = store.getSnapshot();
+    const definition = state.pets.find((entry) => entry.id === state.snapshot?.pet.id);
+    return definition?.gameplay?.work?.tickMs;
+}
 export function apply(ctx) {
     // Anonymous install heartbeat (docs/telemetry.md): one beat per browser per
     // UTC day, package name only, silent failure.
@@ -309,19 +313,23 @@ export function apply(ctx) {
                 },
                 gameplay: {
                     touch: (zone) => petApi.gameplayTouch(zone),
+                    setSkin: (skin) => petApi.setSkin(skin).then((result) => {
+                        if (result.ok)
+                            pollNow();
+                        return result;
+                    }, () => ({ ok: false, error: 'transport' })),
                     setMode: async (mode) => {
                         if (mode === 'work')
-                            lastWorkTickAt = 0;
+                            workTickGate.reset();
                         return petApi.gameplaySetMode(mode);
                     },
                     workTick: async () => {
                         // One adjudication per tick window, page-wide: suppress stale
-                        // duplicate intervals (HMR) re-playing the result track.
-                        const now = Date.now();
-                        if (now - lastWorkTickAt < 8500) {
+                        // duplicate intervals (HMR) re-playing the result track. The window
+                        // is the pet's own cadence, so a shorter tickMs is not downgraded.
+                        if (!workTickGate.allow(activeWorkTickMs(petStore))) {
                             return { ok: true };
                         }
-                        lastWorkTickAt = now;
                         return petApi.gameplayWorkTick();
                     },
                     buy: (item) => petApi.gameplayBuy(item),

package/lib/types/client/renderers/Frames2dVisualMount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Frames2dVisualMount.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/Frames2dVisualMount.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAA+B,KAAK,YAAY,EAAE,MAAM,OAAO,CAAA;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAInD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAA;AAEvC,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,UAAU,EAAE,aAAa,CAAA;IACzB,KAAK,EAAE,aAAa,CAAA;IACpB,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,gEAAgE;IAChE,IAAI,EAAE,UAAU,CAAA;IAChB,yEAAyE;IACzE,GAAG,CAAC,EAAE,WAAW,CAAA;IACjB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;CAC/B,GAAG,YAAY,CAiFf"}
+{"version":3,"file":"Frames2dVisualMount.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/Frames2dVisualMount.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAA+B,KAAK,YAAY,EAAE,MAAM,OAAO,CAAA;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAInD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAA;AAEvC,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,UAAU,EAAE,aAAa,CAAA;IACzB,KAAK,EAAE,aAAa,CAAA;IACpB,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,gEAAgE;IAChE,IAAI,EAAE,UAAU,CAAA;IAChB,yEAAyE;IACzE,GAAG,CAAC,EAAE,WAAW,CAAA;IACjB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;CAC/B,GAAG,YAAY,CAqFf"}

package/lib/types/client/renderers/Frames2dVisualMount.js

@@ -52,6 +52,11 @@ export function Frames2dVisualMount(props) {
             const gameplayBus = props.bus;
             gameplayBus.setTrack = (track) => { handleRef.current?.setState(track); };
             gameplayBus.setIdleTrack = (track) => { handleRef.current?.setIdleTrack(track); };
+            // The HUD latches the wanted base idle (skin selection, restored from the
+            // host snapshot): apply it on activation, so a late or repeated mount
+            // never repaints the pet with the default look.
+            if (gameplayBus.idleTrack !== undefined)
+                handle.setIdleTrack(gameplayBus.idleTrack);
             cleanups.push(() => {
                 gameplayBus.setTrack = undefined;
                 gameplayBus.setIdleTrack = undefined;

package/lib/types/client/renderers/frames2d.d.ts

@@ -12,10 +12,11 @@
  * Frame presentation has two modes picked once at mount by capability
  * probing:
  * - Canvas bitmap buffer (default where createImageBitmap/fetch/2D context
- *   exist): every frame is decoded exactly once into an ImageBitmap during
- *   the warm pass and drawn onto one <canvas> - steady-state playback issues
- *   zero DOM mutations and zero re-decodes (measured hotspot: swapping
- *   <img>.src per frame drove image decode + invalidation every tick).
+ *   exist): frames are decoded once into an ImageBitmap on demand, with a
+ *   bounded look-ahead window over the playing track, and drawn onto one
+ *   <canvas> - steady-state playback issues zero DOM mutations and zero
+ *   re-decodes (measured hotspot: swapping <img>.src per frame drove image
+ *   decode + invalidation every tick).
  * - Classic <img> fallback (jsdom/tests or missing APIs): identical to the
  *   historical behavior - cache-warm Image elements plus guarded src swaps,
  *   so environments without modern decoding keep working unchanged.

package/lib/types/client/renderers/frames2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frames2d.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/frames2d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAA4B,KAAK,WAAW,EAA2B,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACzI,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,8DAA8D;AAC9D,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAC3C,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACjE,wEAAwE;IACxE,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAC7B;AAED,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAA;IACjB,sFAAsF;IACtF,YAAY,CAAC,EAAE,6BAA6B,EAAE,CAAA;IAC9C,2EAA2E;IAC3E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACxC;AAED,4DAA4D;AAC5D,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB;AAED,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;IACzC;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;IAC7C,2DAA2D;IAC3D,YAAY,IAAI,MAAM,CAAA;CACvB;AAuFD,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,iBAAiB,CA6T3D,CAAA"}
+{"version":3,"file":"frames2d.d.ts","sourceRoot":"","sources":["../../../../src/client/renderers/frames2d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAA4B,KAAK,WAAW,EAA2B,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACzI,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,8DAA8D;AAC9D,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAC3C,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACjE,wEAAwE;IACxE,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAC7B;AAED,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAA;IACjB,sFAAsF;IACtF,YAAY,CAAC,EAAE,6BAA6B,EAAE,CAAA;IAC9C,2EAA2E;IAC3E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACxC;AAED,4DAA4D;AAC5D,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB;AAED,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;IACzC;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;IAC7C,2DAA2D;IAC3D,YAAY,IAAI,MAAM,CAAA;CACvB;AAuFD,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,iBAAiB,CAoU3D,CAAA"}

package/lib/types/client/renderers/frames2d.js

@@ -12,10 +12,11 @@
  * Frame presentation has two modes picked once at mount by capability
  * probing:
  * - Canvas bitmap buffer (default where createImageBitmap/fetch/2D context
- *   exist): every frame is decoded exactly once into an ImageBitmap during
- *   the warm pass and drawn onto one <canvas> - steady-state playback issues
- *   zero DOM mutations and zero re-decodes (measured hotspot: swapping
- *   <img>.src per frame drove image decode + invalidation every tick).
+ *   exist): frames are decoded once into an ImageBitmap on demand, with a
+ *   bounded look-ahead window over the playing track, and drawn onto one
+ *   <canvas> - steady-state playback issues zero DOM mutations and zero
+ *   re-decodes (measured hotspot: swapping <img>.src per frame drove image
+ *   decode + invalidation every tick).
  * - Classic <img> fallback (jsdom/tests or missing APIs): identical to the
  *   historical behavior - cache-warm Image elements plus guarded src swaps,
  *   so environments without modern decoding keep working unchanged.
@@ -230,6 +231,27 @@ export const frames2dRenderer = {
             pumpFrames();
             return job;
         };
+        /**
+         * Bounded look-ahead window: decode only the frames playback is about to
+         * need. The historical warm pass decoded every frame of every track up
+         * front - a shipped pet carries ~1.1k 512x683 frames, so that pass pulls
+         * tens of megabytes and retains every decoded bitmap for the life of the
+         * page. Prefetching the playing track's next frames keeps loops and phase
+         * switches warm while unplayed tracks (and every unselected skin's
+         * frames) stay on demand, where playback jumps the queue anyway.
+         */
+        const PREFETCH_AHEAD = 12;
+        const prefetchAhead = (trackId, index) => {
+            const def = config.tracks[trackId];
+            if (def === undefined)
+                return;
+            const end = Math.min(def.frames.length, index + 1 + PREFETCH_AHEAD);
+            for (let ahead = index + 1; ahead < end; ahead += 1) {
+                const url = def.frames[ahead];
+                if (url !== undefined)
+                    void loadFrame(url);
+            }
+        };
         let disposed = false;
         let timer;
         let watchdog;
@@ -277,6 +299,7 @@ export const frames2dRenderer = {
             const url = def?.frames[index];
             if (url === undefined)
                 return;
+            prefetchAhead(trackId, index);
             if (img !== null) {
                 if (img.getAttribute('src') !== url)
                     img.src = url;
@@ -358,20 +381,6 @@ export const frames2dRenderer = {
                     tick();
             }, WATCHDOG_MS);
         }
-        // Warm pass: decode every frame up front (tiny same-origin webp files)
-        // so loops and phase switches never wait on a first decode - same intent
-        // as the historical Image-cache warm loop, now feeding the decode cache.
-        // Phase-reachable tracks enqueue first so early switches never trail the
-        // full warm backlog; demand loads jump the queue regardless.
-        const warmTrackIds = [
-            ...new Set([...Object.values(config.phases), config.phases.idle]),
-        ];
-        for (const warmTrack of [...warmTrackIds, ...Object.keys(config.tracks)].map((id) => config.tracks[id])) {
-            if (warmTrack === undefined)
-                continue;
-            for (const warmUrl of warmTrack.frames)
-                void loadFrame(warmUrl);
-        }
         play(track);
         let disposedOnce = false;
         const dispose = () => {

package/lib/types/client/work-tick-gate.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Page-wide work-tick gate for the pet's work mode. Hot reloads can leave
+ * several GameplayHud instances alive, each running its own work interval;
+ * without a shared gate every interval would call workTick and each stale call
+ * re-rolls, re-grants treats and re-plays the success/fail track, so the
+ * outcome appears to play several times per window. The gate accepts the first
+ * adjudication of a window and silently suppresses the duplicates that follow.
+ *
+ * The window is the active pet's own `gameplay.work.tickMs`, not a constant: a
+ * pet configured with a shorter cadence must actually adjudicate that often,
+ * while a fixed window would downgrade it without saying so (#1494).
+ * @module @linxin666/dsh-pet/client/work-tick-gate
+ */
+/** Window used when the active pet declares no work cadence. */
+export declare const DEFAULT_WORK_TICK_MS = 10000;
+/**
+ * The gate window for one pet: its configured cadence, clamped to the manifest's
+ * own bounds so a malformed registry entry cannot disable or flood the gate.
+ * @param tickMs - the active definition's `gameplay.work.tickMs`, when it has one.
+ * @returns the window in milliseconds.
+ */
+export declare function workTickWindowMs(tickMs: number | undefined): number;
+/** The shared work-tick gate. */
+export interface WorkTickGate {
+    /**
+     * Admit one adjudication for the current window.
+     * @param tickMs - the active pet's configured work cadence.
+     * @returns true when this call may adjudicate, false for a duplicate.
+     */
+    allow: (tickMs: number | undefined) => boolean;
+    /** Forget the last adjudication (used when work mode is entered). */
+    reset: () => void;
+}
+/**
+ * Create a gate.
+ * @param now - the clock, injectable so tests control the window.
+ * @returns the gate over that clock.
+ */
+export declare function createWorkTickGate(now?: () => number): WorkTickGate;
+//# sourceMappingURL=work-tick-gate.d.ts.map

package/lib/types/client/work-tick-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-tick-gate.d.ts","sourceRoot":"","sources":["../../../src/client/work-tick-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,QAAS,CAAA;AAM1C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAGnE;AAED,iCAAiC;AACjC,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAA;IAC9C,qEAAqE;IACrE,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,MAAiB,GAAG,YAAY,CAa7E"}

package/lib/types/client/work-tick-gate.js

@@ -0,0 +1,49 @@
+/**
+ * Page-wide work-tick gate for the pet's work mode. Hot reloads can leave
+ * several GameplayHud instances alive, each running its own work interval;
+ * without a shared gate every interval would call workTick and each stale call
+ * re-rolls, re-grants treats and re-plays the success/fail track, so the
+ * outcome appears to play several times per window. The gate accepts the first
+ * adjudication of a window and silently suppresses the duplicates that follow.
+ *
+ * The window is the active pet's own `gameplay.work.tickMs`, not a constant: a
+ * pet configured with a shorter cadence must actually adjudicate that often,
+ * while a fixed window would downgrade it without saying so (#1494).
+ * @module @linxin666/dsh-pet/client/work-tick-gate
+ */
+/** Window used when the active pet declares no work cadence. */
+export const DEFAULT_WORK_TICK_MS = 10_000;
+/** Manifest bounds for `gameplay.work.tickMs` (src/gameplay.ts). */
+const MIN_WORK_TICK_MS = 1_000;
+const MAX_WORK_TICK_MS = 60_000;
+/**
+ * The gate window for one pet: its configured cadence, clamped to the manifest's
+ * own bounds so a malformed registry entry cannot disable or flood the gate.
+ * @param tickMs - the active definition's `gameplay.work.tickMs`, when it has one.
+ * @returns the window in milliseconds.
+ */
+export function workTickWindowMs(tickMs) {
+    if (typeof tickMs !== 'number' || !Number.isFinite(tickMs))
+        return DEFAULT_WORK_TICK_MS;
+    return Math.min(MAX_WORK_TICK_MS, Math.max(MIN_WORK_TICK_MS, tickMs));
+}
+/**
+ * Create a gate.
+ * @param now - the clock, injectable so tests control the window.
+ * @returns the gate over that clock.
+ */
+export function createWorkTickGate(now = Date.now) {
+    let lastAdjudicatedAt = 0;
+    return {
+        allow: (tickMs) => {
+            const at = now();
+            if (at - lastAdjudicatedAt < workTickWindowMs(tickMs))
+                return false;
+            lastAdjudicatedAt = at;
+            return true;
+        },
+        reset: () => {
+            lastAdjudicatedAt = 0;
+        },
+    };
+}

package/lib/types/gameplay.d.ts

@@ -150,6 +150,10 @@ export interface PetGameplayState {
     mode: 'work' | 'sleep' | null;
     /** Epoch ms of the last lazy settle. */
     settledAt: number;
+    /** Accumulated remainder ms towards the next passive income tick. */
+    incomeCarryMs?: number;
+    /** Accumulated remainder ms towards the next sleep restore tick. */
+    restoreCarryMs?: number;
 }
 /** Fresh state for one pet: stats at their initial (default max), no currency. */
 export declare function initialGameplayState(manifest: PetGameplayManifest, now: number): PetGameplayState;