@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/simulation/living/types.js

@@ -0,0 +1,669 @@
+import { z } from 'zod';
+import { scheduleIntentSchema, changeSchema, entitySchema, kindDefinitionSchema, kindRequestSchema, propertyValueSchema } from './open-world.js';
+// A living world is one place-graph, one cast, and an ordered list of accepted events.
+// Everything the player or a character can know derives from this state and those events.
+export const LIVING_SCHEMA_VERSION = 1;
+// The engine version marks which reducer wrote a state. Replay is exact within one
+// engine version; a state from an older engine still loads and replays, but its
+// rebuilt state may differ.
+export const LIVING_ENGINE_VERSION = 54;
+export const BOUNDED_PERSON_RECORDS_ENGINE = 54;
+export const MAX_WORKING_BELIEFS = 64;
+export const MAX_CLOSED_COMMITMENTS = 64;
+export const MAX_OPEN_COMMITMENTS = 128;
+export const STABLE_CONVERSATION_ENGINE = 52;
+export const FULL_SCHEDULE_INTENT_ENGINE = 52;
+// From this engine a world's own data may say messages take time to arrive.
+export const MESSAGE_TRAVEL_ENGINE = 39;
+// From this engine a pause or a new speed keeps the clock where the player could see it.
+export const SHOWN_CLOCK_ENGINE = 40;
+// From this engine the world keeps a chronicle of what the player did and perceived, for the ending.
+export const CHRONICLE_ENGINE = 40;
+// From this engine walking off sets aside a long act at once; before, its end did.
+export const WALK_OFF_ENGINE = 40;
+// From this engine a thing made past a trigger's threshold joins a check of its kind pending at its place.
+export const ONE_CHECK_ENGINE = 41;
+// From this engine a memory keeps the things its event concerned, and recall reaches it through them.
+export const THING_MEMORY_ENGINE = 42;
+// From this engine going away sets aside a long act under way and no one away can be spoken to.
+export const AWAY_APART_ENGINE = 42;
+// From this engine someone brought in mid-story is a newcomer.
+export const NEWCOMER_ENGINE = 42;
+export const SELF_HOLD_ENGINE = 42;
+// From this engine the player's sighting of someone keeps when the player found them gone from it.
+export const GONE_AT_ENGINE = 42;
+// From this engine the player reads of a problem what they last saw of it, and when.
+export const PROBLEM_VIEW_ENGINE = 42;
+export const REQUEST_TIME_ENGINE = 42;
+// From this engine a person counts the lines they said to someone who has not answered.
+export const SILENCE_ENGINE = 42;
+// From this engine no two people in the story share a name, and only the player's own act moves the player.
+export const IDENTITY_ENGINE = 42;
+// From this engine writing on a paper adds to its words, marked with when and by whom.
+export const WRITING_GROWS_ENGINE = 42;
+// From this engine a world's own happenings carry the typed results its data names, and deadlines are counted down;
+// a promise to be somewhere at a time is decided in time to get there.
+export const DEADLINE_ENGINE = 42;
+export const PROMISE_LEAD_MINUTES = 30;
+// A decision about a promise weighs like one about a serious act: no routine plan puts it aside.
+export const PROMISE_IMPORTANCE = 7;
+// From this engine the open problem nobody has acted on longest goes back to the Game Master every two game hours.
+export const STALL_ENGINE = 42;
+export const STALL_MINUTES = 120;
+// From this engine a thing's condition has named sides, such as damage or contents; a change to one keeps the rest.
+export const CONDITION_SIDES_ENGINE = 43;
+// From this engine a vote is a typed decision: each member casts their own ballot, and the count settles it.
+export const VOTES_ENGINE = 43;
+export const BALLOT_CHOICES = ['yes', 'no', 'abstain'];
+// From this engine the player is never shown as seeing, in a room they look into, someone who has left the story.
+export const LEFT_UNSEEN_ENGINE = 44;
+// From this engine one act adds at most this many characters to words already written, so a paper never restates itself.
+export const ADDED_LINE_ENGINE = 44;
+export const MAX_ADDED_LINE = 400;
+// From this engine a person knows the words of the papers they wrote, wherever the papers lie.
+export const AUTHORS_ENGINE = 44;
+// From this engine a thing that spreads or carries through places, such as a fire, a flood or a sound, is never held.
+export const UNHELD_ENGINE = 44;
+// From this engine coming back from rest is recorded, so people know how long they have been up.
+export const REST_ENGINE = 44;
+export const LONG_DAY_MINUTES = 16 * 60;
+// From this engine an injury, an illness, a custody, a detention, an authority, a debt or a vote belongs to no hand.
+export const BODILESS_ENGINE = 45;
+// From this engine a write gives a paper its whole new text; a replacement that drops most of the words is refused.
+export const WHOLE_TEXT_ENGINE = 45;
+// From this engine a vote opened during play gives its members a turn at once, and a room holds one open vote at a time.
+export const OPEN_NOW_ENGINE = 45;
+// From this engine only the engine writes a vote's count and result on it.
+export const COUNT_ONLY_ENGINE = 45;
+// From this engine a problem the player did not see begin is named by the place where they saw it.
+export const SEEN_WHERE_ENGINE = 45;
+// From this engine an ask records when its asker last reminded; two hours with no answer allow a reminder.
+export const REMINDER_ENGINE = 46;
+export const REMINDER_MINUTES = 120;
+// From this engine a thing's condition keeps whole sides; the oldest named side gives way, never a word.
+export const WHOLE_SIDES_ENGINE = 46;
+// From this engine the world keeps when the player last acted; two quiet game hours on, others see the
+// player's person resting, or asleep at night.
+export const PLAYER_REST_ENGINE = 47;
+export const PLAYER_QUIET_MINUTES = 120;
+// From this engine a thing keeps the order its condition sides were first set in a list a save keeps.
+export const SIDE_ORDER_ENGINE = 48;
+// From this engine a deadline averted because its problem was settled first is recorded as averted.
+export const AVERTED_ENGINE = 48;
+// From this engine a thing seen from the next room is named by its kind, such as "Fire can be seen at the quay".
+export const SIGHT_NAMED_ENGINE = 49;
+// From this engine people know what they could have seen: a world's own things from the start, what lies
+// in a room they come to, and the words of what they read.
+export const THINGS_SEEN_ENGINE = 49;
+// From this engine someone at home by day answers messages; asleep at night, they answer once back.
+export const AWAY_REPLY_ENGINE = 49;
+// From this engine a vote called in play without a closing time closes two game hours after it opens.
+export const VOTE_CLOSES_ENGINE = 50;
+// From this engine what lies in the open is in view to whoever stands there, and people learn it where
+// something happens with them present; only the player learns it on arrival, where the command loads.
+export const SEEN_AT_EVENTS_ENGINE = 50;
+export const VOTE_OPEN_MINUTES = 120;
+// Night, for going home and for sleep: from 20:00 to 05:00.
+export const NIGHT_FROM_HOUR = 20;
+export const NIGHT_UNTIL_HOUR = 5;
+export function isNight(clock) {
+    const hour = Math.floor((clock % 1440) / 60);
+    return hour >= NIGHT_FROM_HOUR || hour < NIGHT_UNTIL_HOUR;
+}
+export const DECISION_RESULTS = ['passed', 'failed', 'lapsed'];
+// Two lines to someone silent for ten minutes or more are enough until they answer; a new day starts over.
+export const UNANSWERED_LINES = 2;
+export const UNANSWERED_MINUTES = 10;
+export const UNANSWERED_RESET_MINUTES = 480;
+// The most things whose last ruling the world keeps a note of.
+export const MAX_THING_NOTES = 120;
+export const THING_NOTE_TEXT = 300;
+export const MAX_CHRONICLE = 80;
+export const MAX_TEXT = 2000;
+export function clockLabel(minutes) {
+    const day = Math.floor(minutes / 1440) + 1;
+    const hour = Math.floor((minutes % 1440) / 60);
+    const minute = minutes % 60;
+    return `Day ${day}, ${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+}
+export const MAX_CLOCK_RATE = 1440;
+export const MAX_LINE = 600;
+// One spoken line or act may run to a paragraph, so the model is never stopped mid-word.
+export const MAX_SPOKEN = 1200;
+// A newcomer's role: what anyone could call them in a few words.
+export const MAX_ROLE = 48;
+const id = z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/u);
+const short = z.string().min(1).max(200);
+const line = z.string().min(1).max(MAX_LINE);
+const text = z.string().min(1).max(MAX_TEXT);
+const minutes = z.number().int().min(0).max(1_000_000_000);
+export const placeKindSchema = z.enum(['room', 'outdoors', 'transit', 'private']);
+export const placeSchema = z.object({
+    id,
+    name: short,
+    kind: placeKindSchema,
+    summary: text,
+    connections: z.array(id),
+    conditions: z.array(short),
+    conditionAspects: z.record(id, z.object({ text: short, changedSeq: z.number().int().min(0), index: z.number().int().min(0).optional() })).default({}),
+    introducedAt: z.number().int().min(0),
+});
+export const relationshipSchema = z.object({
+    trust: z.number().int().min(-100).max(100),
+    warmth: z.number().int().min(-100).max(100),
+    note: z.string().max(MAX_LINE),
+    // The event that last changed it, so an input can cite how the person came to feel this way.
+    changedSeq: z.number().int().min(0).optional(),
+});
+export const goalSchema = z.object({ id, text: line, status: z.enum(['active', 'done', 'dropped']) });
+export const beliefSchema = z.object({
+    id,
+    subject: short,
+    claim: line,
+    source: z.object({ kind: z.enum(['initial', 'witnessed', 'told', 'discovered', 'inferred']), personId: id.nullable(), eventSeq: z.number().int().min(0) }),
+    at: minutes,
+});
+export const memorySchema = z.object({
+    id,
+    at: minutes,
+    eventSeq: z.number().int().min(0),
+    text: text,
+    importance: z.number().int().min(1).max(10),
+    participantIds: z.array(id),
+    placeId: id.nullable(),
+    // The things the remembered event concerned, when it named any.
+    thingIds: z.array(id).optional(),
+    evidence: z.object({ kind: z.enum(['observed', 'heard', 'told', 'inferred']), eventSeq: z.number().int().min(0), sourceId: id.nullable() }).optional(),
+});
+export const memorySummarySchema = z.object({
+    id,
+    personId: id,
+    at: minutes,
+    text,
+    sourceMemoryIds: z.array(id).min(1).max(4),
+    sourceEventSeqs: z.array(z.number().int().min(0)).min(1).max(4),
+    participantIds: z.array(id),
+    placeIds: z.array(id),
+    importance: z.number().int().min(1).max(10),
+});
+export const commitmentSchema = z.object({
+    id,
+    toId: id,
+    text: line,
+    dueAt: minutes.nullable(),
+    // Where the promise is to be kept, when it is a promise to be somewhere.
+    placeId: id.optional(),
+    status: z.enum(['open', 'kept', 'broken']),
+    madeAt: minutes,
+    // The event that made the promise, and who heard it made.
+    madeSeq: z.number().int().min(0).optional(),
+    knownTo: z.array(id).optional(),
+});
+// A plan is what a person is doing now and when it ends: its private intent, what anyone
+// watching can see, and where and with whom. When it ends, they decide what comes next.
+export const planSchema = z.object({
+    intent: line,
+    seen: short.optional(),
+    placeId: id.nullable(),
+    targetId: id.nullable(),
+    dueAt: minutes,
+});
+// Pronouns are authored per person so no prompt has to guess them.
+const pronouns = z.string().min(1).max(40);
+export const personSchema = z.object({
+    id,
+    name: short,
+    role: short,
+    roleId: id.nullable().optional(),
+    summary: text,
+    persona: text,
+    character: z.object({ voice: short, values: z.array(short), redLines: z.array(short), privateConcerns: z.array(short) }).optional(),
+    pronouns: pronouns.optional(),
+    isPlayer: z.boolean(),
+    placeId: id,
+    money: z.number().min(-1_000_000_000).max(1_000_000_000).nullable(),
+    mood: short,
+    // Physical state that others can see: bleeding, soaked, unconscious. Absent means unremarkable.
+    condition: short.optional(),
+    conditionChangedSeq: z.number().int().min(1).optional(),
+    // Someone with the means to enforce it is keeping this person where they are (detained, restrained, sedated).
+    held: z.object({ byId: id.nullable(), reason: line }).optional(),
+    goals: z.array(goalSchema),
+    relationships: z.record(id, relationshipSchema),
+    beliefs: z.array(beliefSchema),
+    memories: z.array(memorySchema),
+    summaries: z.array(memorySummarySchema).optional(),
+    memoryCount: z.number().int().min(0).optional(),
+    commitments: z.array(commitmentSchema),
+    plan: planSchema.nullable(),
+    // The last few activities this person took up and when, newest last; from engine 40.
+    planHistory: z.array(z.object({ at: minutes, intent: line })).max(6).optional(),
+    incapacitated: z.boolean(),
+    // The event at which this person last arrived where they are; absent until they first move.
+    arrivedSeq: z.number().int().min(1).optional(),
+    // When they last came back from rest, from engine 44; a person up sixteen hours is told since when.
+    restedAt: minutes.optional(),
+    // The typed entity whose gate stopped this person, when one did.
+    incapacitatedBy: id.optional(),
+    // A person who has left the world for good: gone home, quit, moved away or died.
+    departed: z.object({ at: minutes, reason: line }).optional(),
+    // Off in the world for a while: home, asleep, out on an errand; back at their place when it ends.
+    away: z.object({ at: minutes, until: minutes, reason: line }).optional(),
+    // Brought into the story mid-way, as a visitor: going home, they leave it. When they came, from engine 42.
+    newcomer: z.literal(true).optional(),
+    arrivedAt: minutes.optional(),
+    // Lines this person said to someone who has done nothing others could see since the first of them.
+    unanswered: z.record(id, z.object({ lines: z.number().int().min(1), firstAt: minutes })).optional(),
+});
+export const objectSchema = z.object({
+    id,
+    name: short,
+    summary: text,
+    placeId: id.nullable(),
+    holderId: id.nullable(),
+    ownerId: id.nullable(),
+    condition: short,
+    // Each named side of the condition, in the order first set; the condition line shows them all.
+    aspects: z.record(z.string().min(1).max(40), short).optional(),
+    // From engine 48, the order the sides were first set.
+    sideOrder: z.array(z.string().min(1).max(40)).max(5).optional(),
+    singlePersonMovable: z.boolean().default(true),
+    introducedAt: z.number().int().min(0),
+    custodyKnownTo: z.array(id).default([]),
+    conditionKnownTo: z.array(id).default([]),
+    // A thing the world's data hides, which only those who know where it is see.
+    hidden: z.literal(true).optional(),
+});
+export const conversationLineSchema = z.object({ seq: z.number().int().min(1), at: minutes, speakerId: id, text: text, toIds: z.array(id) });
+export const conversationSchema = z.object({
+    id,
+    placeId: id,
+    participantIds: z.array(id).min(1),
+    startedAt: minutes,
+    endedAt: minutes.nullable(),
+    lines: z.array(conversationLineSchema),
+});
+export const messageSchema = z.object({
+    id,
+    seq: z.number().int().min(1),
+    // The event that carried this message; older saves lack it.
+    eventSeq: z.number().int().min(1).optional(),
+    at: minutes,
+    fromId: id,
+    toIds: z.array(id).min(1),
+    text: text,
+    sourcePersonId: id.nullable().optional(),
+});
+export const requestSchema = z.object({
+    id,
+    senderId: id,
+    receiverId: id,
+    topic: line,
+    status: z.enum(['open', 'answered', 'refused', 'done']),
+    openedSeq: z.number().int().min(1),
+    // When it was made, from engine 42, so the one who asked knows how long it has waited.
+    openedAt: minutes.optional(),
+    // When its asker last reminded the one asked, from engine 46.
+    remindedAt: minutes.optional(),
+    knownTo: z.array(id).default([]),
+    // The words that answered it, as the one who asked heard them.
+    answer: z.object({ text: z.string().min(1).max(MAX_TEXT), seq: z.number().int().min(1) }).optional(),
+});
+export const stanceSchema = z.object({
+    personId: id, actorId: id, status: z.enum(['undecided', 'cooperate', 'refuse', 'report', 'avoid', 'confront']),
+    sourceSeq: z.number().int().min(1), changedSeq: z.number().int().min(1),
+});
+export const tensionSchema = z.object({
+    id,
+    title: short,
+    summary: text,
+    participantIds: z.array(id),
+    status: z.enum(['open', 'settled']),
+    resolution: text.nullable(),
+    changedAt: minutes,
+    // The record of what opened the problem, so later rulings on it know what really happened.
+    openedBy: line.optional(),
+    // What the player knows of a problem: its label, what they learned of it and since when, and the latest development they saw and when.
+    playerView: z.object({ title: short, summary: text, status: z.enum(['open', 'settled']), resolution: text.nullable(), latest: text.nullable().optional(),
+        since: minutes.optional(), latestAt: minutes.optional() }).nullable().default(null),
+});
+// A scheduled item belongs to one person, or to the world itself (personId null):
+// an arrival, a fire spreading, a storm, a delivery. An errand is a walk to tell
+// someone something, carried out without a model. A delivery is a message on its way. A finish is
+// the end of a long act, ruled when its time has passed.
+// A count opens or closes a vote at its written time; the engine settles it with no model.
+export const scheduledKindSchema = z.enum(['plan', 'reply', 'arrive', 'world', 'errand', 'deliver', 'finish', 'back', 'count']);
+// A message on its way: who sent it, to whom, its words, whether its readers answer, and a request it opens on arrival.
+export const deliverySchema = z.object({
+    fromId: id,
+    toIds: z.array(id).min(1).max(8),
+    text: z.string().min(1).max(MAX_TEXT),
+    replies: z.boolean(),
+    request: z.object({ requestId: id, topic: z.string().min(1).max(MAX_LINE) }).optional(),
+});
+export const messageTravelSchema = z.object({ minutes: z.number().int().min(1).max(10_080), how: z.string().min(1).max(120) });
+// What a world's own happening changes when it falls due, whatever the Game Master rules, and when it
+// does not happen at all; how far it carries and in what words; whether people count down to it.
+export const beatRulesSchema = z.object({
+    unless: z.object({ settled: id }).optional(),
+    then: z.object({
+        facts: z.array(z.object({ aspect: id, text: line })).max(8).optional(),
+        tension: z.object({ id, summary: line.optional(), status: z.enum(['open', 'settled']).optional() }).optional(),
+        transfers: z.array(z.object({ fromId: id.nullable(), toId: id.nullable(), amount: z.number().positive().max(1_000_000_000) })).max(8).optional(),
+    }).optional(),
+    reach: z.enum(['nearby', 'everywhere']).optional(),
+    heard: line.optional(),
+    deadline: z.boolean().optional(),
+});
+export const scheduledSchema = z.object({
+    id,
+    at: minutes,
+    personId: id.nullable(),
+    kind: scheduledKindSchema,
+    intent: scheduleIntentSchema,
+    placeId: id.nullable(),
+    targetId: id.nullable(),
+    sourceSeq: z.number().int().min(0),
+    importance: z.number().int().min(1).max(10).default(3),
+    // A world happening that comes back this many minutes after it is due, such as visitors or a shift change,
+    // and the id its series keeps from one time to the next.
+    everyMinutes: z.number().int().min(1).max(100_000).optional(),
+    series: id.optional(),
+    // Engine 51 stores meter decoding separately from its bounded generated identity.
+    prediction: z.object({ propertyId: id, index: z.number().int().min(0) }).optional(),
+    replanned: z.literal(true).optional(),
+    // A world's own happening, from engine 42: what it changes and how it carries.
+    beat: beatRulesSchema.optional(),
+    delivery: deliverySchema.optional(),
+    // A vote that opens or is counted at this time, from engine 43.
+    count: z.object({ entityId: id, opens: z.boolean() }).optional(),
+    // A long act's ruling, held until its time has passed: the event it will be, checked again when it
+    // applies; how each person or thing it names stood when it began; and who may react to it. Engine 39
+    // kept no record.
+    held: z.object({ at: minutes, fields: z.record(z.string(), z.unknown()), record: z.string().max(MAX_TEXT).optional(), standing: z.record(id, z.string().max(MAX_LINE)), reactorIds: z.array(id) }).optional(),
+});
+// A sighting is where the player saw someone, or, when they saw them walk out, the room they walked into;
+// and, once the player found them gone from it, when that was.
+export const sightingSchema = z.object({ placeId: id, at: minutes, heading: z.literal(true).optional(), gone: z.literal(true).optional(), away: z.literal(true).optional(),
+    goneAt: minutes.optional() });
+// Effects are the whole vocabulary of change. Every accepted event is a list of them.
+export const effectSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('move'), personId: id, placeId: id }),
+    z.object({ kind: z.literal('say'), personId: id, text: text, toIds: z.array(id) }),
+    z.object({ kind: z.literal('message'), fromId: id, toIds: z.array(id).min(1), text: text, sourcePersonId: id.nullable().optional() }),
+    // A message handed to whatever carries messages in this world; it arrives after the world's travel time.
+    z.object({ kind: z.literal('dispatch'), dispatchId: id, ...deliverySchema.shape, sourcePersonId: id.nullable().optional() }),
+    z.object({ kind: z.literal('request.open'), requestId: id, senderId: id, receiverId: id, topic: line }),
+    z.object({ kind: z.literal('request.remind'), requestId: id }),
+    z.object({ kind: z.literal('request.update'), requestId: id, status: z.enum(['answered', 'refused', 'done']), answer: z.string().min(1).max(MAX_TEXT).optional() }),
+    z.object({ kind: z.literal('norm.violation'), normEntityId: id, actionKind: id, actorId: id }),
+    z.object({ kind: z.literal('stance'), personId: id, actorId: id, status: stanceSchema.shape.status, sourceSeq: z.number().int().min(1) }),
+    z.object({ kind: z.literal('object.update'), objectId: id, condition: short.nullable(), aspect: z.string().min(1).max(40).optional(), placeId: id.nullable(), holderId: id.nullable(), ownerId: id.nullable() }),
+    z.object({ kind: z.literal('object.create'), objectId: id, name: short, summary: text, placeId: id.nullable(), holderId: id.nullable(), ownerId: id.nullable(), condition: short }),
+    z.object({ kind: z.literal('place.condition'), placeId: id, add: short.nullable(), remove: short.nullable(), aspect: id.optional() }),
+    z.object({ kind: z.literal('place.create'), placeId: id, name: short, summary: text, connections: z.array(id).min(1) }),
+    z.object({ kind: z.literal('person.create'), personId: id, name: short, role: short, summary: text, persona: text, placeId: id, pronouns: pronouns.nullable().default(null),
+        // What brought them and what they want now: their first aim.
+        wants: line.optional() }),
+    z.object({ kind: z.literal('money'), personId: id, delta: z.number().int().min(-1_000_000_000).max(1_000_000_000) }),
+    // A world deadline has passed, with what came of it.
+    z.object({ kind: z.literal('deadline.passed'), what: line, outcome: line, averted: z.literal(true).optional() }),
+    // Money passes from a person or an account to another; null is outside the world, such as costs paid.
+    z.object({ kind: z.literal('transfer'), fromId: id.nullable(), toId: id.nullable(), amount: z.number().positive().max(1_000_000_000) }),
+    z.object({ kind: z.literal('relationship'), personId: id, targetId: id, trust: z.number().int().min(-40).max(40), warmth: z.number().int().min(-40).max(40), note: z.string().max(MAX_LINE) }),
+    z.object({ kind: z.literal('belief'), personId: id, subject: short, claim: line, sourcePersonId: id.nullable(),
+        evidence: z.object({ kind: z.enum(['observed', 'heard', 'told', 'inferred']), eventSeq: z.number().int().min(0), sourceId: id.nullable() }).optional() }),
+    z.object({ kind: z.literal('commitment'), commitmentId: id, personId: id, toId: id, text: line, dueInMinutes: z.number().int().min(0).max(100_000).nullable(), placeId: id.optional() }),
+    z.object({ kind: z.literal('commitment.update'), commitmentId: id, personId: id, status: z.enum(['kept', 'broken']) }),
+    z.object({ kind: z.literal('goal'), personId: id, add: line.nullable(), dropGoalId: id.nullable(), doneGoalId: id.nullable().optional() }),
+    z.object({ kind: z.literal('mood'), personId: id, mood: short }),
+    z.object({ kind: z.literal('person.condition'), personId: id, condition: short.nullable() }),
+    z.object({ kind: z.literal('hold'), personId: id, byId: id.nullable(), reason: line.nullable() }),
+    z.object({ kind: z.literal('role'), personId: id, role: short, roleId: id.nullable().default(null) }),
+    z.object({ kind: z.literal('schedule'), scheduledId: id, personId: id.nullable(), inMinutes: z.number().int().min(1).max(100_000), intent: scheduleIntentSchema, placeId: id.nullable(), targetId: id.nullable(), scheduleKind: scheduledKindSchema,
+        importance: z.number().int().min(1).max(10).optional(), everyMinutes: z.number().int().min(1).max(100_000).optional(), series: id.optional(), beat: beatRulesSchema.optional(), replanned: z.literal(true).optional(),
+        held: z.object({ fields: z.record(z.string(), z.unknown()), record: z.string().max(MAX_TEXT).optional(), standing: z.record(id, z.string().max(MAX_LINE)), reactorIds: z.array(id) }).optional() }),
+    // A long act set aside before its end names what it was and when it began, so its actor is told.
+    z.object({ kind: z.literal('unschedule'), scheduledId: id, leftOff: z.object({ intent: scheduleIntentSchema, begunAt: minutes }).optional() }),
+    z.object({ kind: z.literal('plan'), personId: id, plan: planSchema.nullable() }),
+    z.object({ kind: z.literal('fact'), add: line.nullable(), remove: line.nullable(), aspect: id.optional() }),
+    z.object({ kind: z.literal('tension.create'), tensionId: id, title: short, summary: text, participantIds: z.array(id), openedBy: line.optional() }),
+    z.object({ kind: z.literal('tension.update'), tensionId: id, status: z.enum(['open', 'settled']), note: text.nullable() }),
+    z.object({ kind: z.literal('memory'), personId: id, text: text, importance: z.number().int().min(1).max(10), participantIds: z.array(id) }),
+    z.object({ kind: z.literal('incapacitate'), personId: id, reason: line }),
+    z.object({ kind: z.literal('person.leave'), personId: id, reason: line }),
+    z.object({ kind: z.literal('person.away'), personId: id, minutes: z.number().int().min(1).max(2880), reason: line }),
+    z.object({ kind: z.literal('person.back'), personId: id }),
+    z.object({ kind: z.literal('conversation.end'), conversationId: id }),
+    z.object({ kind: z.literal('kind.define'), definition: kindDefinitionSchema }),
+    z.object({ kind: z.literal('kind.request'), request: kindRequestSchema }),
+    z.object({ kind: z.literal('entity.create'), entityId: id, kindId: id, name: short, placeId: id.nullable().default(null),
+        initialProperties: z.record(id, propertyValueSchema).optional(),
+        // A thing that is somewhere may be made as it now is, and in the hand of someone there.
+        condition: z.string().trim().min(1).max(200).optional(), holderId: id.optional(),
+        // A decision's members, who alone may vote on it, and the problem its result settles.
+        memberIds: z.array(id).min(1).max(12).optional(), settles: id.optional(),
+        // Who knows a world's own thing from the start, when its data says, and whether it is hidden; only
+        // the opening names them.
+        knownTo: z.array(id).max(64).optional(), hidden: z.literal(true).optional(),
+        // Money that moves when the decision passes, such as an investment wired once an agreement is signed.
+        transfers: z.array(z.object({ fromId: id.nullable(), toId: id.nullable(), amount: z.number().positive().max(1_000_000_000) })).max(4).optional() }),
+    // A member casts their own vote on an open decision; only they may, in their own act or answer.
+    z.object({ kind: z.literal('ballot'), entityId: id, personId: id, choice: z.enum(BALLOT_CHOICES) }),
+    // A decision whose time is up is counted: the result follows from the ballots, not from anyone's word.
+    z.object({ kind: z.literal('decision.close'), entityId: id, result: z.enum(DECISION_RESULTS) }),
+    z.object({ kind: z.literal('property.set'), entityId: id, propertyId: id, value: propertyValueSchema.nullable() }),
+    // A thing that is somewhere changes hands, or is set down where it is.
+    z.object({ kind: z.literal('entity.move'), entityId: id, holderId: id.nullable(), placeId: id.nullable() }),
+    // A thing that is somewhere is visibly changed, such as torn or burned.
+    z.object({ kind: z.literal('entity.condition'), entityId: id, condition: short, aspect: z.string().min(1).max(40).optional() }),
+    z.object({ kind: z.literal('relation.set'), entityId: id, relationId: id, targetId: id.nullable() }),
+    // The server clock: whether the world runs, and how many game minutes pass each real minute.
+    z.object({ kind: z.literal('clock'), paused: z.boolean(), rate: z.number().int().min(1).max(MAX_CLOCK_RATE) }),
+]);
+export const eventKindSchema = z.enum([
+    'opening', 'move', 'speech', 'message', 'attempt', 'world', 'reaction', 'plan', 'wait', 'arrive', 'keep-playing', 'finish',
+    // Game time passing on the server clock, and the clock itself being paused, resumed or sped up.
+    'tick', 'clock',
+]);
+// The recap card a finish event carries: a verdict, the beats that happened, where the cast ended up, and a last line.
+export const endingSchema = z.object({
+    verdict: line,
+    highlights: z.array(line).min(1).max(5),
+    cast: z.array(z.object({ name: short, line: line })).max(4),
+    closing: line,
+});
+// How far an event carries. People in the room witness it. With 'nearby' reach, people
+// in connected places notice it (a shout, smoke, a crash) without seeing what happened;
+// with 'everywhere', everyone in the world does. The notice is what they perceive.
+export const reachSchema = z.enum(['here', 'nearby', 'everywhere']);
+export const eventSchema = z.object({
+    seq: z.number().int().min(1),
+    at: minutes,
+    kind: eventKindSchema,
+    actorId: id.nullable(),
+    placeId: id.nullable(),
+    witnessIds: z.array(id),
+    reach: reachSchema.default('here'),
+    notice: text.nullable().default(null),
+    nearbyIds: z.array(id).default([]),
+    summary: text,
+    // Older events have no observation fields. Replay uses their saved summary.
+    observed: text.nullable().optional(),
+    perceivedBy: z.array(id).optional(),
+    visibleObjectIds: z.array(id).optional(),
+    visibleTensionIds: z.array(id).optional(),
+    // The things an act handled, used or changed, or that words were about.
+    thingIds: z.array(id).max(8).optional(),
+    narration: text.nullable(),
+    outcome: z.enum(['succeeded', 'partial', 'failed', 'impossible']).nullable(),
+    minutes: z.number().int().min(0).max(100_000),
+    effects: z.array(effectSchema),
+    causeSeq: z.number().int().min(0).nullable(),
+    importance: z.number().int().min(1).max(10),
+    suggestions: z.array(short).max(3),
+    ending: endingSchema.optional(),
+    // How many proposed changes the world could not accept and left out of this event.
+    droppedEffects: z.number().int().min(1).optional(),
+    // The real time, in epoch milliseconds, at which a clock or tick event happened.
+    realAt: z.number().int().min(0).optional(),
+});
+export const stoppingPointSchema = z.object({ at: minutes, tensionId: id, title: short, summary: text });
+// Runs finished before recap cards carry only a title and text.
+export const epilogueSchema = z.object({ title: short, text: text, at: minutes }).extend(endingSchema.partial().shape);
+export const stateSchema = z.object({
+    schemaVersion: z.literal(LIVING_SCHEMA_VERSION),
+    engine: z.number().int().min(1).default(1),
+    gameKind: id,
+    seed: z.string().min(1).max(128),
+    revision: z.number().int().min(0),
+    clock: minutes,
+    // When the world began: the moment its opening and facts were written for. Older saves lack it.
+    startClock: minutes.optional(),
+    // When the player last acted, from engine 47.
+    playerActedAt: minutes.optional(),
+    status: z.enum(['open', 'finished']),
+    playerId: id,
+    places: z.record(id, placeSchema),
+    people: z.record(id, personSchema),
+    objects: z.record(id, objectSchema),
+    facts: z.array(line),
+    factAspects: z.record(id, z.object({ text: line, changedSeq: z.number().int().min(0), index: z.number().int().min(0).optional() })).default({}),
+    conversations: z.array(conversationSchema),
+    messages: z.array(messageSchema),
+    requests: z.array(requestSchema).default([]),
+    stances: z.array(stanceSchema).default([]),
+    tensions: z.array(tensionSchema),
+    schedule: z.array(scheduledSchema),
+    // Threshold crossings predicted for growing values, ordered by time; kept apart so a large count
+    // of growing things does not weigh on every change to the main schedule.
+    meterSchedule: z.array(scheduledSchema).default([]),
+    sightings: z.record(id, sightingSchema),
+    events: z.array(eventSchema),
+    stoppingPoint: stoppingPointSchema.nullable(),
+    forcedEnding: line.nullable(),
+    epilogue: epilogueSchema.nullable(),
+    opening: z.object({ title: short, situation: text, stakes: text }),
+    // The world's physics, technology and social order as authored; older saves carry none.
+    setting: z.string().max(2000).default(''),
+    currency: z.object({ symbol: z.string().min(1).max(4), name: z.string().min(1).max(40) }).nullable(),
+    // The world's deadlines that have passed lately, and what came of each.
+    passedDeadlines: z.array(z.object({ what: line, at: minutes, outcome: line, averted: z.literal(true).optional() })).max(8).optional(),
+    // Money kept apart from anyone's purse, such as a city reserve or a company account.
+    accounts: z.record(id, z.object({ id, name: short, holderId: id.nullable(), balance: z.number().min(-1_000_000_000).max(1_000_000_000), allowsDebt: z.boolean() })).optional(),
+    suggestions: z.array(short).max(3),
+    kinds: z.record(id, kindDefinitionSchema).default({}),
+    kindRequests: z.array(kindRequestSchema).default([]),
+    entities: z.record(id, entitySchema).default({}),
+    entityPlaceIds: z.record(id, z.array(id)).default({}),
+    globalEntityIds: z.array(id).default([]),
+    // Decisions still open to votes, so finding them never walks every thing in the world.
+    openDecisionIds: z.array(id).optional(),
+    // The papers each person wrote, by their author slot, so a mind recalls them without walking every thing.
+    authoredIds: z.record(id, z.array(id)).optional(),
+    entityMoveSubjectIds: z.record(id, z.array(id)).default({}),
+    // Placeless things by the people, places and things they name; those that name nothing apply everywhere.
+    globalEntityRefs: z.record(id, z.record(id, z.literal(true))).default({}),
+    worldEntityIds: z.record(id, z.literal(true)).default({}),
+    changes: z.array(changeSchema).default([]),
+    // A live world runs on the server clock: game minutes per real minute, whether it is paused, and
+    // the game and real time the clock was last set at. Without a rate, time moves with each event.
+    clockRate: z.number().int().min(1).max(MAX_CLOCK_RATE).nullable().default(null),
+    paused: z.boolean().default(false),
+    clockAnchor: z.object({ game: minutes, real: z.number().int().min(0) }).nullable().default(null),
+    // How messages travel here and how many game minutes they take; null when they arrive at once.
+    messageTravel: messageTravelSchema.nullable().default(null),
+    // The turning points of the player's story as they saw them, bounded, oldest first.
+    chronicle: z.array(z.object({ seq: z.number().int().min(1), at: minutes, kind: z.string().min(1).max(40), placeId: id.nullable(),
+        summary: z.string().min(1).max(MAX_TEXT), outcome: z.string().max(40).nullable(), importance: z.number().int().min(1).max(10), mine: z.boolean() })).default([]),
+    // What a ruling last did with each thing it named, for later rulings: the newest things only.
+    thingNotes: z.record(id, z.object({ seq: z.number().int().min(1), at: minutes, text: z.string().min(1).max(THING_NOTE_TEXT) })).default({}),
+});
+// The ids a thing names through its id properties and relations.
+export function entityRefs(kinds, entity) {
+    const refs = new Set();
+    for (const property of kinds[entity.kindId]?.properties ?? []) {
+        const value = entity.properties[property.id]?.value;
+        if (property.type === 'id' && typeof value === 'string')
+            refs.add(value);
+    }
+    for (const relation of Object.values(entity.relations))
+        refs.add(relation.targetId);
+    return [...refs].sort();
+}
+function freezeThrough(value) {
+    if (value === null || typeof value !== 'object' || Object.isFrozen(value))
+        return;
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        freezeThrough(child);
+}
+// With automatic immutability off, the draft library walks every plain value it meets while drafts remain
+// open, so large indexes would cost their full size on every event. Frozen, they are skipped; the
+// reducer only ever changes them through drafts, which copy on write, and a loaded state starts sealed.
+export function sealLivingIndexes(state) {
+    for (const person of Object.values(state.people))
+        if (!Object.isFrozen(person.memories))
+            Object.freeze(person.memories);
+    for (const list of [state.meterSchedule, state.changes, state.globalEntityIds])
+        if (!Object.isFrozen(list))
+            Object.freeze(list);
+    // An accepted event never changes; frozen through, the recent events cost nothing on later events.
+    for (const event of state.events)
+        if (!Object.isFrozen(event))
+            freezeThrough(event);
+    for (const table of [state.worldEntityIds, state.globalEntityRefs, state.entityPlaceIds, state.entityMoveSubjectIds]) {
+        if (Object.isFrozen(table))
+            continue;
+        for (const value of Object.values(table))
+            if (typeof value === 'object' && !Object.isFrozen(value))
+                Object.freeze(value);
+        Object.freeze(table);
+    }
+    return state;
+}
+export function parseLivingState(value) {
+    const parsed = stateSchema.parse(value);
+    if (value === null || typeof value !== 'object' || !('globalEntityRefs' in value) || !('worldEntityIds' in value)) {
+        parsed.globalEntityRefs = {};
+        parsed.worldEntityIds = {};
+        for (const entity of Object.values(parsed.entities)) {
+            if (entity.placeId !== null)
+                continue;
+            const refs = entityRefs(parsed.kinds, entity);
+            if (refs.length === 0)
+                parsed.worldEntityIds[entity.id] = true;
+            for (const ref of refs)
+                (parsed.globalEntityRefs[ref] ??= {})[entity.id] = true;
+        }
+    }
+    if (value !== null && typeof value === 'object' && 'entityPlaceIds' in value
+        && 'globalEntityIds' in value && 'entityMoveSubjectIds' in value)
+        return sealLivingIndexes(parsed);
+    parsed.entityPlaceIds = {};
+    parsed.globalEntityIds = [];
+    parsed.entityMoveSubjectIds = {};
+    for (const entity of Object.values(parsed.entities)) {
+        if (entity.placeId === null)
+            parsed.globalEntityIds.push(entity.id);
+        else
+            (parsed.entityPlaceIds[entity.placeId] ??= []).push(entity.id);
+        const kind = parsed.kinds[entity.kindId];
+        for (const mechanic of kind?.mechanics ?? []) {
+            if (mechanic.kind !== 'change' || !mechanic.onEvent)
+                continue;
+            const subjectId = entity.properties[mechanic.onEvent.subjectPropertyId]?.value;
+            if (typeof subjectId === 'string')
+                (parsed.entityMoveSubjectIds[subjectId] ??= []).push(entity.id);
+        }
+    }
+    return sealLivingIndexes(parsed);
+}
+export class LivingWorldError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'LivingWorldError';
+    }
+}