@linxin666/dsh-pet 0.1.1 → 0.1.2

package/lib/types/client/WhalePet.js

@@ -0,0 +1,239 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Whale-girl companion component — the browser half's centerpiece. Renders a
+ * fixed-position floating sprite (React portal onto document.body), plays
+ * the spritesheet track matching the host animation snapshot, and exposes
+ * the interaction surface: click to pet, hover panel with feed/hide, drag to
+ * reposition (persisted via setConfig).
+ * @module @linxin666/dsh-pet/client/WhalePet
+ */
+import { useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { framePosition, FRAME_WIDTH, FRAME_HEIGHT, FRAME_COLUMNS, TRACKS, rowOfTrack, trimTrack, detectFrameCounts } from "./spritesheet.js";
+import styles from './pet.module.css';
+/** Browser URL of the whale-girl atlas (served by the host half's own route). */
+export const PET_SPRITESHEET_URL = '/pet/whale/spritesheet.webp';
+/** Browser URL of the whale-girl manifest (authoritative per-row frame counts). */
+export const PET_MANIFEST_URL = '/pet/whale/pet.json';
+/** Clamp a drag offset inside the viewport with a margin. */
+function clampOffset(value, max) {
+    return Math.max(0, Math.min(max, value));
+}
+/**
+ * The floating pet. The spritesheet frame advances on requestAnimationFrame
+ * with per-frame durations from TRACKS; the atlas image is loaded once and
+ * the background position is written straight to the sprite element (no
+ * per-frame React state).
+ */
+export function WhalePet(props) {
+    const { snapshot, display, feedback } = props;
+    const spriteRef = useRef(null);
+    const floatRef = useRef(null);
+    const [imageReady, setImageReady] = useState(false);
+    const [frameCounts, setFrameCounts] = useState(null);
+    const [hovered, setHovered] = useState(false);
+    const [renaming, setRenaming] = useState(false);
+    const [nameDraft, setNameDraft] = useState('');
+    const [dragPos, setDragPos] = useState(null);
+    const dragRef = useRef(null);
+    const frameRef = useRef({
+        track: null,
+        index: 0,
+        elapsed: 0,
+    });
+    // Load the atlas once; then resolve per-row frame counts so tracks never
+    // play the transparent trailing cells of a short row. One decoded Image
+    // feeds both the sprite render and the frame-count detection. The counts
+    // prefer the authoritatively recorded `frames` field on the pet.json
+    // manifest route and only fall back to the getImageData atlas scan when
+    // that field is absent (older manifests).
+    useEffect(() => {
+        let cancelled = false;
+        const img = new Image();
+        img.onload = () => {
+            if (cancelled)
+                return;
+            setImageReady(true);
+            fetch(PET_MANIFEST_URL)
+                .then((res) => (res.ok ? res.json() : Promise.resolve({})))
+                .then((manifest) => {
+                if (cancelled)
+                    return;
+                const frames = manifest.frames;
+                if (Array.isArray(frames) && frames.length === 9 && frames.every((n) => typeof n === 'number')) {
+                    setFrameCounts(frames);
+                }
+                else {
+                    setFrameCounts(detectFrameCounts(img));
+                }
+            })
+                .catch(() => {
+                if (!cancelled)
+                    setFrameCounts(detectFrameCounts(img));
+            });
+        };
+        img.src = PET_SPRITESHEET_URL;
+        return () => {
+            cancelled = true;
+            img.onload = null;
+        };
+    }, []);
+    // Frame loop: advance the current track and write background-position.
+    // Offsets must be in SCALED coordinates (background-position applies to the
+    // scaled background image), so the current sprite scale rides a ref that
+    // the loop reads every tick. Under prefers-reduced-motion the sprite holds
+    // its track's first frame instead of animating (presentation-only; the
+    // animation state machine is untouched).
+    const spriteScale = display.size / FRAME_HEIGHT;
+    const animation = snapshot?.animation ?? 'idle';
+    const scaleRef = useRef(spriteScale);
+    scaleRef.current = spriteScale;
+    useEffect(() => {
+        const reduceMotion = typeof window !== 'undefined'
+            && window.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches === true;
+        // Paint one static sprite frame up front either way, so the pet is never
+        // blank while the loop heat-up runs.
+        const row = rowOfTrack(animation);
+        const track = frameCounts === null
+            ? TRACKS[animation]
+            : trimTrack(TRACKS[animation], frameCounts[row] ?? TRACKS[animation].frames.length);
+        const leadCol = track.frames[0];
+        const lead = framePosition(row, leadCol, scaleRef.current);
+        if (spriteRef.current !== null) {
+            spriteRef.current.style.backgroundPosition = `${lead.x}px ${lead.y}px`;
+        }
+        if (reduceMotion)
+            return;
+        let raf = 0;
+        let last = performance.now();
+        const tick = (ts) => {
+            const delta = ts - last;
+            last = ts;
+            // Trim the track to the row's real frame count (transparent cells
+            // would render as a vanishing pet).
+            const row = rowOfTrack(animation);
+            const track = frameCounts === null
+                ? TRACKS[animation]
+                : trimTrack(TRACKS[animation], frameCounts[row] ?? TRACKS[animation].frames.length);
+            const st = frameRef.current;
+            if (st.track !== animation) {
+                st.track = animation;
+                st.index = 0;
+                st.elapsed = 0;
+            }
+            st.elapsed += delta;
+            const maxIndex = track.frames.length - 1;
+            while (st.elapsed >= (track.durations[st.index] ?? 0) && st.index < maxIndex) {
+                st.elapsed -= track.durations[st.index] ?? 0;
+                st.index += 1;
+            }
+            if (st.elapsed >= (track.durations[st.index] ?? 0)) {
+                if (track.loop) {
+                    st.elapsed = 0;
+                    st.index = 0;
+                }
+                else {
+                    st.index = maxIndex; // hold the final frame; the host switches tracks
+                }
+            }
+            const col = track.frames[st.index];
+            const { x, y } = framePosition(row, col, scaleRef.current);
+            if (spriteRef.current !== null) {
+                spriteRef.current.style.backgroundPosition = `${x}px ${y}px`;
+            }
+            raf = requestAnimationFrame(tick);
+        };
+        raf = requestAnimationFrame(tick);
+        return () => cancelAnimationFrame(raf);
+    }, [animation, frameCounts]);
+    // Auto-clear the feedback bubble after its CSS animation. The callback
+    // rides a ref so re-renders never reset the timer: the 800ms poll rebuilds
+    // `props` every tick, and depending on it would starve the timeout.
+    const feedbackDoneRef = useRef(props.onFeedbackDone);
+    feedbackDoneRef.current = props.onFeedbackDone;
+    useEffect(() => {
+        if (feedback === null)
+            return;
+        const timer = window.setTimeout(() => feedbackDoneRef.current(), 2600);
+        return () => window.clearTimeout(timer);
+    }, [feedback]);
+    // Dragging: pointer events on the sprite; position is right/bottom based.
+    // `draggedRef` records whether the pointer actually moved, so the browser's
+    // trailing click (fired after pointerup) does not pet the whale.
+    const draggedRef = useRef(false);
+    const onPointerDown = (e) => {
+        e.preventDefault();
+        e.target.setPointerCapture?.(e.pointerId);
+        const current = dragPos ?? { right: display.right, bottom: display.bottom };
+        dragRef.current = { startX: e.clientX, startY: e.clientY, ...current };
+        draggedRef.current = false;
+        setHovered(false);
+    };
+    const onPointerMove = (e) => {
+        const drag = dragRef.current;
+        if (drag === null)
+            return;
+        const dx = e.clientX - drag.startX;
+        const dy = e.clientY - drag.startY;
+        if (Math.abs(dx) > 4 || Math.abs(dy) > 4)
+            draggedRef.current = true;
+        const right = clampOffset(drag.right - dx, window.innerWidth - 40);
+        const bottom = clampOffset(drag.bottom - dy, window.innerHeight - 40);
+        setDragPos({ right, bottom });
+    };
+    const onPointerUp = () => {
+        if (dragRef.current === null)
+            return;
+        dragRef.current = null;
+        if (dragPos !== null)
+            props.onDragEnd(dragPos.right, dragPos.bottom);
+    };
+    const pos = dragPos ?? { right: display.right, bottom: display.bottom };
+    const spriteWidth = Math.round(FRAME_WIDTH * spriteScale);
+    const spriteHeight = Math.round(FRAME_HEIGHT * spriteScale);
+    const float = (_jsxs("div", { ref: floatRef, className: styles.float, style: { right: pos.right, bottom: pos.bottom, zIndex: 2147483000 }, onPointerEnter: () => setHovered(true), onPointerLeave: (e) => {
+            // The panel and bubble render OUTSIDE the container's box (absolute,
+            // above the sprite), so moving onto them fires pointerleave on the
+            // container. Treat a target still inside the container's DOM (the
+            // overflowed panel) as "still hovering".
+            const next = e.relatedTarget;
+            if (next instanceof Node && floatRef.current?.contains(next))
+                return;
+            setHovered(false);
+        }, children: [_jsx("div", { ref: spriteRef, className: styles.sprite, style: {
+                    width: spriteWidth,
+                    height: spriteHeight,
+                    backgroundImage: imageReady ? `url(${PET_SPRITESHEET_URL})` : undefined,
+                    backgroundSize: `${FRAME_WIDTH * FRAME_COLUMNS * spriteScale}px ${FRAME_HEIGHT * 9 * spriteScale}px`,
+                    backgroundRepeat: 'no-repeat',
+                    backgroundPosition: '0 0',
+                    cursor: dragRef.current === null ? 'grab' : 'grabbing',
+                }, onPointerDown: onPointerDown, onPointerMove: onPointerMove, onPointerUp: onPointerUp, onClick: () => {
+                    // A pointer sequence that moved (dragged) still fires a trailing
+                    // click; skip the pet when that happened.
+                    if (draggedRef.current)
+                        return;
+                    props.onPet();
+                }, role: "button", "aria-label": "whale girl" }), feedback !== null && (_jsx("div", { className: `${styles.bubble} ${feedback.kind === 'feed' ? styles.bubbleFeed : styles.bubblePet}`, children: feedback.text }, feedback.at)), hovered && dragRef.current === null && (_jsx("div", { className: styles.panel, children: renaming ? (_jsxs("div", { className: styles.renameRow, children: [_jsx("input", { className: styles.nameInput, value: nameDraft, maxLength: 20, placeholder: props.t('pet.namePlaceholder'), autoFocus: true, onChange: (e) => setNameDraft(e.target.value), onKeyDown: (e) => {
+                                if (e.key === 'Enter') {
+                                    const trimmed = nameDraft.trim();
+                                    if (trimmed !== '') {
+                                        props.onRename(trimmed);
+                                        setRenaming(false);
+                                    }
+                                }
+                                else if (e.key === 'Escape') {
+                                    setRenaming(false);
+                                }
+                            } }), _jsx("button", { type: "button", className: styles.action, onClick: () => {
+                                const trimmed = nameDraft.trim();
+                                if (trimmed !== '') {
+                                    props.onRename(trimmed);
+                                    setRenaming(false);
+                                }
+                            }, children: props.t('pet.confirm') })] })) : (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.rankRow, children: [_jsx("span", { className: styles.nameCell, children: snapshot?.name ?? '鲸鱼娘' }), _jsx("span", { children: props.t('pet.rank', { rank: snapshot?.affinity.rank ?? '?' }) })] }), _jsxs("div", { className: styles.rankRow, children: [_jsx("span", { children: props.t('pet.treats', { n: snapshot?.treats.stocked ?? 0 }) }), _jsx("span", { children: props.t('pet.points', { points: snapshot?.affinity.points ?? 0 }) })] }), _jsxs("div", { className: styles.actions, children: [_jsx("button", { type: "button", className: styles.action, onClick: props.onFeed, children: props.t('pet.feed') }), _jsx("button", { type: "button", className: styles.action, onClick: () => {
+                                        setNameDraft(snapshot?.name ?? '');
+                                        setRenaming(true);
+                                    }, children: props.t('pet.rename') }), _jsx("button", { type: "button", className: styles.action, onClick: props.onHide, children: props.t('pet.hide') })] })] })) }))] }));
+    return createPortal(float, document.body);
+}

package/lib/types/client/index.js

@@ -0,0 +1,206 @@
+/**
+ * dsh-pet browser half — registers the whale-girl into the conversation
+ * input selector row (the same every-phase row the git branch chip uses) and
+ * drives it from the host's same-origin `/api/pet/*` JSON endpoints: poll the
+ * host snapshot (~800 ms), forward interactions, persist drag positions. The
+ * row anchor mounts the floating pet via portal; when the pet is hidden the
+ * anchor becomes the summon button. Anchoring in the selector row (rather
+ * than the session-only composer dock band) keeps the pet floating on the
+ * new-conversation screen too, where no session exists to scope a slot by.
+ * @module @linxin666/dsh-pet/client
+ */
+import { createPetStore } from "./pet-store.js";
+import { PetDockEntry } from "./PetDockEntry.js";
+import { PetSettingsCard, PetSettingsCardController } from "./PetSettingsCard.js";
+import { NS, en, zh } from "./locales.js";
+/** Same-origin JSON fetch helper (GET without body, POST with JSON body). */
+async function petFetch(path, body) {
+    const response = await fetch(path, body === undefined
+        ? {}
+        : {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+    if (!response.ok) {
+        throw new Error(`pet ${path} failed: ${response.status}`);
+    }
+    return (await response.json());
+}
+/** The live host API instance (always defined; failures surface per call). */
+const petApi = {
+    state: () => petFetch('/api/pet/state'),
+    interact: (kind) => petFetch('/api/pet/interact', { kind }),
+    setVisible: (visible) => petFetch('/api/pet/set-visible', { visible }),
+    setConfig: (patch) => petFetch('/api/pet/set-config', patch),
+    setName: (name) => petFetch('/api/pet/set-name', { name }),
+};
+/** Poll interval for the host snapshot. */
+const POLL_MS = 800;
+/** Settings namespace the pet settings card edits (the Host plugin registers it). */
+const PET_SETTINGS_NS = 'pet';
+/** Required services. */
+export const inject = ['slots', 'locale', 'connection', 'settingsScope', 'remote'];
+/**
+ * Client plugin body: register dictionaries, mount the dock entry and poll
+ * loop while the plugin is enabled, and seat the settings card in the Web UI
+ * plugin group.
+ * @param ctx - client root context.
+ */
+export function apply(ctx) {
+    ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'pet: dictionaries');
+    const settingsScope = ctx.settingsScope.bind({ namespace: PET_SETTINGS_NS });
+    const enabled = () => {
+        const snapshot = settingsScope.getSnapshot();
+        return snapshot.status === 'ready'
+            ? snapshot.value?.enabled ?? true
+            : snapshot.status === 'unavailable';
+    };
+    // Plugin configuration card: one staged form over the `pet` settings
+    // namespace, contributed to the Web UI plugin group.
+    const petSettings = new PetSettingsCardController(settingsScope);
+    ctx.slots.inject('web-ui.plugin.item', () => ctx.slots.register({
+        name: 'web-ui.plugin.item',
+        id: 'pet-settings',
+        order: 140,
+        locale: NS,
+        inject: () => petSettings.inject(),
+    }, PetSettingsCard));
+    // The dock entry, its store, and the poll loop live while the plugin is
+    // enabled; toggling the setting off hides the pet and stops polling.
+    let disposeUi;
+    const syncUi = () => {
+        if (enabled() && disposeUi === undefined) {
+            // ONE store instance for the whole app, owned by this apply body. The
+            // pet is host-global (state/display/interactions are /api/pet/*
+            // endpoints with no session dimension), so the slot system's per-session
+            // store scoping would only reset the pet on session switches and leave
+            // it stateless on the new-conversation screen (no session to scope by).
+            const petStore = createPetStore().create();
+            const setSnapshot = petStore.actions.setSnapshot;
+            const setState = petStore.actions.setState;
+            const setFeedback = petStore.actions.setFeedback;
+            const pollNow = () => {
+                petApi.state().then((snapshot) => {
+                    setSnapshot(snapshot);
+                }, () => {
+                    setState('error', 'pet.state transport error');
+                });
+            };
+            const disposePoll = ctx.effect(() => {
+                // Poll only while the tab is visible: the host snapshot does not
+                // change while the page is hidden, so a background interval would
+                // only burn RPCs (browser throttling is an unreliable backstop).
+                // Coming back to the tab refreshes the pet immediately instead of
+                // waiting out the next 800 ms cycle.
+                let timer;
+                const stop = () => {
+                    if (timer !== undefined) {
+                        window.clearInterval(timer);
+                        timer = undefined;
+                    }
+                };
+                const start = () => {
+                    if (timer === undefined && document.visibilityState === 'visible') {
+                        timer = window.setInterval(pollNow, POLL_MS);
+                    }
+                };
+                const onVisibility = () => {
+                    if (document.visibilityState === 'visible') {
+                        pollNow();
+                        start();
+                    }
+                    else {
+                        stop();
+                    }
+                };
+                start();
+                document.addEventListener('visibilitychange', onVisibility);
+                return () => {
+                    stop();
+                    document.removeEventListener('visibilitychange', onVisibility);
+                };
+            }, 'pet: poll');
+            const injected = () => ({
+                store: petStore,
+                ensure: pollNow,
+                pet: () => {
+                    petApi.interact('pet').then((result) => {
+                        setFeedback({
+                            text: result.reaction,
+                            kind: 'pet',
+                            at: Date.now(),
+                        });
+                    }, () => {
+                        // Ignore transport errors on interactions; the next poll resyncs.
+                    });
+                },
+                feed: () => {
+                    petApi.interact('feed').then((result) => {
+                        setFeedback({
+                            text: result.reaction,
+                            kind: 'feed',
+                            at: Date.now(),
+                        });
+                    }, () => {
+                        // Ignore transport errors on interactions; the next poll resyncs.
+                    });
+                },
+                hide: () => {
+                    petApi.setVisible(false).then(() => {
+                        pollNow();
+                    }, () => {
+                        // Ignore; next poll resyncs.
+                    });
+                },
+                summon: () => {
+                    petApi.setVisible(true).then(() => {
+                        pollNow();
+                    }, () => {
+                        // Ignore; next poll resyncs.
+                    });
+                },
+                dragEnd: (right, bottom) => {
+                    petApi.setConfig({ right, bottom }).then(() => {
+                        pollNow();
+                    }, () => {
+                        // Ignore; next poll resyncs.
+                    });
+                },
+                rename: (name) => {
+                    petApi.setName(name).then((result) => {
+                        if (result.ok)
+                            pollNow();
+                    }, () => {
+                        // Ignore; next poll resyncs.
+                    });
+                },
+                feedbackDone: () => {
+                    setFeedback(null);
+                },
+            });
+            // The input selector row mounts in EVERY conversation phase (cold
+            // start, blank-session hero, active seat) — the composer dock band
+            // only renders for an active session, which is why the pet used to
+            // vanish on the new-conversation screen.
+            const disposeDock = ctx.slots.inject('conversation.input.selector.context', () => ctx.slots.register({
+                name: 'conversation.input.selector.context',
+                id: 'pet',
+                order: 110,
+                inject: injected,
+                locale: NS,
+            }, PetDockEntry));
+            disposeUi = () => {
+                disposeDock();
+                disposePoll();
+                disposeUi = undefined;
+            };
+        }
+        else if (!enabled() && disposeUi !== undefined) {
+            disposeUi();
+            disposeUi = undefined;
+        }
+    };
+    settingsScope.subscribe(syncUi);
+    syncUi();
+}

package/lib/types/client/locales.js

@@ -0,0 +1,92 @@
+/**
+ * dsh-pet locale dictionaries (zh/en).
+ * @module @linxin666/dsh-pet/client/locales
+ */
+/** Dictionary namespace this package registers. */
+export const NS = 'pet';
+/** Chinese copy. */
+export const zh = {
+    'pet.feed': '喂食',
+    'pet.hide': '隐藏',
+    'pet.rename': '改名',
+    'pet.confirm': '确定',
+    'pet.namePlaceholder': '输入新名字',
+    'pet.summon': '召唤{name}',
+    'pet.rank': '亲密度 {rank}',
+    'pet.points': '{points} 点',
+    'pet.treats': '小鱼干 ×{n}',
+    'pet.state.loading': '鲸鱼娘正在赶来…',
+    'pet.state.error': '鲸鱼娘迷路了（连接失败）',
+    // 插件设置卡片（settings.plugin.item 席位）。
+    'settings.title': '宠物',
+    'settings.description': '鲸鱼娘的显示布局与名字。',
+    'settings.enabled': '启用宠物',
+    'settings.enabledHint': '关闭后隐藏宠物并停止轮询，可在设置里重新启用。',
+    'settings.visible': '显示宠物',
+    'settings.visibleHint': '关闭后宠物隐藏，可从聊天输入区重新召唤。',
+    'settings.size': '大小（px）',
+    'settings.sizeHint': '精灵单元高度，范围 32–512。',
+    'settings.right': '距右侧（px）',
+    'settings.rightHint': '距视口右边缘的水平内缩距离。',
+    'settings.bottom': '距底部（px）',
+    'settings.bottomHint': '距视口底边的垂直内缩距离。',
+    'settings.name': '名字',
+    'settings.nameHint': '宠物显示名，1–20 个字符。',
+    'settings.inherit': '继承',
+    'settings.on': '开',
+    'settings.off': '关',
+    'settings.overridden': '已覆盖',
+    'settings.reset': '恢复默认',
+    'settings.readOnly': '当前部署的设置只读。',
+    'settings.expand': '展开设置',
+    'settings.collapse': '收起设置',
+    'settings.save': '保存',
+    'settings.saving': '保存中…',
+    'settings.discard': '放弃',
+    'settings.unsaved': '未保存',
+    'settings.saveFailed': '部署未接受这些值，已保留供你修改。',
+    'settings.invalidNumber': '请输入数字，留空则使用默认值。',
+};
+/** English copy. */
+export const en = {
+    'pet.feed': 'Feed',
+    'pet.hide': 'Hide',
+    'pet.rename': 'Rename',
+    'pet.confirm': 'OK',
+    'pet.namePlaceholder': 'Enter a new name',
+    'pet.summon': 'Summon {name}',
+    'pet.rank': 'Affinity {rank}',
+    'pet.points': '{points} pts',
+    'pet.treats': 'Treats ×{n}',
+    'pet.state.loading': 'The whale girl is on her way…',
+    'pet.state.error': 'The whale girl is lost (connection failed)',
+    // Plugin settings card (the `settings.plugin.item` seat).
+    'settings.title': 'Pet',
+    'settings.description': 'The whale girl\u2019s display layout and name.',
+    'settings.enabled': 'Enable the pet',
+    'settings.enabledHint': 'When off, the pet hides and polling stops; re-enable it here.',
+    'settings.visible': 'Show the pet',
+    'settings.visibleHint': 'When off, the pet hides; summon it again from the input row.',
+    'settings.size': 'Size (px)',
+    'settings.sizeHint': 'Sprite cell height, 32\u2013512.',
+    'settings.right': 'Right inset (px)',
+    'settings.rightHint': 'Horizontal inset from the viewport right edge.',
+    'settings.bottom': 'Bottom inset (px)',
+    'settings.bottomHint': 'Vertical inset from the viewport bottom edge.',
+    'settings.name': 'Name',
+    'settings.nameHint': 'The pet\u2019s display name, 1\u201320 characters.',
+    'settings.inherit': 'Inherit',
+    'settings.on': 'On',
+    'settings.off': 'Off',
+    'settings.overridden': 'Overridden',
+    'settings.reset': 'Reset to default',
+    'settings.readOnly': 'This deployment stores settings read-only.',
+    'settings.expand': 'Show settings',
+    'settings.collapse': 'Hide settings',
+    'settings.save': 'Save',
+    'settings.saving': 'Saving\u2026',
+    'settings.discard': 'Discard',
+    'settings.unsaved': 'Unsaved',
+    'settings.saveFailed': 'The deployment did not accept these values; they were left for you to correct.',
+    'settings.invalidNumber': 'Enter a number, or leave blank to use the default.',
+};

package/lib/types/client/pet-store.js

@@ -0,0 +1,33 @@
+/**
+ * Browser-side pet store: the pet state snapshot plus transient UI feedback
+ * (reaction bubbles), written only through the store's audit actions. The
+ * RPC polling and interactions live in the plugin apply body; components
+ * only ever read snapshots.
+ * @module @linxin666/dsh-pet/client/pet-store
+ */
+import { defineStore } from '@deepseek-ai/dsh-client-runtime/client';
+/** Create the pet store handle (apply world only; never module-level). */
+export function createPetStore() {
+    return defineStore({
+        init: () => ({
+            snapshot: null,
+            state: 'loading',
+            error: null,
+            feedback: null,
+        }),
+        actions: {
+            setSnapshot: (draft, snapshot) => {
+                draft.snapshot = snapshot;
+                draft.state = 'ready';
+                draft.error = null;
+            },
+            setState: (draft, state, error) => {
+                draft.state = state;
+                draft.error = error;
+            },
+            setFeedback: (draft, feedback) => {
+                draft.feedback = feedback;
+            },
+        },
+    });
+}