lilgotchi 0.0.0-stage → 3.0.2

package/dist/pets/wellbeing.js

@@ -0,0 +1,73 @@
+const hour = 3600000;
+const clamp = value => Math.max(0, Math.min(100, value));
+
+// Additive companion metrics. Original P1 care and evolution rules stay separate.
+export function initializeWellbeing(state, now) {
+  if (!Number.isFinite(state.energy)) state.energy = 100;
+  if (!Number.isFinite(state.health)) state.health = state.isSick ? 60 : 100;
+  if (!Number.isFinite(state.wellbeingUpdatedAt)) state.wellbeingUpdatedAt = now;
+  if (!Number.isFinite(state.careTotal)) state.careTotal = 0;
+  if (!Number.isFinite(state.careDuration)) state.careDuration = 0;
+  if (!['auto', 'sleep', 'wake'].includes(state.sleepOverride)) state.sleepOverride = 'auto';
+  if (!Number.isFinite(state.sleepOverrideUntil)) state.sleepOverrideUntil = 0;
+  return state;
+}
+
+export function advanceWellbeing(state, now) {
+  initializeWellbeing(state, now);
+  if (now <= state.wellbeingUpdatedAt) return state;
+  const elapsed = Math.min(now - state.wellbeingUpdatedAt, 25 * 24 * hour);
+  state.wellbeingUpdatedAt = now;
+  if (state.isDead || state.stage === 'egg') return state;
+  const hours = elapsed / hour;
+  const beforeEnergy = state.energy, beforeHealth = state.health;
+  state.energy = clamp(state.energy + hours * (state.isSleeping ? 20 : -5));
+  const neglected = state.hunger === 0 || state.happiness === 0 || state.poopCount >= 3;
+  state.health = clamp(state.health + hours * (state.isSick ? -8 : neglected ? -4 : 4));
+  const score = (state.hunger * 25 + state.happiness * 25 + (beforeEnergy + state.energy) / 2 + (beforeHealth + state.health) / 2) / 4;
+  state.careTotal += score * elapsed;
+  state.careDuration += elapsed;
+  return state;
+}
+
+export function applyWellbeingAction(state, action, now) {
+  advanceWellbeing(state, now);
+  if (state.isDead || state.stage === 'egg') return;
+  if (action === 'play') state.energy = clamp(state.energy - 5);
+  if (action === 'meal') state.energy = clamp(state.energy + 2);
+  if (action === 'cured') state.health = clamp(state.health + 10);
+}
+
+export function setManualSleep(state, sleeping, now) {
+  advanceWellbeing(state, now);
+  if (state.isDead || state.stage === 'egg') return false;
+  state.sleepOverride = sleeping ? 'sleep' : 'wake';
+  state.sleepOverrideUntil = now + 2 * hour;
+  state.isSleeping = sleeping;
+  state.lightOn = !sleeping;
+  if (!sleeping) {
+    state.lastHungerDecay = now;
+    state.lastHappyDecay = now;
+    state.lastPoopTime = now;
+  }
+  return true;
+}
+
+export function sleepDecision(state, scheduled, now) {
+  initializeWellbeing(state, now);
+  const sleptLongEnough = now >= state.sleepOverrideUntil - 2 * hour + 300000;
+  if (state.sleepOverride === 'sleep' && state.energy >= 100 && sleptLongEnough) {
+    state.sleepOverride = 'wake';
+    state.sleepOverrideUntil = now + 2 * hour;
+  }
+  if (now >= state.sleepOverrideUntil) state.sleepOverride = 'auto';
+  if (state.sleepOverride === 'sleep') return true;
+  if (state.sleepOverride === 'wake') return false;
+  return scheduled;
+}
+
+export function careGrade(state) {
+  if (!state.careDuration || state.careDuration < 600000) return { label: 'Getting started', score: null };
+  const score = clamp(state.careTotal / state.careDuration);
+  return { label: score >= 90 ? 'Perfect' : score >= 75 ? 'Good' : score >= 50 ? 'Normal' : 'Bad', score: Math.round(score) };
+}

package/dist/reference/source.json

@@ -0,0 +1,8 @@
+{
+  "repository": "https://github.com/plateaukao/tamagochi",
+  "commit": "74c7a45c8ef03ac43a500db18d19b8fa7cd4ec62",
+  "file": "upstream.html",
+  "sha256": "41352311394443d519155b13c44e5d1103c9b61cc647b028b43277069d4cf650",
+  "license": "MIT as declared in upstream README",
+  "note": "Exact local source copy used for the existing adaptation. Original bytes retained."
+}

package/dist/version.json

@@ -0,0 +1,5 @@
+{
+  "name": "lilgotchi",
+  "version": "3.0.2",
+  "schema": 1
+}

package/dist/widget/care-guide.js

@@ -0,0 +1,50 @@
+const steps=Object.freeze([
+  {title:'Meet your pet', paragraphs:[
+    'Feed offers meals for food and snacks for happiness. Too many snacks can make your pet sick. Play a guessing game to lift its mood.',
+    'Care changes with the moment. Clean waste first, or use it to sleep and wake. More care keeps medicine, discipline and the other controls within reach.'
+  ]},
+  {title:'Read the little signals', paragraphs:[
+    'Food and happiness show how satisfied your pet is. Energy drops while awake and recovers during sleep. Health is an advisory wellbeing meter. It does not replace the illness icon, medicine or the original care rules.',
+    'A care grade appears after ten minutes of measured care. It averages food, happiness, energy and health over time: Perfect is at least 90, Good is at least 75, Normal is at least 50, and Bad is below 50. It describes that average, not your pet’s worth. The original evolution branches still use care mistakes and discipline.'
+  ]},
+  {title:'Rest and grow', paragraphs:[
+    'Sleep and Wake control rest for a limited period before the normal schedule resumes. Lights only change the display and bedtime lighting. Turning a light off is not the same as asking an awake pet to sleep.',
+    'Use medicine when your pet is sick. Use discipline when it is misbehaving, rather than whenever it refuses something. Eggs need time to hatch. Later stages grow through care. A named starting character begins a fresh life at the stage shown, so an adult can be zero days old.'
+  ]},
+  {title:'Come back when you can', paragraphs:[
+    'While you are away, progress catches up for up to eight hours. Vacation pauses care and growth when you need a longer break. The launcher counts care needs across your started pets while this page is active. Open the needs list to see who needs what. A pet active elsewhere may show its last saved needs. Closing the drawer keeps the pet active. Close the browser tab or page to release it for another window.',
+    'Your pet saves in this browser on this website. Use Export save in Settings for a backup or to move it elsewhere. Import previews a replacement first. Clearing browser data can remove progress. If storage is unavailable, progress may last only for this visit.'
+  ]}
+]);
+
+// All guide copy is rendered as text, never supplied as HTML.
+export function mountCareGuide(container){
+  const document=container.ownerDocument;
+  const details=document.createElement('details');details.className='care-guide';
+  const summary=document.createElement('summary');summary.textContent='How to care for your pet';
+  const content=document.createElement('div');content.className='care-guide-content';
+  const progress=document.createElement('p');progress.className='care-guide-progress';progress.setAttribute('aria-live','polite');
+  const title=document.createElement('h3');title.tabIndex=-1;
+  const paragraphs=document.createElement('div');
+  const controls=document.createElement('div');controls.className='care-guide-controls';
+  const back=document.createElement('button');back.type='button';back.textContent='Back';
+  const next=document.createElement('button');next.type='button';
+  const replay=document.createElement('button');replay.type='button';replay.textContent='Start again';
+  let index=0;
+  const render=(focus=false)=>{
+    progress.textContent=`Step ${index+1} of ${steps.length}`;
+    title.textContent=steps[index].title;
+    paragraphs.replaceChildren(...steps[index].paragraphs.map(text=>{const p=document.createElement('p');p.textContent=text;return p;}));
+    back.disabled=index===0;next.textContent=index===steps.length-1?'Done':'Next';replay.hidden=index!==steps.length-1;
+    if(focus)title.focus();
+  };
+  back.addEventListener('click',()=>{if(index>0){index--;render(true);}});
+  next.addEventListener('click',()=>{
+    if(index===steps.length-1){details.open=false;summary.focus();}
+    else{index++;render(true);}
+  });
+  replay.addEventListener('click',()=>{index=0;render(true);});
+  controls.append(back,next,replay);content.append(progress,title,paragraphs,controls);details.append(summary,content);container.append(details);render();
+  return {element:details,reset(){index=0;render();},destroy(){details.remove();}};
+}
+

package/dist/widget/care-monitor.js

@@ -0,0 +1,52 @@
+import { inactiveSince } from './inactive.js';
+import { PetSimulation } from '../pets/simulation.js';
+
+export function careNeeds(state, memorialSeen) {
+  if (!state || state.vacationAt > 0) return [];
+  if (state.isDead) return String(state.bornAt) === memorialSeen ? [] : ['Remember your pet'];
+  if (state.stage === 'egg') return [];
+  return [state.hunger === 0 && 'Food', state.happiness === 0 && 'Play',
+    state.isSick && 'Medicine', state.poopCount > 0 && 'Cleaning',
+    state.isMisbehaving && 'Discipline'].filter(Boolean);
+}
+
+// Run the same absence simulation as the game, without mounting its UI or saving
+// through standalone storage. The caller holds the family's save ownership.
+export function advanceSavedPet(saved) {
+  const app = Object.create(PetSimulation.prototype);
+  app.state = structuredClone(saved);
+  Object.defineProperty(app.state, 'save', { value() {} });
+  app.sound = new Proxy({}, { get: () => () => {} });
+  app.toast = app.updateButtons = app.showDeath = app.cancelGame = () => {};
+  app.processMissedTime();
+  return JSON.parse(JSON.stringify(app.state));
+}
+
+export async function refreshCare(store, families, activeFamily, advance = advanceSavedPet) {
+  const entries = [];
+  for (const family of families) {
+    let acquired = false;
+    try {
+      // Never reload an active writer's revision or simulate its state twice.
+      if (family === activeFamily || inactiveSince(store,family)) continue;
+      const raw = store.raw(family);
+      if (!raw) continue;
+      const recent=JSON.parse(raw)?.state;
+      if(recent && (Date.now()-recent.lastProcessed<60000 || recent.vacationAt>0 || recent.isDead)){
+        const saved=store.load(family);
+        entries.push({family,state:saved.state,stale:false});continue;
+      }
+      acquired = await store.acquire(family);
+      const saved = store.load(family);
+      if (!saved) continue;
+      let state = saved.state;
+      if (acquired) { state = advance(state); store.save(family, state); }
+      entries.push({ family, state, stale: !acquired });
+    } catch {
+      // Keep the previous count if storage is unavailable or a save needs recovery.
+    } finally {
+      if (acquired) store.release(family);
+    }
+  }
+  return entries;
+}

package/dist/widget/color-controls.js

@@ -0,0 +1,15 @@
+import {cleanColors,resolvedColors} from '../pets/colors.js';
+export function mountColorControls(container,onChange){
+  const doc=container.ownerDocument,fields={};
+  const title=doc.createElement('strong');title.textContent='Pet colors';
+  const hint=doc.createElement('p');hint.textContent='Choose colors for this family.';
+  container.append(title,hint);
+  for(const [key,label] of [['shell','Handheld color'],['screen','Screen color']]){
+    const row=doc.createElement('label');row.className='color-choice';row.textContent=label;
+    const input=doc.createElement('input');input.type='color';input.setAttribute('aria-label',label);
+    input.addEventListener('input',()=>onChange(cleanColors({shell:fields.shell.value,screen:fields.screen.value})));
+    fields[key]=input;row.append(input);container.append(row);
+  }
+  const reset=doc.createElement('button');reset.type='button';reset.textContent='Return to default colors';reset.addEventListener('click',()=>onChange({}));container.append(reset);
+  return {update(family,colors){const resolved=resolvedColors(family,colors);for(const key of Object.keys(fields))fields[key].value=resolved[key];}};
+}

package/dist/widget/configurator.js

@@ -0,0 +1,24 @@
+import { catalog } from '../pets/catalog.js';
+import { installSnippet } from './install-snippet.js?v=3.0.2';
+const form=document.querySelector('#setup');
+const list=form.querySelector('.character-options');
+for(const choice of catalog){
+  const label=document.createElement('label');
+  const input=document.createElement('input');input.type='checkbox';input.value=choice.id;input.checked=true;
+  label.append(input,document.createTextNode(choice.name));list.append(label);
+}
+const first=form.querySelector('[name=first]'),code=form.querySelector('code'),copy=form.querySelector('.copy'),status=form.querySelector('.copy-status');
+function update(){
+  const all=form.querySelector('[name=roster]').value==='all';list.hidden=all;
+  const chosen=all?catalog:catalog.filter(choice=>list.querySelector(`input[value="${choice.id}"]`).checked);
+  const previous=first.value||'slice';first.replaceChildren(...chosen.map(choice=>new Option(choice.name,choice.id)));
+  first.value=chosen.some(c=>c.id===previous)?previous:chosen[0]?.id||'';
+  try{code.textContent=installSnippet({characters:all?'all':chosen.map(c=>c.id).join(','),character:first.value,placement:form.elements.placement.value,appearance:form.elements.appearance.value,launcher:form.elements.launcher.value,notifications:form.elements.notifications.value});copy.disabled=false;status.textContent='';}
+  catch{code.textContent='Choose at least one character.';copy.disabled=true;status.textContent='Choose at least one character to make your snippet.';}
+}
+form.addEventListener('change',update);
+copy.addEventListener('click',async()=>{
+  try{await navigator.clipboard.writeText(code.textContent);status.textContent='Copied. Paste this into your page. No upload needed.';}
+  catch{status.textContent='Copy is unavailable here. Select the code above and copy it manually.';}
+});
+update();

package/dist/widget/egg.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 28" shape-rendering="crispEdges"><path fill="#e7c88d" d="M9 1h6v2h3v3h2v4h2v10h-2v4h-4v2H8v-2H4v-4H2V10h2V6h2V3h3z"/><path fill="#fff0cc" d="M9 3h5v2h3v4h2v10h-2v4H8v-2H5V10h2V6h2z"/><path fill="#6c8060" d="M7 12h3v3H7zm7 0h3v3h-3zm-4 6h4v2h-4z"/></svg>

package/dist/widget/focus.js

@@ -0,0 +1,6 @@
+// Closed details can report layout rectangles for controls they do not display.
+export function visibleControl(node) {
+  if(node.disabled || !node.getClientRects().length)return false;
+  const closed=node.closest('details:not([open])');
+  return !closed || (node.tagName==='SUMMARY' && node.parentElement===closed);
+}

package/dist/widget/gallery.js

@@ -0,0 +1,17 @@
+import { catalog } from '../pets/catalog.js';
+import { launcherArt } from './launcher.js';
+const gallery=document.querySelector('.gallery');
+const open=async id=>{
+  const pet=document.querySelector('lil-gotchi');
+  await pet.setCharacter(id);
+  await pet.open();
+};
+for(const choice of catalog){
+  const button=document.createElement('button');
+  button.type='button';
+  button.innerHTML=`${launcherArt(choice.id,{character:choice.id==='original2'?'mimitchi':choice.id==='default'?'kuchipatchi':choice.id==='cyberpunk'?'ginjirotchi':'mametchi'},{fit:true})}<strong>${choice.name}</strong><span>${choice.id==='slice'?'Starts as dough':choice.id==='cyberpunk'?'Starts as a binary seed':'Starts as an egg'}</span>`;
+  button.addEventListener('click',async()=>{
+    await open(choice.id);
+  });
+  gallery.append(button);
+}

package/dist/widget/inactive.js

@@ -0,0 +1,24 @@
+import { shiftClocks } from '../pets/away.js';
+
+export function inactiveSince(store,family) {
+  const value=Number(store.preference(`inactive-${family}`));
+  return Number.isFinite(value)&&value>0?value:0;
+}
+
+export function hasActivePets(store,families,states=new Map()) {
+  return families.some(family=>{
+    if(inactiveSince(store,family))return false;
+    if(states.get(family)?.state)return true;
+    try{return !!store.load(family)?.state;}
+    catch{return false;}
+  });
+}
+
+export function resumeInactive(state,since,now=Date.now()) {
+  const next=structuredClone(state);
+  const elapsed=now-since;
+  shiftClocks(next,elapsed);
+  // A pet already on vacation stays on vacation, without counting this pause twice.
+  if(next.vacationAt>0)next.vacationAt=Math.max(1,next.vacationAt+elapsed);
+  return next;
+}

package/dist/widget/install-snippet.js

@@ -0,0 +1,14 @@
+import { cleanColorMap } from '../pets/colors.js';
+import { allowedCharacters } from '../pets/catalog.js';
+export function installSnippet({characters='all',character='slice',placement='bottom-right',appearance='dark',launcher='shell',notifications='on',colors={}}={}){
+  const allowed=allowedCharacters(characters);
+  if(!allowed.includes(character))character=allowed[0];
+  if(!['bottom-right','bottom-left','top-right','top-left'].includes(placement))throw new Error('Choose a supported placement.');
+  if(!['dark','light'].includes(appearance))throw new Error('Choose a supported appearance.');
+  if(!['shell','pet','brand'].includes(launcher))throw new Error('Choose a supported launcher.');
+  if(!['on','off'].includes(notifications))throw new Error('Choose notifications on or off.');
+  const colorMap=cleanColorMap(colors);
+  const colorSetting=Object.keys(colorMap).length?" data-colors='"+JSON.stringify(colorMap)+"'":'';
+  const setting=` data-placement="${placement}"`;
+  return `<script defer src="https://www.taylordorsett.com/lilgotchi/releases/3.0.2/embed.js" data-characters="${characters==='all'?'all':allowed.join(',')}" data-character="${character}"${setting} data-appearance="${appearance}" data-launcher="${launcher}" data-notifications="${notifications}"${colorSetting} data-storage-key="my-pets"></script>`;
+}

package/dist/widget/launcher.js

@@ -0,0 +1,63 @@
+import { resolvedColors, cleanColors, shade, screenInk } from '../pets/colors.js';
+import { getCharacter } from '../pets/catalog.js';
+import { sliceSprites, slicePalette } from '../pets/slice-sprites.js';
+import { cyberpunkSprites, cyberpunkPalette } from '../pets/cyberpunk-sprites.js';
+import { classicSprites } from '../pets/classic-sprites.js';
+import { originalSprites } from '../pets/original-sprites.js';
+const originals={...classicSprites,...originalSprites};
+import { lilgotchiSprites, lilgotchiPalette } from '../pets/lilgotchi-sprites.js';
+
+const shellColors={
+  classic:{edge:'#c9a882',face:'#e8d5c4',screen:'#c4cfa1'},
+  eink:{edge:'#d8d8d8',face:'#f5f5f5',screen:'#f0f0f0'},
+  pizza:{edge:'#526f70',face:'#839c98',screen:'#648e97'},
+  cyberpunk:{edge:'#172c36',face:'#304e59',screen:'#0b1c24'},
+  lilgotchi:{edge:'#e7c88d',face:'#fff0cc',screen:'#20281d'},
+};
+
+export function launcherArt(family, state, { fit = false } = {}) {
+  const sprites=family==='lilgotchi'?lilgotchiSprites:family==='slice'?sliceSprites:family==='cyberpunk'?cyberpunkSprites:originals;
+  const palette=family==='lilgotchi'?lilgotchiPalette:family==='slice'?slicePalette:family==='cyberpunk'?cyberpunkPalette:['','#b4ce83'];
+  const preview=family==='slice'||family==='cyberpunk'?'tamatchi':getCharacter(family)?.character||'egg';
+  const identity=state?.character && Object.hasOwn(sprites,state.character)?state.character:preview;
+  const pixels=sprites[identity].idle1;
+  const rects=pixels.flatMap((row,y)=>row.flatMap((color,x)=>color?[`<rect x="${x}" y="${y}" width="1" height="1" fill="${palette[color]||palette[1]}"/>`]:[])).join('');
+  let viewBox=`0 0 ${pixels[0].length} ${pixels.length}`;
+  if(fit){
+    const occupied=pixels.flatMap((row,y)=>row.flatMap((color,x)=>color?[[x,y]]:[]));
+    if(occupied.length){
+      const xs=occupied.map(([x])=>x),ys=occupied.map(([,y])=>y);
+      const left=Math.min(...xs),top=Math.min(...ys);
+      const width=Math.max(...xs)-left+1,height=Math.max(...ys)-top+1;
+      const side=Math.max(width,height)+2;
+      viewBox=`${left-(side-width)/2} ${top-(side-height)/2} ${side} ${side}`;
+    }
+  }
+  return `<svg aria-hidden="true" viewBox="${viewBox}" shape-rendering="crispEdges">${rects}</svg>`;
+}
+export function savedCare(state) {
+  if(!state)return '';
+  if(state.vacationAt>0)return '';
+  if(state.isDead)return 'Your pet passed away';
+  if(state.stage==='egg')return '';
+  const needs=[];
+  if(state.isSick)needs.push('medicine');
+  if(state.poopCount>0)needs.push('cleaning');
+  if(state.hunger===0)needs.push('food');
+  if(state.happiness===0)needs.push('play');
+  if(state.isMisbehaving)needs.push('discipline');
+  return needs.length?`Needs ${needs.join(', ')}`:'';
+}
+export function launcherIcon(family,state,{shell=true,eink=false,colors:custom={}}={}) {
+  if(!shell)return `${launcherArt(family,state,{fit:true})}<span class="launcher-label">lilgotchi</span>`;
+  const skin=getCharacter(family)?.skin||'classic';
+  let colors={...shellColors[skin==='classic'&&eink?'eink':skin]||shellColors.classic};
+  if(!(skin==='classic'&&eink)){
+    const resolved=resolvedColors(family,custom),overrides=cleanColors(custom);
+    if(skin==='classic'||overrides.shell){colors.face=shade(resolved.shell,22);colors.edge=shade(resolved.shell,-24);}
+    if(skin==='classic'||overrides.screen)colors.screen=resolved.screen;
+  }
+  let pet=launcherArt(family,state,{fit:true}).replace('<svg ', '<svg x="5" y="8" width="14" height="14" ');
+  if(skin==='classic')pet=pet.replaceAll('#b4ce83',eink?'#111':screenInk(colors.screen));
+  return `<svg aria-hidden="true" viewBox="0 0 24 28" shape-rendering="crispEdges"><path fill="${colors.edge}" d="M9 1h6v2h3v3h2v4h2v10h-2v4h-4v2H8v-2H4v-4H2V10h2V6h2V3h3z"/><path fill="${colors.face}" d="M9 3h5v2h3v4h2v10h-2v4H8v-2H5V10h2V6h2z"/><path fill="${colors.screen}" d="M6 8h12v14H6z"/>${pet}</svg>`;
+}

package/dist/widget/pet-history.js

@@ -0,0 +1,57 @@
+import { lilgotchiNames } from '../pets/lilgotchi-sprites.js';
+import { characters } from '../pets/valid-state.js';
+import { catalog, families } from '../pets/catalog.js';
+import { validEnvelope } from './save-store.js';
+import { sliceNames } from '../pets/slice-sprites.js';
+import { cyberpunkNames } from '../pets/cyberpunk-sprites.js';
+
+export const HISTORY_LIMIT=12;
+export const historyKey=(instance,family)=>`lilgotchi:history:v1:${encodeURIComponent(instance)}:${family}`;
+const fields=['age','bornAt','character','family','recordedAt'];
+const identities=new Set(characters);
+const time=value=>Number.isSafeInteger(value)&&value>=0;
+export function validHistoryEntry(entry,family){
+  return !!entry && typeof entry==='object' && !Array.isArray(entry) &&
+    Object.keys(entry).sort().join(',')===fields.join(',') &&
+    families.includes(entry.family) && (family===undefined || entry.family===family) &&
+    identities.has(entry.character) && Number.isSafeInteger(entry.age) && entry.age>=0 && entry.age<=1000000 &&
+    time(entry.bornAt) && time(entry.recordedAt) && entry.recordedAt>=entry.bornAt;
+}
+const newest=(a,b)=>b.recordedAt-a.recordedAt || b.bornAt-a.bornAt || a.family.localeCompare(b.family);
+export class PetHistory {
+  constructor(store){this.store=store;}
+  list(family){
+    if(family!==undefined && !families.includes(family))throw new Error('Unknown history character.');
+    const entries=[];
+    for(const id of family===undefined?families:[family]){
+      const raw=this.store.read(historyKey(this.store.instance,id));
+      if(raw===null)continue;
+      let data;
+      try{if(raw.length>16384)throw new Error();data=JSON.parse(raw);}catch{throw new Error('Pet history needs recovery. It has not been replaced.');}
+      if(!data || data.schema!==1 || data.instance!==this.store.instance || data.family!==id || !Array.isArray(data.entries) ||
+        data.entries.length>HISTORY_LIMIT || !data.entries.every(entry=>validHistoryEntry(entry,id)) ||
+        new Set(data.entries.map(entry=>entry.bornAt)).size!==data.entries.length)throw new Error('Pet history needs recovery. It has not been replaced.');
+      entries.push(...data.entries);
+    }
+    return entries.sort(newest);
+  }
+  recordDeath(family,state){
+    const now=this.store.now();
+    if(!families.includes(family) || !time(now) || !validEnvelope({schema:1,instance:this.store.instance,family,revision:1,savedAt:now,state}) || !time(state.bornAt) || state.bornAt>now)throw new Error('Invalid pet history.');
+    if(!this.store.owns(family))throw new Error('This pet is active in another window.');
+    if(!state.isDead)return false;
+    const entries=this.list(family);
+    if(entries.some(entry=>entry.bornAt===state.bornAt))return false;
+    const entry={family,character:state.character,bornAt:state.bornAt,age:state.age,recordedAt:now};
+    if(!validHistoryEntry(entry,family))throw new Error('Invalid pet history.');
+    entries.push(entry);entries.sort(newest);entries.length=Math.min(entries.length,HISTORY_LIMIT);
+    this.store.write(historyKey(this.store.instance,family),JSON.stringify({schema:1,instance:this.store.instance,family,entries}));
+    return true;
+  }
+  describe(entry){
+    if(!validHistoryEntry(entry))throw new Error('Invalid pet history.');
+    const choice=catalog.find(choice=>choice.id===entry.family);
+    const identity=entry.family==='slice'?sliceNames[entry.character]:entry.family==='cyberpunk'?cyberpunkNames[entry.character]:entry.family==='lilgotchi'?lilgotchiNames[entry.character]:entry.character[0].toUpperCase()+entry.character.slice(1);
+    return `${choice.name} · ${identity} · ${entry.age} ${entry.age===1?'day':'days'} old`;
+  }
+}

package/dist/widget/pet-label.js

@@ -0,0 +1,12 @@
+import { lilgotchiNames } from '../pets/lilgotchi-sprites.js';
+import { getCharacter } from '../pets/catalog.js';
+import { sliceNames } from '../pets/slice-sprites.js';
+import { cyberpunkNames } from '../pets/cyberpunk-sprites.js';
+
+export const stageLabel = stage => stage[0].toUpperCase()+stage.slice(1);
+export function petLabel(family,state) {
+  const choice=getCharacter(family);
+  const character=state?.character||choice.character,stage=state?.stage||choice.stage;
+  const name=family==='slice'?sliceNames[character]:family==='cyberpunk'?cyberpunkNames[character]:family==='lilgotchi'?lilgotchiNames[character]:character==='egg'?choice.name:stageLabel(character);
+  return `${name} · ${stageLabel(stage)}${state?.vacationAt?' · Paused':''}`;
+}

package/dist/widget/save-store.js

@@ -0,0 +1,198 @@
+import { validState } from '../pets/valid-state.js';
+import { stagesForFamily } from '../pets/original-roster.js';
+
+import { families, legacyFamily, requireAllowed } from '../pets/catalog.js';
+export { families, legacyFamily } from '../pets/catalog.js';
+const memory = new Map();
+const sessionOnly = new Set();
+const localOwners = new Map();
+const LEASE_MS = 15000;
+export const saveKey = (instance, family) => `lilgotchi:v1:${encodeURIComponent(instance)}:${family}`;
+const clone = value => JSON.parse(JSON.stringify(value));
+
+export function validEnvelope(data, instance, family) {
+  if (!data || data.schema !== 1 || !families.includes(data.family) || typeof data.instance !== 'string') return false;
+  if (instance !== undefined && data.instance !== instance) return false;
+  if (family !== undefined && data.family !== family) return false;
+  if (!Number.isSafeInteger(data.revision) || data.revision < 0 || !Number.isFinite(data.savedAt) || data.savedAt < 0 || !validState(data.state)) return false;
+  const state=data.state;
+  const identities=stagesForFamily(data.family);
+  if(!Object.values(identities).flat().includes(state.character))return false;
+  if(state.stage!=='dead' && !identities[state.stage]?.includes(state.character))return false;
+  if(state.isDead !== (state.stage==='dead') || state.weight>99 || state.age>1000000)return false;
+  for(const key of ['age','weight','careMistakes','snacksInWindow','medDoses','sickCount']) if(!Number.isSafeInteger(state[key]))return false;
+  return [null,...identities.teen].includes(state.prevTeen) && [null,'hungry','sad','misbehave','sick'].includes(state.attentionReason) && (state.attentionCallTime===null || state.attentionCallTime>=0);
+}
+
+export function parseImport(text, allowed=families) {
+  if (typeof text !== 'string' || text.length > 32768) throw new Error('This save file is too large.');
+  let data;
+  try { data = JSON.parse(text); } catch { throw new Error('This is not a valid save file.'); }
+  if (!validEnvelope(data)) throw new Error('This save has unsupported or invalid game data.');
+  requireAllowed(data.family,allowed);
+  if (data.savedAt > Date.now() + 300000) throw new Error('This save is dated in the future.');
+  for(const key of ['bornAt','stageStartTime','lastHungerDecay','lastHappyDecay','lastPoopTime','lastAgeInc','lastProcessed','snackWindowStart','attentionCallTime']) {
+    if(data.state[key]!==null && data.state[key]>Date.now()+300000)throw new Error('This save contains a future game clock.');
+  }
+  return data;
+}
+
+export class SaveStore {
+  constructor(instance = 'default', options = {}) {
+    this.instance = instance;
+    this.owner = options.owner || globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random()}`;
+    this.now = options.now || Date.now;
+    this.locks = options.locks === undefined ? globalThis.navigator?.locks : options.locks;
+    this.persistent = true;
+    this.revisions = new Map();
+    this.releases = new Map();
+    this.lockRequests = new Map();
+    this.pendingReleases = new Map();
+    try { this.storage = options.storage === undefined ? globalThis.localStorage : options.storage; }
+    catch { this.storage = null; }
+    if (!this.storage) this.persistent = false;
+  }
+  read(key) {
+    if(sessionOnly.has(key)){this.persistent=false;return memory.get(key)??null;}
+    if (!this.persistent && memory.has(key)) return memory.get(key);
+    try {
+      if (this.storage) {
+        const raw = this.storage.getItem(key);
+        if (raw !== null) { memory.set(key,raw); return raw; }
+        if (this.persistent) return null;
+      }
+    } catch { this.persistent = false; }
+    return memory.get(key) ?? null;
+  }
+  write(key, value) {
+    memory.set(key,value);
+    try { if (!this.storage) throw new Error(); this.storage.setItem(key,value); }
+    catch { this.persistent = false; sessionOnly.add(key); }
+  }
+  load(family) {
+    const key = saveKey(this.instance,family);
+    const raw = this.read(key);
+    if (raw===null) { this.revisions.set(family,0); return null; }
+    let data;
+    try { data=JSON.parse(raw); } catch { throw new Error('Saved progress is damaged. Export it before starting again.'); }
+    if (!validEnvelope(data,this.instance,family)) throw new Error('Saved progress needs recovery. It has not been replaced.');
+    this.revisions.set(family,data.revision);
+    return clone(data);
+  }
+  migrateLegacy(family) {
+    if (!families.includes(family)) throw new Error('Unknown character');
+    if (!['default','slice','cyberpunk'].includes(family)) return false;
+    if (!this.owns(family)) throw new Error('This pet is active in another window.');
+    const key=saveKey(this.instance,family);
+    // Check durable storage directly. A failed migration must remain retryable.
+    if (this.read(key)!==null) return false;
+    if (!this.storage) return false;
+    let destination;
+    try { destination=this.storage.getItem(key); } catch { this.persistent=false;return false; }
+    if (destination!==null) return false;
+    const source=`taylor-pocket-pets-p1-v1-${legacyFamily[family]}`;
+    const raw=this.storage.getItem(source);
+    if (raw===null) return false;
+    let state;
+    try { state=JSON.parse(raw); } catch { throw new Error('Your old pet needs recovery. Its save has not been changed.'); }
+    const envelope={schema:1,instance:this.instance,family,revision:1,savedAt:this.now(),state};
+    parseImport(JSON.stringify(envelope));
+    const serialized=JSON.stringify(envelope);
+    if (!this.owns(family)) throw new Error('This pet is active in another window.');
+    this.storage.setItem(key,serialized);
+    if (this.storage.getItem(key)!==serialized) throw new Error('Your old pet could not be copied. Try again.');
+    memory.set(key,serialized);
+    sessionOnly.delete(key);
+    this.revisions.set(family,1);
+    // The destination itself prevents repeat copies, even if this receipt fails.
+    try { this.storage.setItem(`${key}:migration`,JSON.stringify({source,completedAt:this.now()})); } catch {}
+    return true;
+  }
+  preference(name, value) {
+    const key=`lilgotchi:preferences:${encodeURIComponent(this.instance)}:${name}`;
+    if (value !== undefined) this.write(key,String(value));
+    return this.read(key);
+  }
+  lease(family) {
+    try { return JSON.parse(this.read(saveKey(this.instance,family)+':lease') || 'null'); } catch { return null; }
+  }
+  async acquire(family) {
+    // Resolving the callback releases ownership locally before the browser has
+    // finished releasing its Web Lock. Wait only for locks we already released.
+    if(this.pendingReleases.has(family))await this.pendingReleases.get(family);
+    const key=saveKey(this.instance,family);
+    if (localOwners.has(key) && localOwners.get(key)!==this.owner && (this.locks || this.lease(family)?.expires>this.now())) return false;
+    if (this.releases.has(family)) return this.owns(family);
+    if (this.locks) {
+      let answer;
+      const acquired=new Promise(resolve=>{answer=resolve;});
+      const request=this.locks.request(key,{ifAvailable:true},async lock=>{
+        if (!lock) { answer(false); return; }
+        localOwners.set(key,this.owner);
+        await new Promise(resolve=>{this.releases.set(family,resolve); answer(true);});
+      }).catch(()=>answer(false));
+      this.lockRequests.set(family,request);
+      request.then(()=>{if(this.lockRequests.get(family)===request)this.lockRequests.delete(family);});
+      return acquired;
+    }
+    const lease=this.lease(family);
+    if (lease && lease.owner!==this.owner && lease.expires>this.now()) return false;
+    localOwners.set(key,this.owner);
+    this.write(key+':lease',JSON.stringify({owner:this.owner,expires:this.now()+LEASE_MS}));
+    this.releases.set(family,()=>{});
+    return this.owns(family);
+  }
+  owns(family) {
+    const key=saveKey(this.instance,family);
+    if (localOwners.get(key)!==this.owner || !this.releases.has(family)) return false;
+    if (this.locks) return true;
+    const lease=this.lease(family);
+    return lease?.owner===this.owner && lease.expires>this.now();
+  }
+  renew(family) {
+    if (!this.owns(family)) return false;
+    if (!this.locks) this.write(saveKey(this.instance,family)+':lease',JSON.stringify({owner:this.owner,expires:this.now()+LEASE_MS}));
+    return true;
+  }
+  save(family,state) {
+    if (!families.includes(family) || !validState(state)) throw new Error('Invalid game state. Progress was not replaced.');
+    if (!this.owns(family)) throw new Error('This pet is active in another window.');
+    const key=saveKey(this.instance,family);
+    const expected=this.revisions.get(family) || 0;
+    const current=this.read(key);
+    if (current!==null) {
+      let data;
+      try { data=JSON.parse(current); } catch { throw new Error('Saved progress needs recovery.'); }
+      if (!validEnvelope(data,this.instance,family) || data.revision!==expected) throw new Error('Newer progress exists. Reopen this pet to continue.');
+    } else if (expected!==0) throw new Error('Progress changed in another window.');
+    const envelope={schema:1,instance:this.instance,family,revision:expected+1,savedAt:this.now(),state:clone(state)};
+    if(!validEnvelope(envelope,this.instance,family))throw new Error('Invalid game state. Progress was not replaced.');
+    this.write(key,JSON.stringify(envelope));
+    this.revisions.set(family,envelope.revision);
+    this.renew(family);
+    return envelope;
+  }
+  replace(family,state) {
+    if(!this.owns(family))throw new Error('This pet is active in another window.');
+    const key=saveKey(this.instance,family);
+    const raw=this.read(key);
+    if(raw!==null)this.write(`${key}:recovery`,raw);
+    const envelope={schema:1,instance:this.instance,family,revision:1,savedAt:this.now(),state:clone(state)};
+    if(!validEnvelope(envelope,this.instance,family))throw new Error('Invalid imported state.');
+    this.write(key,JSON.stringify(envelope));this.revisions.set(family,1);return envelope;
+  }
+  raw(family){return this.read(saveKey(this.instance,family));}
+  release(family) {
+    const key=saveKey(this.instance,family);
+    if (!this.locks && this.lease(family)?.owner===this.owner) this.write(key+':lease',JSON.stringify({owner:this.owner,expires:0}));
+    if(localOwners.get(key)===this.owner) localOwners.delete(key);
+    const request=this.lockRequests.get(family);
+    if(this.releases.has(family) && request){
+      this.pendingReleases.set(family,request);
+      request.then(()=>{if(this.pendingReleases.get(family)===request)this.pendingReleases.delete(family);});
+    }
+    this.releases.get(family)?.();
+    this.releases.delete(family);
+  }
+  dispose() { for(const family of [...this.releases.keys()]) this.release(family); }
+}