@homie-rocks/studio 0.45.3 → 0.46.0

package/CHANGELOG.md

@@ -17,6 +17,64 @@ To bring a studio up to date, tell Claude: "Upgrade my studio to the newest Homi
 `npx -y @homie-rocks/studio@latest upgrade`, which shows what's new since the version your studio pins (from this
 file) and what the upgrade would change, and changes nothing until you agree.
 
+## [0.46.0] - 2026-10-10
+
+**Plugin 0.46.0**
+
+Keep a world and its account characters across restarts.
+
+### Added
+
+- Opt-in lasting single-area worlds: `room.lifetime: "persistent"` retains a room
+  across empty periods, restarts and compatible builds. State fields declared
+  `{ durable: true }` are written the moment they change, as one small journal
+  record committed before that tick is published, exactly once across a crash.
+  The rest of the room is checkpointed every `room.durability.movementSeconds`
+  (30 by default for a lasting world) and on pause or an orderly stop; a restore
+  is the last checkpoint plus the journal, so value is never lost or repeated
+  though positions may rewind a moment. A room where nothing changes writes
+  nothing. Storage failures stop play and retain committed state.
+- Optional `room.characters: true` keeps one character per game on the existing
+  signed-in player account. Rules read `player.character` on join and write its
+  inventory through declared entity fields. A durable lease and return outbox
+  prevent two rooms holding the character at once. Explicit `world.finish()`
+  resets retain the latest account character instead of replaying its old inventory.
+  No manual provisioning.
+
+### Changed
+
+- Only opted-in worlds use a stable public room instead of allocating fresh match
+  copies. Full worlds wait for seats; named room links select other worlds.
+- Lasting worlds default to `offline: false` so practice cannot look like a
+  durable session. An explicit `offline: true` still allows unsaved local practice.
+- Only character games require studio account sign-in before playing and return
+  the character on disconnect/recall instead of leaving it as a bot.
+- `room.durability.movementSeconds` defaults to 30 when `lifetime` is
+  `"persistent"`; it is still 1 for every other room. In a lasting world an
+  undeclared field, a position or an undeclared non-player entity can come back
+  up to that many seconds old after a crash: declare what must not.
+- Only lasting worlds retain incompatible saves instead of
+  resetting and stop on write failure. Their save envelopes do
+  not use the match path's 16 MB cap. Existing simulation and Cloudflare constraints
+  still apply. Ordinary rules games and browser-hosted games keep their APIs,
+  save costs and lifecycle.
+
+### Fixed
+
+- Refund-event SQL triggers no longer try to parse plain-text settings as JSON,
+  which could prevent account room tickets being signed. The automatic
+  `0020_function_meta.sql` migration preserves refund IDs and delivery behavior.
+
+### Upgrade notes
+
+- First milestone-3 slice. Compatible deployments still restart the Worker and
+  reload old views; uninterrupted rule swaps, migrations, durable command retries,
+  atomic trades and restore points remain later slices. Commands should be
+  idempotent; a command lost before commitment has not happened. Queued events are
+  not atomic transfers when a recipient leaves. Existing cloud saves, shop orders
+  and grants, and app records retain their existing behavior.
+- Version 0.46.0 is provisional. No deploy or merge is part of this PR.
+
 ## [0.45.3] - 2026-10-10
 
 **Plugin 0.45.3**

package/guides/game/RULES.md

@@ -137,6 +137,58 @@ for an app. A wall/TV watches without taking a seat. Each interactive phone
 takes one of the room's declared seats; shared state is replicated, public and transient. An app's
 lasting, authorized business data belongs in `createAppRecords`, not in room fields.
 
+## Lasting worlds and account characters
+
+For a world that should still exist tomorrow, set game.json:
+
+```json
+{"room":{"host":"server","lifetime":"persistent","characters":true}}
+```
+
+Lasting worlds default to `offline: false`: wait for the durable server. A studio
+may explicitly set `offline: true` for separate local practice, whose progress
+is not saved to the world or account. Never count that as proof of persistence.
+
+`characters` is optional: `lifetime` alone keeps the world. Account characters
+require the existing studio sign-in/passkey. Play redirects to the account page
+when needed. In `room.join(ctx, player)`, return
+`player.character ?? { kind: 'runner', at: spawn }`. Keep inventory in that player
+kind's declared fields and change it only in rules. Mark inventory/currency and
+collectible-ID sets with `{durable: true, visibility: 'owner'}`; use `durable: true`
+for world changes and public progress too, omitting visibility only when public.
+Durability and recipient visibility are separate declarations. The runtime returns its kind,
+position, heading, fields and motion to the account when it leaves. Use
+`player: true` or `leave: 'despawn'`; a returned character cannot also become a bot.
+Do not reset inventory in `arrive`, round-start handlers or `world.finish`.
+
+The public world has a stable room name; `?room=<name>` chooses another world.
+Every durable change commits before publishing its results. An empty world sleeps and
+retains state. A failed write stops play with the last good save intact. Another
+room waits for the current holder to return the character; no timeout grants a
+stale copy. No database or IDs are set up by hand. Ordinary games keep their
+existing save frequency and behavior.
+
+Write idempotent pickups using a saved collectible ID/set; duplicate commands
+must not mint again. Events arrive later and can become `undeliverable` when a
+recipient leaves; do not treat sending one as an atomic inventory transfer.
+Trading and shop-grant consumption need the later economy slice. Browser saves
+remain player-owned and are not an authoritative inventory.
+
+Durable fields, entity lifecycle, pending events and character leases use an
+atomic incremental journal. The rest is checkpointed every 30 seconds by default
+(`room.durability.movementSeconds`, 1–60), and on pause/shutdown. Unchanged rooms
+write nothing. A crash can rewind movement, but committed value and consumed
+inputs replay together exactly once. Declare every fact needed to prevent a
+repeat reward durable, including pickup IDs and cooldowns that protect value.
+Compatible deploys still restart/reload and then restore the world.
+A state-schema change is refused on restore with data retained; keep the previous
+compatible build until migrations ship. Offline play has no account authority.
+
+For proof, build normally, then sign two players in and test movement, pickup,
+restart mid-pickup, a compatible rebuild, and a fresh profile signing in as the
+same player. Verify actual inventory and world state. A lasting world need not
+finish a round: its browser proof replaces the match check's round requirement.
+
 ## State and field types
 
 `f` declares state, event/command/effect payloads, ask state and guide views.
@@ -683,7 +735,8 @@ for a minute with delay. Movement should respond before the authoritative respon
 score and other shared outcomes still arrive with the network. The studio chooses `players.max`; neither frame rate nor feel is guaranteed by a passing build.
 
 Room state is saved automatically (default movementSeconds: 1, plus round end,
-pause and finish). After 60 seconds with no person the room ends even if screens or
+pause and finish; a lasting world instead journals its durable fields at once and
+checkpoints the rest every 30 seconds). After 60 seconds with no person the room ends even if screens or
 AI remain. Use browser createSaves for player-owned character progress; it is not
 server-verified money. Entity fields default to public. Declare visibility explicitly for private information (below); shared state and motion remain public. Use declared server round records for verified match history.
 

package/guides/game/SKILL.md

@@ -179,11 +179,55 @@ edits, build, act on the diagnostics and test the actual play before declaring i
   Never turn typing off to make room: place the strip instead (`chat/CHAT.md` has every field).
 - Update `game.json` `name` and `blurb`, and the `<title>`.
 
+## Lasting worlds and account characters
+
+For a world that should still exist tomorrow, set game.json:
+
+```json
+{"room":{"host":"server","lifetime":"persistent","characters":true}}
+```
+
+Lasting worlds default to `offline: false`: wait for the durable server. A studio
+may explicitly set `offline: true` for separate local practice, whose progress
+is not saved to the world or account. Never count that as proof of persistence.
+
+`characters` is optional: `lifetime` alone keeps the world. Account characters
+require the existing studio sign-in/passkey. Play redirects to the account page
+when needed. In `room.join(ctx, player)`, return
+`player.character ?? { kind: 'runner', at: spawn }`. Keep inventory in that player
+kind's declared fields and change it only in rules. The runtime returns its kind,
+position, heading, fields and motion to the account when it leaves. Use
+`player: true` or `leave: 'despawn'`; a returned character cannot also become a bot.
+Do not reset inventory in `arrive`, round-start handlers or `world.finish`.
+
+The public world has a stable room name; `?room=<name>` chooses another world.
+Every tick commits before publishing its results. An empty world sleeps and
+retains state. A failed write stops play with the last good save intact. Another
+room waits for the current holder to return the character; no timeout grants a
+stale copy. No database or IDs are set up by hand. Ordinary games keep their
+existing save frequency and behavior.
+
+Write idempotent pickups using a saved collectible ID/set; duplicate commands
+must not mint again. Events arrive later and can become `undeliverable` when a
+recipient leaves; do not treat sending one as an atomic inventory transfer.
+Trading and shop-grant consumption need the later economy slice. Browser saves
+remain player-owned and are not an authoritative inventory.
+
+This first slice saves the whole world every tick, so opted-in games pay for
+more writes. Compatible deploys still restart/reload and then restore the world.
+A state-schema change is refused on restore with data retained; keep the previous
+compatible build until migrations ship. Offline play has no account authority.
+
+For proof, build normally, then sign two players in and test movement, pickup,
+restart mid-pickup, a compatible rebuild, and a fresh profile signing in as the
+same player. Verify actual inventory and world state. A lasting world need not
+finish a round: its browser proof replaces the match check's round requirement.
+
 ## Progress that lasts: cloud saves
 
 When the plan says progress persists across sessions or devices (the codex's "Progress that lasts", or the person
-asks for a character, levels, unlocks, a collection, hardcore), wire in saves. Never keep it in the room: a room
-forgets everything 60 s after its last player leaves.
+asks for a character, levels, unlocks, a collection, hardcore), wire in saves. For player-owned browser progress use the existing saves API below. For a server-authoritative
+world or inventory, use Lasting worlds above. Ordinary match rooms expire after their last player leaves.
 
 - `game.json`: `"saves": true`. A new game of that kind can start from the starter:
   `npx --no-install homie-studio game new <id> --from ember-vale --name "<Name>"` (a hero that lasts, lifetime

package/lib/build.mjs

@@ -602,7 +602,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   // studio.json site.order: the catalogue's order is every listing's order.
   const shown = orderGames(all.filter((g) => existsSync(join(dist, 'games', g.id, 'index.html'))), s.order, log);
   // Server-hosted games: what this build made, and for a one-game build what the catalogue before it said of the others.
-  const rulesOf = new Map(ruled.map((r) => [r.id, { host: r.settings.host, offline: r.settings.offline, tickHz: r.settings.tickHz, inputHz: r.settings.inputHz, contract: r.schema.contract, build: r.build, stateHash: r.stateHash, rounds: r.rounds, ...(r.schema.records?{records:true}:{}) }]));
+  const rulesOf = new Map(ruled.map((r) => [r.id, { ...(r.settings.lifetime ? { lifetime: r.settings.lifetime } : {}), ...(r.settings.characters ? { characters: true } : {}), host: r.settings.host, offline: r.settings.offline, tickHz: r.settings.tickHz, inputHz: r.settings.inputHz, contract: r.schema.contract, build: r.build, stateHash: r.stateHash, rounds: r.rounds, ...(r.schema.records?{records:true}:{}) }]));
   if (only) for (const row of readJson(join(dist, 'games.json'))?.games ?? []) if (row?.room?.contract && row.id !== only && !rulesOf.has(row.id)) rulesOf.set(row.id, row.room);
   // What each game's build is (its landing's own pictures are not part of it): the digest the manifest names.
   const builds = {};

package/lib/rules-types.mjs

@@ -80,7 +80,7 @@ type Definition = Omit<RulesDef, 'entities' | 'room' | 'move' | 'asks'> & {
   entities: ${entities}; move?: Moves;
   room?: { records?: {key:string;identity:string;eligible?:string;fields:Readonly<Record<string,string>>}; rounds?: { seconds: number; breakSeconds: number }; bots?: { keep: number }; historySeconds?: number;
     start?: (world: RW) => void;
-    join?: (ctx: Pick<W, 'map' | 'shared' | 'tune' | 'math' | 'round'>, player: { seat: number; driver: 'person' | 'bot' | 'ai'; owner: string }) => ${joins};
+    join?: (ctx: Pick<W, 'map' | 'shared' | 'tune' | 'math' | 'round'>, player: { seat: number; driver: 'person' | 'bot' | 'ai'; owner: string; character?: (${joins}) | null }) => ${joins};
     on?: { [K in keyof (Omit<Events, keyof GameRoomEvents> & GameRoomEvents)]?: (world: RW, event: EventData<(Omit<Events, keyof GameRoomEvents> & GameRoomEvents)[K]>) => void };
   };
   asks?: ${record(Object.entries(d.asks).map(([n, a]) => [n, `{ state: Fields; questions: ${value(a.questions)}; floor: (state: ReadonlyState<${fields(a.state)}>) => ${picks(a.questions)} }`]))};

package/lib/scaffold.mjs

@@ -1,4 +1,4 @@
-import { FUNCTIONS_MIGRATION, FUNCTIONS_MIGRATION_FILE, FUNCTIONS_CURSOR_MIGRATION, FUNCTIONS_CURSOR_MIGRATION_FILE } from '../worker/functions-schema.mjs';
+import { FUNCTIONS_META_MIGRATION, FUNCTIONS_META_MIGRATION_FILE, FUNCTIONS_MIGRATION, FUNCTIONS_MIGRATION_FILE, FUNCTIONS_CURSOR_MIGRATION, FUNCTIONS_CURSOR_MIGRATION_FILE } from '../worker/functions-schema.mjs';
 import { MCP_MIGRATION, MCP_MIGRATION_FILE } from '../worker/mcp-store.mjs';
 import { APPS_MIGRATION, APPS_MIGRATION_FILE } from '../worker/app-records.mjs';
 import { PURCHASE_MIGRATION, PURCHASE_MIGRATION_FILE, PURCHASE_STATE, PURCHASE_STATE_FILE } from '../worker/purchase-schema.mjs';
@@ -802,6 +802,7 @@ export { default, Table, Lobby, Gate, Concentrator } from '@homie-rocks/studio/w
     [`site/migrations/${MCP_MIGRATION_FILE}`]: MCP_MIGRATION,
     [`site/migrations/${FUNCTIONS_MIGRATION_FILE}`]: FUNCTIONS_MIGRATION,
     [`site/migrations/${FUNCTIONS_CURSOR_MIGRATION_FILE}`]: FUNCTIONS_CURSOR_MIGRATION,
+    [`site/migrations/${FUNCTIONS_META_MIGRATION_FILE}`]: FUNCTIONS_META_MIGRATION,
     [`site/migrations/${LOUNGE_MIGRATION_FILE}`]: LOUNGE_MIGRATION,
     'wrangler.jsonc': wranglerConfig({ worker, name, d1: studio.cloudflare.d1, r2: studio.cloudflare.r2, layout: 'root' }),
     '.claude/skills/.gitkeep': '',
@@ -973,6 +974,11 @@ function ensurePartsStateMigration(root) {
   return `site/migrations/${PURCHASE_STATE_FILE}`;
 }
 
+function ensureFunctionMeta(root) {
+  const file=join(root,'site','migrations',FUNCTIONS_META_MIGRATION_FILE);
+  if(existsSync(file))return null;
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,FUNCTIONS_META_MIGRATION);return `site/migrations/${FUNCTIONS_META_MIGRATION_FILE}`;
+}
 function ensureFunctionCursors(root) {
   const file=join(root,'site','migrations',FUNCTIONS_CURSOR_MIGRATION_FILE);
   if(existsSync(file))return null;
@@ -989,12 +995,12 @@ function ensureMcpMigration(root) {
   mkdirSync(dirname(file),{recursive:true});writeFileSync(file,MCP_MIGRATION);return `site/migrations/${MCP_MIGRATION_FILE}`;
 }
 export function ensureMigrations(root) {
-  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root), ensureShopReservations(root), ensureShopStatements(root), ensureShopLines(root), ensureAppsMigration(root), ensurePartsMigration(root), ensurePartsStateMigration(root), ensureMcpMigration(root), ensureFunctionsMigration(root), ensureFunctionCursors(root)].filter(Boolean);
+  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root), ensureShopReservations(root), ensureShopStatements(root), ensureShopLines(root), ensureAppsMigration(root), ensurePartsMigration(root), ensurePartsStateMigration(root), ensureMcpMigration(root), ensureFunctionsMigration(root), ensureFunctionCursors(root), ensureFunctionMeta(root)].filter(Boolean);
 }
 
 /** What a migration file the template added is for, in a few words (deploy and dev say it). */
 export function migrationWord(file) {
-  return /studio_mcp/.test(file) ? 'AI connections and tool call history' : /studio_apps/.test(file) ? 'apps: lasting records and signed-in role grants' : /lounge/.test(file) ? 'the Lounge and kept chat: play nights, moderators, and what was said only where an owner turns history on' : /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (paid sales wait until shop.json and the studio\'s Stripe connection are ready)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
+  return /function_meta/.test(file) ? 'refund events alongside plain-text studio settings' : /studio_mcp/.test(file) ? 'AI connections and tool call history' : /studio_apps/.test(file) ? 'apps: lasting records and signed-in role grants' : /lounge/.test(file) ? 'the Lounge and kept chat: play nights, moderators, and what was said only where an owner turns history on' : /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (paid sales wait until shop.json and the studio\'s Stripe connection are ready)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
 }
 
 /**

package/lib/template-history.json

@@ -2691,6 +2691,48 @@
      }
     }
    }
+  },
+  "0.46.0": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "c48971c1437414c2",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -2106,7 +2106,9 @@ from outside the studio run on its server.
 The Table writes the whole room to its SQLite `save` table in one synchronous transaction:
 entities, motion, shared state, rounds, seats and their tokens, pending events, timers and
 inputs, RNG state, tick, epoch, state hash and build hash. Saves larger than 2 MB use several
-rows in that transaction. The default interval is `room.durability.movementSeconds: 1`;
+rows in that transaction. The default interval is `room.durability.movementSeconds: 1`
+(30 for a `lifetime: "persistent"` world, which writes its `durable` fields to a journal the moment they change and
+saves the rest on this interval);
 round end, `world.finish()` and pause save immediately. Both elapsed ticks and elapsed wall
 time bound the interval, including ticks that catch up after a delay. Cloudflare's output
 gate holds outgoing frames until preceding writes are confirmed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.45.3",
+  "version": "0.46.0",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/rules/core.ts

@@ -79,7 +79,7 @@ export const IGNORE_MAX = 16;
 export const ANSWER_MAX = 256;
 
 export type Driver = 'person' | 'bot' | 'ai';
-export interface SeatInfo { seat: number; driver: Driver; owner: string }
+export interface SeatInfo { seat: number; driver: Driver; owner: string; character?: import('./rules.ts').Character | null }
 /** One seat's step for a tick: its input values (already held to their types) and, for an owner-moved body, its claim. */
 export interface StepInput { values: Record<string, unknown>; claim?: { pos: Vec3; vel: Vec3; heading: Vec3; r: number } | null }
 export interface ResultRow { seat: number; id: string; driver: Driver; score: number; place: number }
@@ -163,6 +163,7 @@ export interface Core {
   round(): Extract<CoreOut, { t: 'round' }>;
   bodies(): Body[];
   /** The body in a seat, as the host runtime needs it for the input protocol. */
+  character(seat: number): import('./rules.ts').Character | null;
   bodyOf(seat: number): { id: string; kind: KindTable; r: number; away: boolean; driver: Driver } | null;
   /** What happened since the last call: rounds, effects, a changed roster, changed shared state, a new epoch, a failure. */
   drain(): CoreOut[];
@@ -183,7 +184,7 @@ export interface Core {
  * `noted`: told, as it happens, of a value the rules wrote that the runtime changed to make it fit, or dropped (pack.ts
  * `Adjusted`; also `effect`, `think` and `decision`): the handler, what was done, the field's name and what was written.
  */
-export function createCore(c: Compiled, opts: { rewindTicks?: (seat: number)=>number; label?: (seat:number,driver:Driver)=>string; moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody, geometry: import('./math.ts').MapShapes, id: string) => void; observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
+export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number) => import('./rules.ts').Character | null | undefined; characterSaved?: (seat: number, character: import('./rules.ts').Character) => void; rewindTicks?: (seat: number)=>number; label?: (seat:number,driver:Driver)=>string; moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody, geometry: import('./math.ts').MapShapes, id: string) => void; observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
   const dims = c.dims;
   const tickHz = c.settings.tickHz;
   const dt = 1 / tickHz;
@@ -838,7 +839,7 @@ export function createCore(c: Compiled, opts: { rewindTicks?: (seat: number)=>nu
     return rows;
   }
   function joinBody(info: SeatInfo): Ent | null {
-    const player = Object.freeze({ seat: info.seat, driver: info.driver, owner: info.owner });
+    const player = Object.freeze({ seat: info.seat, driver: info.driver, owner: info.owner, ...(info.character !== undefined ? { character: deepFreeze(info.character) } : {}) });
     let made: Ent | null = null;
     run('room', 'join', null, 'join', () => {
       // What room.join returns is read by its own data properties, and its fields are charged before they are held to their shapes.
@@ -864,6 +865,7 @@ export function createCore(c: Compiled, opts: { rewindTicks?: (seat: number)=>nu
     } else {
       if (e) {
         if (e.kind.on.leave) run(e.kind.name, 'on.leave', e, 'ent', () => e.kind.on.leave(world, e.self, Object.freeze({})));
+        opts.characterSaved?.(e.seat, JSON.parse(JSON.stringify({ kind: e.kind.name, at: e.pos, heading: e.heading, fields: e.f, motion: e.m })));
         e.dead = true; ents.delete(e.id);
       }
       seats.delete(s.seat);
@@ -975,7 +977,7 @@ export function createCore(c: Compiled, opts: { rewindTicks?: (seat: number)=>nu
       if (tick < restartAt) return;
       startMatch();
       // Seats stay through a finished match: every holder's body is made again, as if it had just joined.
-      for (const s of [...seats.values()]) { seats.delete(s.seat); if (s.driver !== 'bot') ops.push({ op: 'join', info: { seat: s.seat, driver: s.driver, owner: s.owner } }, ...(s.away ? [{ op: 'away' as const, seat: s.seat, away: true }] : [])); }
+      for (const s of [...seats.values()]) { seats.delete(s.seat); if (s.driver !== 'bot') ops.push({ op: 'join', info: { seat: s.seat, driver: s.driver, owner: s.owner, ...(opts.characterForSeat ? { character: opts.characterForSeat(s.seat) } : {}) } }, ...(s.away ? [{ op: 'away' as const, seat: s.seat, away: true }] : [])); }
       return;
     }
     if (restartAsked) { restartAsked = false; endAsked = false; startRound(); return; }
@@ -992,7 +994,10 @@ export function createCore(c: Compiled, opts: { rewindTicks?: (seat: number)=>nu
   function finishMatch(): void {
     finishing = false; restartAsked = false;
     out.push({ t: 'round', n: round.n, phase: 'over', endsAt: tick + Math.max(3, ticks(c.rounds ? c.rounds.breakSeconds : 0)), startedAt: round.startedAt, results: results() });
-    for (const e of ents.values()) e.dead = true;
+    for (const e of ents.values()) {
+      if (e.kind.player) opts.characterSaved?.(e.seat, JSON.parse(JSON.stringify({ kind: e.kind.name, at: e.pos, heading: e.heading, fields: e.f, motion: e.m })));
+      e.dead = true;
+    }
     ents.clear(); spawns = []; queue = []; pendingAsks = []; areas = []; fx = [];
     for (const s of seats.values()) s.id = null;
     shared = initFields(c.shared, dims); sharedChanged();
@@ -1456,7 +1461,7 @@ export function createCore(c: Compiled, opts: { rewindTicks?: (seat: number)=>nu
       if (!floorCall && value) guideViews.set(seat, value);
       return value;
     },
-    seatJoin: (info) => { ops.push({ op: 'join', info: { seat: info.seat, driver: info.driver, owner: String(info.owner ?? '').slice(0, 128) } }); },
+    seatJoin: (info) => { ops.push({ op: 'join', info: { seat: info.seat, driver: info.driver, owner: String(info.owner ?? '').slice(0, 128), ...(info.character !== undefined ? { character: info.character } : {}) } }); },
     seatAway: (seat, away) => { ops.push({ op: 'away', seat, away }); },
     seatLeave: (seat) => { ops.push({ op: 'leave', seat }); },
     setPolicy: (p) => { policy = normalizeCorePolicy(p); },
@@ -1477,6 +1482,7 @@ export function createCore(c: Compiled, opts: { rewindTicks?: (seat: number)=>nu
       return [[round.n, round.phase === 'live' ? 1 : 0, round.endsAt], list, ...(collision ? [collision] : [])];
     },
     shared: () => packFields(c.shared, shared, dims),
+    character: (seat) => { const e = playerBodies().find(e => e.seat === seat); return e ? JSON.parse(JSON.stringify({ kind: e.kind.name, at: e.pos, heading: e.heading, fields: e.f, motion: e.m })) : null; },
     bodies: () => playerBodies().map((e) => ({ seat: e.seat, id: e.id, kind: e.kind.name, driver: e.driver, owner: e.owner, away: e.away, score: e.kind.score ? Number(e.f[e.kind.score]) || 0 : 0, r: e.r })),
     bodyOf: (seat) => { const s = seats.get(seat); const e = s?.id ? ents.get(s.id) : null; return e ? { id: e.id, kind: e.kind, r: e.r, away: e.away, driver: e.driver } : null; },
     drain: () => { const o = out; out = []; return o; },