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

package/dist/simulation/living/reduce.js

@@ -0,0 +1,1853 @@
+import { BOUNDED_IDENTIFIERS_ENGINE, generatedId } from './identifiers.js';
+import { current, isDraft, produce, setAutoFreeze } from 'immer';
+import { observedObjectIds, observedSummary, visibleTo, witnessed } from './projection.js';
+import { valueMatchesType } from './open-world.js';
+import { ACT_GATE_ENGINE, GLOBAL_SIGNAL_CHANNEL, LAZY_METER_ENGINE, LOCAL_RECOVERY_ENGINE, plain, PEEK_ENTITY, readEntity, advanceScopedEntities, applyEventChanges, currentValue, dropStalePredictions, indexPlaceless, insertScheduled, reindexPlaceless, keepPassedCrossings, predictCrossings, blockedByGate, gatesAgainst, heldHere, normViolationsFor, runTriggers, signalNotice, signalsFor, spreadLevel } from './mechanics.js';
+import { STABLE_CONVERSATION_ENGINE, ADDED_LINE_ENGINE, AUTHORS_ENGINE, AVERTED_ENGINE, AWAY_REPLY_ENGINE, SEEN_AT_EVENTS_ENGINE, THINGS_SEEN_ENGINE, VOTE_CLOSES_ENGINE, VOTE_OPEN_MINUTES, isNight, COUNT_ONLY_ENGINE, REMINDER_ENGINE, WHOLE_SIDES_ENGINE, PLAYER_REST_ENGINE, SIDE_ORDER_ENGINE, OPEN_NOW_ENGINE, SEEN_WHERE_ENGINE, REST_ENGINE, UNHELD_ENGINE, WHOLE_TEXT_ENGINE, AWAY_APART_ENGINE, CHRONICLE_ENGINE, CONDITION_SIDES_ENGINE, DEADLINE_ENGINE, LEFT_UNSEEN_ENGINE, MAX_ADDED_LINE, VOTES_ENGINE, MAX_LINE, PROMISE_IMPORTANCE, PROMISE_LEAD_MINUTES, IDENTITY_ENGINE, STALL_ENGINE, STALL_MINUTES, SILENCE_ENGINE, WRITING_GROWS_ENGINE, MAX_TEXT, clockLabel, UNANSWERED_LINES, UNANSWERED_MINUTES, UNANSWERED_RESET_MINUTES, NEWCOMER_ENGINE, REQUEST_TIME_ENGINE, LivingWorldError, MAX_CHRONICLE, MAX_THING_NOTES, THING_NOTE_TEXT, SHOWN_CLOCK_ENGINE, THING_MEMORY_ENGINE, WALK_OFF_ENGINE, entityRefs, eventSchema, sealLivingIndexes, GONE_AT_ENGINE, PROBLEM_VIEW_ENGINE } from './types.js';
+import { BOUNDED_PERSON_RECORDS_ENGINE, MAX_WORKING_BELIEFS, MAX_CLOSED_COMMITMENTS, MAX_OPEN_COMMITMENTS } from './types.js';
+import { namesPerson, neverHeld, oneEachSlot, sealedPaper } from './shared-kinds.js';
+// The reducer is the replay oracle. It is pure: the same state and event always give
+// the same next state, and nothing here consults a model, a clock, or randomness.
+setAutoFreeze(false);
+class EntityOverlay {
+}
+function entityOverlay(entities) {
+    const changed = {};
+    const table = new Proxy(new EntityOverlay(), {
+        get(target, key) {
+            if (key === PEEK_ENTITY)
+                return (id) => Object.hasOwn(changed, id) ? changed[id] : entities[id];
+            if (typeof key !== 'string')
+                return Reflect.get(target, key);
+            if (Object.hasOwn(changed, key))
+                return changed[key];
+            if (!Object.hasOwn(entities, key))
+                return Reflect.get(target, key);
+            const original = entities[key];
+            const copied = structuredClone(original);
+            changed[key] = copied;
+            return copied;
+        },
+        set(_target, key, value) {
+            if (typeof key !== 'string')
+                return false;
+            changed[key] = value;
+            return true;
+        },
+        ownKeys() { return [...new Set([...Object.keys(entities), ...Object.keys(changed)])]; },
+        getOwnPropertyDescriptor(_target, key) {
+            if (typeof key !== 'string' || !Object.hasOwn(changed, key) && !Object.hasOwn(entities, key))
+                return undefined;
+            return { configurable: true, enumerable: true, writable: true, value: changed[key] ?? entities[key] };
+        },
+    });
+    return { table, changes: () => changed };
+}
+// Who is in a place now; someone who has left the world, or is away for a while, is nowhere.
+export function peopleAt(state, placeId) {
+    return Object.values(state.people).filter(person => person.placeId === placeId && person.departed === undefined && person.away === undefined).map(person => person.id).sort();
+}
+export function witnessesFor(state, event) {
+    const present = event.placeId === null ? [] : peopleAt(state, event.placeId);
+    if (event.actorId !== null && !present.includes(event.actorId))
+        return [...present, event.actorId].sort();
+    return present;
+}
+// Who notices an event without being in the room: with 'nearby' reach, everyone in a
+// connected place; with 'everywhere', everyone elsewhere; and whoever is in a room that
+// someone walks into sees them arrive. Derived from the place graph, so replay can
+// check it the way it checks witnesses.
+export function nearbyFor(state, event) {
+    const noticed = new Set();
+    const place = event.placeId === null ? undefined : state.places[event.placeId];
+    if (place && (event.reach ?? 'here') !== 'here') {
+        const places = event.reach === 'everywhere' ? Object.keys(state.places).filter(id => id !== event.placeId) : place.connections;
+        for (const id of places.flatMap(id => peopleAt(state, id)))
+            noticed.add(id);
+    }
+    for (const effect of event.effects) {
+        if (effect.kind !== 'move')
+            continue;
+        for (const id of peopleAt(state, effect.placeId))
+            if (id !== effect.personId)
+                noticed.add(id);
+    }
+    for (const signal of signalsFor(state, event.effects)) {
+        if (signal.targetPlaceId !== null)
+            for (const id of peopleAt(state, signal.targetPlaceId))
+                noticed.add(id);
+        else if (signal.channel === GLOBAL_SIGNAL_CHANNEL)
+            for (const id of Object.keys(state.people))
+                noticed.add(id);
+    }
+    return [...noticed].filter(id => event.placeId === null || state.people[id].placeId !== event.placeId).sort();
+}
+// Where someone arrived from, when an event walked them into this person's room.
+export function arrivalFor(state, event, personId) {
+    const person = state.people[personId];
+    if (!person)
+        return null;
+    const move = event.effects.find(effect => effect.kind === 'move' && effect.placeId === person.placeId && effect.personId !== personId);
+    if (!move || move.kind !== 'move')
+        return null;
+    return `${state.people[move.personId]?.name ?? move.personId} comes in from ${event.placeId ? state.places[event.placeId]?.name ?? event.placeId : 'elsewhere'}`;
+}
+// The working state keeps the recent part of what the event log keeps whole: the latest lines of
+// each conversation, the latest ended conversations, and the latest messages.
+const CONVERSATION_LINES = 64;
+const ENDED_CONVERSATIONS = 16;
+const INBOX_MESSAGES = 256;
+const KEPT_CLOSED_REQUESTS = 64;
+const BOUNDED_RECORDS_ENGINE = 33;
+// How many of the newest events, and their changes, the working state carries.
+const RECENT_EVENTS = 64;
+const KEPT_ACTIVE_GOALS = 32;
+const KEPT_FINISHED_GOALS = 16;
+// The working state carries the property and relation changes of the recent events it carries;
+// the durable change log keeps every change. Dropping from the front costs each change once.
+function keepRecentChanges(state, cutoffSeq) {
+    const items = plain(state.changes);
+    let first = 0;
+    while (first < items.length && items[first].seq <= cutoffSeq)
+        first += 1;
+    if (first === 0)
+        return;
+    state.changes = items.slice(first);
+}
+function keepWorkingStateBounded(state, replay) {
+    for (const conversation of state.conversations) {
+        if (conversation.lines.length > CONVERSATION_LINES)
+            conversation.lines = conversation.lines.slice(-CONVERSATION_LINES);
+    }
+    const ended = state.conversations.filter(conversation => conversation.endedAt !== null);
+    if (ended.length > ENDED_CONVERSATIONS) {
+        const dropped = new Set(ended.slice(0, ended.length - ENDED_CONVERSATIONS).map(conversation => conversation.id));
+        state.conversations = state.conversations.filter(conversation => !dropped.has(conversation.id));
+    }
+    if (state.messages.length > INBOX_MESSAGES)
+        state.messages = state.messages.slice(-INBOX_MESSAGES);
+    // Requests and goals stay in the event log; saved state keeps what inputs and rules can use: every
+    // open request, the newest refusals, the newest settled requests, and each person's newest goals.
+    // Older engines kept every request and goal; their logged ids depend on that, so they keep it.
+    if (state.engine < BOUNDED_RECORDS_ENGINE)
+        return;
+    const newest = (items, keep) => new Set(items.slice(Math.max(0, items.length - keep)));
+    if (state.requests.length > KEPT_CLOSED_REQUESTS) {
+        const refused = newest(state.requests.filter(request => request.status === 'refused'), KEPT_CLOSED_REQUESTS);
+        const settled = newest(state.requests.filter(request => request.status === 'answered' || request.status === 'done'), KEPT_CLOSED_REQUESTS);
+        if (refused.size + settled.size + state.requests.filter(request => request.status === 'open').length < state.requests.length) {
+            state.requests = state.requests.filter(request => request.status === 'open' || refused.has(request) || settled.has(request));
+        }
+    }
+    for (const person of Object.values(state.people)) {
+        if (state.engine >= BOUNDED_PERSON_RECORDS_ENGINE) {
+            if (person.beliefs.length > MAX_WORKING_BELIEFS)
+                person.beliefs = person.beliefs.slice(-MAX_WORKING_BELIEFS);
+            const closed = newest(person.commitments.filter(item => item.status !== 'open'), MAX_CLOSED_COMMITMENTS);
+            if (closed.size + person.commitments.filter(item => item.status === 'open').length < person.commitments.length) {
+                person.commitments = person.commitments.filter(item => item.status === 'open' || closed.has(item));
+                if (replay)
+                    replay.set(person.id, new Map(person.commitments.map(item => [item.id, item])));
+            }
+        }
+        if (person.goals.length <= KEPT_ACTIVE_GOALS)
+            continue;
+        const active = newest(person.goals.filter(goal => goal.status === 'active'), KEPT_ACTIVE_GOALS);
+        const finished = newest(person.goals.filter(goal => goal.status !== 'active'), KEPT_FINISHED_GOALS);
+        if (active.size + finished.size < person.goals.length)
+            person.goals = person.goals.filter(goal => active.has(goal) || finished.has(goal));
+    }
+}
+export function applyLivingEvent(previous, input) {
+    return applyEvent(previous, input);
+}
+// Replay owns this fresh state. Mutating it avoids copying the full archive on every event.
+export function foldLivingEvents(initial, events) {
+    let state = structuredClone(initial);
+    const commitments = new Map(Object.values(state.people).map(person => [person.id, new Map(person.commitments.map(commitment => [commitment.id, commitment]))]));
+    for (const event of events)
+        state = applyEvent(state, event, commitments);
+    return sealLivingIndexes(state);
+}
+function applyEvent(previous, input, replay) {
+    if (previous.status === 'finished')
+        throw new LivingWorldError('run-finished', 'A finished story accepts no further events');
+    // Events written by an older engine carry no reach: parsing fills the defaults and the
+    // reducer works out who was nearby, since that record was never kept.
+    const legacy = input.reach === undefined;
+    const parsed = eventSchema.safeParse(input);
+    if (!parsed.success)
+        throw new LivingWorldError('state-invalid', `Event ${input.seq} is malformed: ${parsed.error.message}`);
+    const signaledNotice = signalNotice(previous, parsed.data.effects, parsed.data.observed ?? null);
+    const event = legacy
+        ? { ...parsed.data, nearbyIds: nearbyFor(previous, parsed.data), notice: signaledNotice ?? parsed.data.notice }
+        : { ...parsed.data, notice: signaledNotice ?? parsed.data.notice };
+    if (event.seq !== previous.revision + 1)
+        throw new LivingWorldError('replay-mismatch', `Event ${event.seq} does not follow revision ${previous.revision}`);
+    if (event.at !== previous.clock)
+        throw new LivingWorldError('replay-mismatch', `Event ${event.seq} starts at ${event.at}, not the clock ${previous.clock}`);
+    // A paused world accepts nothing but the clock event that resumes it.
+    if (previous.paused && event.kind !== 'clock')
+        throw new LivingWorldError('run-paused', 'The world is paused');
+    checkClockEvent(previous, event);
+    // In a live world only the clock moves time; an act's minutes are how long it keeps its actor busy.
+    const live = previous.clockRate !== null;
+    const endsAt = live && event.kind !== 'tick' ? event.at : event.at + event.minutes;
+    const expectedWitnesses = witnessesFor(previous, event);
+    if (JSON.stringify(expectedWitnesses) !== JSON.stringify([...event.witnessIds].sort())) {
+        throw new LivingWorldError('replay-mismatch', `Event ${event.seq} names witnesses ${event.witnessIds.join(',')} but ${expectedWitnesses.join(',')} were present`);
+    }
+    if (event.perceivedBy && (new Set(event.perceivedBy).size !== event.perceivedBy.length
+        || event.perceivedBy.some(id => !expectedWitnesses.includes(id)))) {
+        throw new LivingWorldError('effect-invalid', `Event ${event.seq} names someone who could not perceive it`);
+    }
+    const affectedObjects = new Set(event.effects.flatMap(effect => effect.kind === 'object.update' || effect.kind === 'object.create' ? [effect.objectId] : []));
+    if (event.visibleObjectIds && new Set(event.visibleObjectIds).size !== event.visibleObjectIds.length) {
+        throw new LivingWorldError('effect-invalid', `Event ${event.seq} repeats a visible object id`);
+    }
+    const remoteVisibleObject = event.visibleObjectIds?.find(id => {
+        if (affectedObjects.has(id))
+            return false;
+        const object = previous.objects[id];
+        return !object || event.placeId === null || object.placeId !== event.placeId
+            && (object.holderId === null || previous.people[object.holderId]?.placeId !== event.placeId);
+    });
+    if (remoteVisibleObject) {
+        throw new LivingWorldError('effect-invalid', `Visible object ${remoteVisibleObject} is not at the event place`);
+    }
+    const affectedTensions = new Set(event.effects.flatMap(effect => effect.kind === 'tension.create' || effect.kind === 'tension.update' ? [effect.tensionId] : []));
+    if (event.visibleTensionIds && new Set(event.visibleTensionIds).size !== event.visibleTensionIds.length) {
+        throw new LivingWorldError('effect-invalid', `Event ${event.seq} repeats a visible tension id`);
+    }
+    const remoteVisibleTension = event.visibleTensionIds?.find(id => {
+        if (affectedTensions.has(id))
+            return false;
+        const tension = previous.tensions.find(candidate => candidate.id === id);
+        return !tension || event.placeId === null || !tension.participantIds.some(personId => previous.people[personId]?.placeId === event.placeId);
+    });
+    if (remoteVisibleTension) {
+        throw new LivingWorldError('effect-invalid', `Visible tension ${remoteVisibleTension} has no participant at the event place`);
+    }
+    const expectedNearby = nearbyFor(previous, event);
+    if (!legacy && JSON.stringify(expectedNearby) !== JSON.stringify([...event.nearbyIds].sort())) {
+        throw new LivingWorldError('replay-mismatch', `Event ${event.seq} names nearby people ${event.nearbyIds.join(',')} but ${expectedNearby.join(',')} were nearby`);
+    }
+    const change = (state) => {
+        const playerPresent = event.witnessIds.includes(state.playerId);
+        // Older changes leave before this event's changes join, so the trim reads the list as it was.
+        if (state.engine >= LOCAL_RECOVERY_ENGINE)
+            keepRecentChanges(state, event.seq - RECENT_EVENTS);
+        for (const effect of event.effects)
+            applyEffect(state, event, effect, replay);
+        if (state.engine >= SILENCE_ENGINE)
+            noteUnanswered(state, event);
+        if (event.thingIds && (new Set(event.thingIds).size !== event.thingIds.length || event.thingIds.some(id => !readEntity(state, id) && !state.objects[id]))) {
+            throw new LivingWorldError('effect-invalid', `Event ${event.seq} names a thing that does not exist, or one twice`);
+        }
+        for (const objectId of event.visibleObjectIds ?? []) {
+            const object = state.objects[objectId];
+            if (!object)
+                throw new LivingWorldError('effect-invalid', `Unknown visible object ${objectId}`);
+            const observers = [...(event.perceivedBy ?? event.witnessIds), ...(event.actorId ? [event.actorId] : [])];
+            object.custodyKnownTo = [...new Set([...object.custodyKnownTo, ...observers])];
+            object.conditionKnownTo = [...new Set([...object.conditionKnownTo, ...observers])];
+        }
+        if ((event.perceivedBy ?? event.witnessIds).includes(state.playerId)) {
+            for (const tensionId of event.visibleTensionIds ?? []) {
+                if (affectedTensions.has(tensionId))
+                    continue;
+                const tension = state.tensions.find(candidate => candidate.id === tensionId);
+                if (state.engine >= PROBLEM_VIEW_ENGINE) {
+                    seeTension(state, tension, event, 'shown');
+                    continue;
+                }
+                tension.playerView = {
+                    title: tension.playerView?.title ?? tension.title,
+                    summary: tension.playerView?.summary ?? event.observed ?? tension.summary,
+                    status: tension.status,
+                    resolution: tension.status === 'settled' ? event.observed ?? tension.resolution : null,
+                    latest: tension.playerView ? event.observed ?? null : null,
+                };
+            }
+        }
+        applyEventChanges(state, event);
+        if (state.engine >= LAZY_METER_ENGINE)
+            dropStalePredictions(state, endsAt);
+        else {
+            advanceScopedEntities(state, event.placeId, endsAt, event.seq);
+            for (const destination of new Set(event.effects.flatMap(effect => effect.kind === 'move' ? [effect.placeId] : []))) {
+                if (destination !== event.placeId)
+                    advanceScopedEntities(state, destination, endsAt, event.seq);
+            }
+        }
+        if (event.effects.some(effect => effect.kind === 'move')) {
+            for (const person of Object.values(state.people)) {
+                if (person.held?.byId && state.people[person.held.byId].placeId !== person.placeId)
+                    delete person.held;
+            }
+        }
+        keepWorkingStateBounded(state, replay);
+        // A typed cause set up later in the same act still counts as what stopped the person.
+        for (const effect of event.effects) {
+            if (effect.kind !== 'incapacitate')
+                continue;
+            const person = state.people[effect.personId];
+            const cause = person.incapacitatedBy === undefined ? blockedByGate(state, person.id, 'incapacitate') : null;
+            if (cause !== null)
+                person.incapacitatedBy = cause;
+        }
+        // Recovery is decided where the event happens and where the player arrives: a character may arrive
+        // several rooms away in a room a command did not load, but the player's next room is always loaded,
+        // so a scoped fold and the whole world reach the same state.
+        const recoveryPlaces = state.engine >= LOCAL_RECOVERY_ENGINE
+            ? new Set([event.placeId, ...event.effects.flatMap(effect => effect.kind === 'move' && effect.personId === state.playerId ? [effect.placeId] : [])]) : null;
+        for (const person of Object.values(state.people)) {
+            if (person.incapacitatedBy === undefined || (recoveryPlaces !== null && !recoveryPlaces.has(person.placeId)))
+                continue;
+            if (blockedByGate(state, person.id, 'incapacitate') !== null)
+                continue;
+            person.incapacitated = false;
+            delete person.incapacitatedBy;
+        }
+        rememberEvent(state, event);
+        recordChronicle(state, event);
+        noteThings(state, event);
+        learnThings(state, event);
+        // From engine 50 those where something happens learn what lies there in the open; that room is loaded.
+        if (state.engine >= SEEN_AT_EVENTS_ENGINE && event.placeId !== null && state.places[event.placeId]) {
+            for (const personId of peopleAt(state, event.placeId))
+                seeWhatLiesHere(state, personId, event.placeId);
+        }
+        if (event.actorId !== null && ((event.importance >= 7 && (event.kind === 'attempt' || event.kind === 'speech'))
+            || event.effects.some(effect => effect.kind === 'norm.violation'))) {
+            // Each serious act asks every witness for a fresh decision about its actor.
+            for (const personId of event.perceivedBy ?? event.witnessIds) {
+                if (personId === event.actorId || personId === state.playerId)
+                    continue;
+                const existing = state.stances.find(stance => stance.personId === personId && stance.actorId === event.actorId);
+                if (existing)
+                    Object.assign(existing, { status: 'undecided', sourceSeq: event.seq, changedSeq: event.seq });
+                else
+                    state.stances.push({ personId, actorId: event.actorId, status: 'undecided', sourceSeq: event.seq, changedSeq: event.seq });
+            }
+        }
+        if (playerPresent && event.placeId !== null)
+            observePlace(state, event.placeId, event.at);
+        if (event.kind === 'keep-playing')
+            state.stoppingPoint = null;
+        // Suggestions belong to the latest character line addressed to the player; the player's own words clear them.
+        if (event.actorId === state.playerId)
+            state.suggestions = [];
+        else if (event.suggestions.length > 0)
+            state.suggestions = [...event.suggestions];
+        if (event.kind === 'finish') {
+            state.epilogue = { title: event.summary, text: event.narration ?? event.summary, at: event.at, ...event.ending };
+            state.status = 'finished';
+        }
+        state.clock = endsAt;
+        state.revision = event.seq;
+        if (state.engine >= PLAYER_REST_ENGINE && event.actorId === state.playerId && event.kind !== 'tick' && event.kind !== 'clock')
+            state.playerActedAt = event.at;
+        state.events = [...plain(state.events).slice(-RECENT_EVENTS), event];
+    };
+    if (replay) {
+        change(previous);
+        return previous;
+    }
+    const overlay = entityOverlay(previous.entities);
+    const next = produce({ ...previous, entities: overlay.table }, change);
+    const changed = overlay.changes();
+    const result = { ...next, entities: Object.keys(changed).length === 0 ? previous.entities : { ...previous.entities, ...changed } };
+    sealLivingIndexes(result);
+    return result;
+}
+function applyEffect(state, event, effect, replay) {
+    // From engine 49 a world's own things, as its opening sets them out, are known to everyone in it.
+    const opening = event.kind === 'opening' && state.engine >= THINGS_SEEN_ENGINE;
+    const knownTo = opening ? Object.keys(state.people).sort()
+        : [...new Set([...(event.perceivedBy ?? event.witnessIds), ...(event.actorId && state.people[event.actorId] ? [event.actorId] : [])])];
+    switch (effect.kind) {
+        case 'move': {
+            const person = requirePerson(state, effect.personId);
+            // The player goes where they choose, or where someone beside them takes them; nothing else moves them.
+            if (state.engine >= IDENTITY_ENGINE && person.id === state.playerId && event.actorId !== state.playerId
+                && (event.actorId === null || event.placeId !== person.placeId)) {
+                throw new LivingWorldError('effect-invalid', `${person.name} moves only by their own choice or with someone beside them`);
+            }
+            if (event.actorId === person.id) {
+                // The repair hears what holds the person and how an act that frees them must say so first.
+                const gate = gatesAgainst(state, person.id, 'move')[0];
+                if (gate)
+                    throw new LivingWorldError('effect-invalid', `${gate.name} (${gate.entityId}) holds ${person.name}; to free them, set its ${gate.propertyId} first in the same ruling, or keep them here`);
+            }
+            requirePlace(state, effect.placeId);
+            const from = person.placeId;
+            person.placeId = effect.placeId;
+            person.arrivedSeq = event.seq;
+            carryHeldEntities(state, person.id, from, effect.placeId);
+            // A character may walk into a room the command did not load; from engine 50 only the player,
+            // whose next room is always loaded, learns what lies there on arrival.
+            if (state.engine < SEEN_AT_EVENTS_ENGINE || person.id === state.playerId)
+                seeWhatLiesHere(state, person.id, effect.placeId);
+            // Walking off sets aside any long act the person had under way.
+            if (state.engine >= WALK_OFF_ENGINE && state.schedule.some(item => item.kind === 'finish' && item.targetId === person.id)) {
+                state.schedule = state.schedule.filter(item => !(item.kind === 'finish' && item.targetId === person.id));
+            }
+            leaveConversations(state, person.id, from, event.at);
+            if (person.id === state.playerId)
+                observePlace(state, effect.placeId, event.at + event.minutes);
+            // Seen arriving where the player stands, the player knows where they are.
+            else if (state.people[state.playerId].placeId === effect.placeId)
+                state.sightings[person.id] = { placeId: effect.placeId, at: event.at };
+            // Seen walking out, they were last seen heading into the next room on their way.
+            else if ((event.perceivedBy ?? event.witnessIds).includes(state.playerId)) {
+                state.sightings[person.id] = { placeId: travelPath(state, from, effect.placeId)?.[1] ?? effect.placeId, at: event.at, heading: true };
+            }
+            return;
+        }
+        case 'say': {
+            const speaker = requirePerson(state, effect.personId);
+            if (event.placeId === null || speaker.placeId !== event.placeId)
+                throw new LivingWorldError('effect-invalid', `${speaker.name} cannot speak at a place they are not in`);
+            if (state.engine >= ACT_GATE_ENGINE && event.actorId === speaker.id) {
+                const gate = blockedByGate(state, speaker.id, 'speak');
+                if (gate)
+                    throw new LivingWorldError('effect-invalid', `Speech is blocked by ${gate}`);
+            }
+            for (const target of effect.toIds) {
+                const listener = requirePerson(state, target);
+                if (listener.placeId !== event.placeId || state.engine >= AWAY_APART_ENGINE && listener.away)
+                    throw new LivingWorldError('effect-invalid', `${listener.name} is not here to be addressed`);
+            }
+            const conversation = openConversation(state, event.placeId, [speaker.id, ...effect.toIds], event.at, event.seq);
+            conversation.lines.push({ seq: event.seq, at: event.at, speakerId: speaker.id, text: effect.text, toIds: [...effect.toIds] });
+            return;
+        }
+        case 'message': {
+            checkMessage(state, event, effect);
+            const seq = (state.messages.at(-1)?.seq ?? 0) + 1;
+            state.messages.push({ id: `message-${event.seq}-${seq}`, seq, eventSeq: event.seq, at: event.at, fromId: effect.fromId, toIds: [...effect.toIds], text: effect.text,
+                ...(effect.sourcePersonId ? { sourcePersonId: effect.sourcePersonId } : {}) });
+            return;
+        }
+        case 'dispatch': {
+            if (state.messageTravel === null)
+                throw new LivingWorldError('effect-invalid', 'Messages here arrive at once');
+            checkMessage(state, event, effect);
+            if (state.schedule.some(item => item.id === effect.dispatchId))
+                throw new LivingWorldError('effect-invalid', `Delivery ${effect.dispatchId} already exists`);
+            // Whose account it passes on is checked now, when it is sent; the reader learns it from the sender.
+            const { kind: _kind, dispatchId, sourcePersonId: _source, ...delivery } = effect;
+            insertScheduled(state, { id: dispatchId, at: event.at + state.messageTravel.minutes, personId: null, kind: 'deliver',
+                intent: `A message from ${state.people[effect.fromId].name}`.slice(0, 600), placeId: null, targetId: null, sourceSeq: event.seq, importance: event.importance, delivery });
+            return;
+        }
+        case 'request.open': {
+            requirePerson(state, effect.senderId);
+            requirePerson(state, effect.receiverId);
+            if (effect.senderId === effect.receiverId)
+                throw new LivingWorldError('effect-invalid', 'A request needs another recipient');
+            if (state.requests.some(request => request.id === effect.requestId))
+                throw new LivingWorldError('effect-invalid', `Request ${effect.requestId} already exists`);
+            state.requests.push({ id: effect.requestId, senderId: effect.senderId, receiverId: effect.receiverId,
+                topic: effect.topic, status: 'open', openedSeq: event.seq, ...(state.engine >= REQUEST_TIME_ENGINE ? { openedAt: event.at } : {}),
+                knownTo: [...new Set([effect.senderId, effect.receiverId, ...(event.perceivedBy ?? event.witnessIds)])] });
+            return;
+        }
+        case 'norm.violation': {
+            if (effect.actorId !== event.actorId || event.placeId === null)
+                throw new LivingWorldError('effect-invalid', 'Norm violation needs the actor and place');
+            const valid = normViolationsFor(state, effect.actorId, event.placeId, effect.actionKind)
+                .some(violation => violation.normEntityId === effect.normEntityId);
+            if (!valid)
+                throw new LivingWorldError('effect-invalid', `Norm ${effect.normEntityId} does not forbid ${effect.actionKind} here`);
+            return;
+        }
+        case 'stance': {
+            requirePerson(state, effect.personId);
+            requirePerson(state, effect.actorId);
+            if (effect.personId === effect.actorId || effect.personId === state.playerId)
+                throw new LivingWorldError('effect-invalid', 'A stance needs another character');
+            const existing = state.stances.find(stance => stance.personId === effect.personId && stance.actorId === effect.actorId);
+            // A standing already recorded from this source proves the witnessing, however old the event is.
+            if (existing?.sourceSeq !== effect.sourceSeq) {
+                const cause = state.events.find(item => item.seq === effect.sourceSeq);
+                if (!cause || cause.actorId !== effect.actorId || !(cause.perceivedBy ?? cause.witnessIds).includes(effect.personId)) {
+                    throw new LivingWorldError('effect-invalid', 'Stance needs a witnessed source event');
+                }
+            }
+            if (existing) {
+                existing.status = effect.status;
+                existing.sourceSeq = effect.sourceSeq;
+                existing.changedSeq = event.seq;
+            }
+            else
+                state.stances.push({ personId: effect.personId, actorId: effect.actorId, status: effect.status, sourceSeq: effect.sourceSeq, changedSeq: event.seq });
+            return;
+        }
+        case 'request.remind': {
+            if (state.engine < REMINDER_ENGINE)
+                throw new LivingWorldError('effect-invalid', 'This world keeps no reminders');
+            const request = state.requests.find(item => item.id === effect.requestId);
+            if (!request)
+                throw new LivingWorldError('effect-invalid', `Unknown request ${effect.requestId}`);
+            if (request.status !== 'open')
+                throw new LivingWorldError('effect-invalid', `Request ${effect.requestId} is already ${request.status}`);
+            if (event.actorId !== request.senderId)
+                throw new LivingWorldError('effect-invalid', `Only the one who asked in request ${effect.requestId} reminds of it`);
+            request.remindedAt = event.at;
+            return;
+        }
+        case 'request.update': {
+            const request = state.requests.find(item => item.id === effect.requestId);
+            if (!request)
+                throw new LivingWorldError('effect-invalid', `Unknown request ${effect.requestId}`);
+            if (request.status !== 'open')
+                throw new LivingWorldError('effect-invalid', `Request ${effect.requestId} is already ${request.status}`);
+            if (event.actorId !== request.receiverId && event.actorId !== request.senderId) {
+                throw new LivingWorldError('effect-invalid', `Only the people in request ${effect.requestId} can update it`);
+            }
+            request.status = effect.status;
+            if (effect.answer !== undefined)
+                request.answer = { text: effect.answer, seq: event.seq };
+            return;
+        }
+        case 'object.update': {
+            const object = state.objects[effect.objectId];
+            if (!object)
+                throw new LivingWorldError('effect-invalid', `Unknown object ${effect.objectId}`);
+            if (effect.placeId !== null)
+                requirePlace(state, effect.placeId);
+            if (effect.holderId !== null)
+                requirePerson(state, effect.holderId);
+            if (effect.ownerId !== null)
+                requirePerson(state, effect.ownerId);
+            if (effect.placeId !== null && effect.holderId !== null)
+                throw new LivingWorldError('effect-invalid', `${object.name} cannot be both placed and held`);
+            if (effect.placeId !== null || effect.holderId !== null) {
+                object.custodyKnownTo = observedObjectIds(event).includes(effect.objectId)
+                    ? [...new Set([...(event.perceivedBy ?? event.witnessIds), ...(event.actorId ? [event.actorId] : [])])]
+                    : event.actorId === state.playerId ? [state.playerId] : [];
+            }
+            if (effect.placeId !== null) {
+                object.placeId = effect.placeId;
+                object.holderId = null;
+            }
+            if (effect.holderId !== null) {
+                object.holderId = effect.holderId;
+                object.placeId = null;
+            }
+            if (effect.ownerId !== null)
+                object.ownerId = effect.ownerId;
+            if (effect.condition !== null) {
+                object.condition = state.engine >= CONDITION_SIDES_ENGINE ? withSide(object, effect.aspect, effect.condition, state.engine >= WHOLE_SIDES_ENGINE, state.engine >= SIDE_ORDER_ENGINE) : effect.condition;
+                object.conditionKnownTo = observedObjectIds(event).includes(effect.objectId)
+                    ? [...new Set([...(event.perceivedBy ?? event.witnessIds), ...(event.actorId ? [event.actorId] : [])])]
+                    : event.actorId === state.playerId ? [state.playerId] : [];
+            }
+            return;
+        }
+        case 'object.create': {
+            if (state.objects[effect.objectId])
+                throw new LivingWorldError('effect-invalid', `Object ${effect.objectId} already exists`);
+            if ((effect.placeId === null) === (effect.holderId === null))
+                throw new LivingWorldError('effect-invalid', `${effect.name} needs exactly one of a place or a holder`);
+            if (effect.placeId !== null)
+                requirePlace(state, effect.placeId);
+            if (effect.holderId !== null)
+                requirePerson(state, effect.holderId);
+            if (effect.ownerId !== null)
+                requirePerson(state, effect.ownerId);
+            state.objects[effect.objectId] = { id: effect.objectId, name: effect.name, summary: effect.summary, placeId: effect.placeId, holderId: effect.holderId, ownerId: effect.ownerId, condition: effect.condition, singlePersonMovable: true, introducedAt: event.seq,
+                custodyKnownTo: observedObjectIds(event).includes(effect.objectId) ? [...new Set([...(event.perceivedBy ?? event.witnessIds), ...(event.actorId ? [event.actorId] : [])])] : [],
+                conditionKnownTo: observedObjectIds(event).includes(effect.objectId) ? [...new Set([...(event.perceivedBy ?? event.witnessIds), ...(event.actorId ? [event.actorId] : [])])] : [] };
+            return;
+        }
+        case 'place.condition': {
+            const place = requirePlace(state, effect.placeId);
+            if (effect.aspect) {
+                const previous = place.conditionAspects[effect.aspect];
+                if (effect.add === null) {
+                    if (previous?.index !== undefined) {
+                        place.conditions.splice(previous.index, 1);
+                        for (const current of Object.values(place.conditionAspects))
+                            if (current.index !== undefined && current.index > previous.index)
+                                current.index -= 1;
+                    }
+                    delete place.conditionAspects[effect.aspect];
+                }
+                else {
+                    const index = previous?.index ?? place.conditions.length;
+                    if (previous?.index === undefined)
+                        place.conditions.push(effect.add);
+                    else
+                        place.conditions[index] = effect.add;
+                    place.conditionAspects[effect.aspect] = { text: effect.add, changedSeq: event.seq, index };
+                }
+                return;
+            }
+            if (effect.add !== null)
+                place.conditions.push(effect.add);
+            return;
+        }
+        case 'place.create': {
+            if (state.places[effect.placeId])
+                throw new LivingWorldError('effect-invalid', `Place ${effect.placeId} already exists`);
+            for (const connection of effect.connections)
+                requirePlace(state, connection);
+            state.places[effect.placeId] = { id: effect.placeId, name: effect.name, kind: 'room', summary: effect.summary, connections: [...effect.connections], conditions: [], conditionAspects: {}, introducedAt: event.seq };
+            for (const connection of effect.connections)
+                state.places[connection].connections.push(effect.placeId);
+            return;
+        }
+        case 'person.create': {
+            if (state.people[effect.personId])
+                throw new LivingWorldError('effect-invalid', `Person ${effect.personId} already exists`);
+            const namesake = state.engine >= IDENTITY_ENGINE ? Object.values(state.people).find(person => person.departed === undefined && person.name === effect.name) : undefined;
+            if (namesake)
+                throw new LivingWorldError('effect-invalid', `${effect.name} (${namesake.id}) is already in the story; tell the newcomer apart by a name of their own or by what anyone can see, such as a coat or a trade, not a number`);
+            requirePlace(state, effect.placeId);
+            state.people[effect.personId] = {
+                id: effect.personId, name: effect.name, role: effect.role, roleId: null, summary: effect.summary, persona: effect.persona, isPlayer: false,
+                ...(effect.pronouns ? { pronouns: effect.pronouns } : {}),
+                placeId: effect.placeId, money: null, mood: 'Arrived', goals: effect.wants === undefined ? [] : [{ id: generatedId(state.engine, 'goal', [effect.personId, 1], `${effect.personId}-goal-1`), text: effect.wants, status: 'active' }],
+                relationships: {},
+                beliefs: [], memories: [], commitments: [], plan: null, incapacitated: false,
+                ...(state.engine >= NEWCOMER_ENGINE ? { newcomer: true, arrivedAt: event.at } : {}),
+            };
+            if ((event.perceivedBy ?? event.witnessIds).includes(state.playerId) && effect.placeId === event.placeId)
+                state.sightings[effect.personId] = { placeId: effect.placeId, at: event.at };
+            if (state.engine < SEEN_AT_EVENTS_ENGINE)
+                seeWhatLiesHere(state, effect.personId, effect.placeId);
+            return;
+        }
+        case 'money': {
+            const person = requirePerson(state, effect.personId);
+            if (person.money === null)
+                throw new LivingWorldError('effect-invalid', `${person.name} keeps no money in this world`);
+            const next = person.money + effect.delta;
+            if (next < 0)
+                throw new LivingWorldError('effect-invalid', `${person.name} cannot spend more than they have`);
+            person.money = next;
+            return;
+        }
+        case 'transfer': {
+            if (effect.fromId === null && effect.toId === null)
+                throw new LivingWorldError('effect-invalid', 'A transfer needs someone who pays or someone who receives');
+            const unit = state.currency?.name ?? 'units';
+            const cents = (amount) => Math.round(amount * 100) / 100;
+            const from = effect.fromId === null ? null : purse(state, effect.fromId);
+            const to = effect.toId === null ? null : purse(state, effect.toId);
+            if (from !== null) {
+                const actor = event.actorId === null ? undefined : state.people[event.actorId];
+                // An account held by no one moves only by the world's own happenings; one held by someone, by them.
+                if (from.account && actor && from.account.holderId === null)
+                    throw new LivingWorldError('effect-invalid', `${from.name} is moved only by the world's own rules, such as a vote or a due happening`);
+                if (from.account && actor && from.account.holderId !== null && from.account.holderId !== actor.id)
+                    throw new LivingWorldError('effect-invalid', `Only ${state.people[from.account.holderId]?.name ?? from.account.holderId} moves money from ${from.name}`);
+                // Someone else's purse is reached only by someone beside them.
+                if (from.person && actor && actor.id !== from.person.id && actor.placeId !== from.person.placeId)
+                    throw new LivingWorldError('effect-invalid', `${actor.name} cannot reach ${from.name}'s money from here`);
+                if (!from.allowsDebt && from.balance() < effect.amount)
+                    throw new LivingWorldError('effect-invalid', `${from.name} holds ${from.balance()} ${unit}; ${effect.amount} is more than that`);
+                from.set(cents(from.balance() - effect.amount));
+            }
+            if (to !== null)
+                to.set(cents(to.balance() + effect.amount));
+            return;
+        }
+        case 'relationship': {
+            const person = requirePerson(state, effect.personId);
+            requirePerson(state, effect.targetId);
+            if (effect.personId === effect.targetId)
+                throw new LivingWorldError('effect-invalid', 'A relationship needs two people');
+            const current = person.relationships[effect.targetId] ?? { trust: 0, warmth: 0, note: '' };
+            person.relationships[effect.targetId] = {
+                trust: clamp(current.trust + effect.trust), warmth: clamp(current.warmth + effect.warmth),
+                note: effect.note === '' ? current.note : effect.note, changedSeq: event.seq,
+            };
+            return;
+        }
+        case 'belief': {
+            const person = requirePerson(state, effect.personId);
+            const evidence = effect.evidence;
+            const sourceEvent = evidence?.eventSeq === event.seq ? event : state.events.find(candidate => candidate.seq === evidence?.eventSeq);
+            // Messages outlive the recent event window, so a message stays citable after its event scrolls out.
+            const message = !sourceEvent && evidence?.kind === 'told' ? state.messages.find(candidate => candidate.eventSeq === evidence.eventSeq
+                && candidate.fromId === evidence.sourceId && candidate.toIds.includes(person.id)) : undefined;
+            if (evidence && !sourceEvent && !message)
+                throw new LivingWorldError('effect-invalid', 'A belief must cite a recorded event');
+            if (evidence?.kind === 'observed' && !((sourceEvent.perceivedBy ?? sourceEvent.witnessIds).includes(person.id))) {
+                throw new LivingWorldError('effect-invalid', `${person.name} did not observe the cited event`);
+            }
+            if ((evidence?.kind === 'told' || evidence?.kind === 'heard') && !message) {
+                const speaker = evidence.sourceId;
+                if (!speaker || !sourceEvent.effects.some(item => item.kind === 'message' && item.fromId === speaker && item.toIds.includes(person.id)
+                    || item.kind === 'say' && item.personId === speaker && sourceEvent.witnessIds.includes(person.id)
+                        && (item.toIds.length === 0 || item.toIds.includes(person.id)))) {
+                    throw new LivingWorldError('effect-invalid', `${person.name} was not told by the cited speaker`);
+                }
+            }
+            const index = person.beliefs.length + 1;
+            person.beliefs.push({
+                id: generatedId(state.engine, 'belief', [person.id, event.seq, index], `${person.id}-belief-${event.seq}-${index}`), subject: effect.subject, claim: effect.claim,
+                source: { kind: evidence?.kind === 'observed' ? 'witnessed' : evidence?.kind === 'told' || evidence?.kind === 'heard' ? 'told' : 'inferred',
+                    personId: evidence?.kind === 'told' || evidence?.kind === 'heard' ? evidence.sourceId : null, eventSeq: evidence?.eventSeq ?? event.seq },
+                at: event.at,
+            });
+            return;
+        }
+        case 'commitment': {
+            const person = requirePerson(state, effect.personId);
+            requirePerson(state, effect.toId);
+            if (replay && !replay.has(person.id))
+                replay.set(person.id, new Map(person.commitments.map(item => [item.id, item])));
+            const index = replay?.get(person.id);
+            if (index ? index.has(effect.commitmentId) : person.commitments.some(commitment => commitment.id === effect.commitmentId))
+                throw new LivingWorldError('effect-invalid', `Commitment ${effect.commitmentId} already exists`);
+            if (state.engine >= BOUNDED_PERSON_RECORDS_ENGINE && person.commitments.filter(item => item.status === 'open').length >= MAX_OPEN_COMMITMENTS) {
+                throw new LivingWorldError('effect-invalid', `${person.name} already has ${MAX_OPEN_COMMITMENTS} open promises; settle one before adding another`);
+            }
+            // Those who perceived the event heard the promise; a message in the same event carries it to its recipients.
+            const heard = [...(event.perceivedBy ?? event.witnessIds), effect.personId,
+                ...event.effects.flatMap(item => item.kind === 'message' ? item.toIds : [])];
+            const dueAt = effect.dueInMinutes === null ? null : event.at + effect.dueInMinutes;
+            if (effect.placeId !== undefined)
+                requirePlace(state, effect.placeId);
+            person.commitments.push({ id: effect.commitmentId, toId: effect.toId, text: effect.text, dueAt, ...(effect.placeId === undefined ? {} : { placeId: effect.placeId }), status: 'open', madeAt: event.at,
+                madeSeq: event.seq, knownTo: [...new Set(heard)].sort() });
+            index?.set(effect.commitmentId, person.commitments[person.commitments.length - 1]);
+            // A promise to be somewhere at a time becomes a decision the promiser must make in time to get there,
+            // one no routine plan puts aside.
+            if (state.engine >= DEADLINE_ENGINE && dueAt !== null && effect.placeId !== undefined && !person.isPlayer) {
+                insertScheduled(state, { id: generatedId(state.engine, 'keep', [effect.commitmentId]), at: Math.max(event.at + 1, dueAt - PROMISE_LEAD_MINUTES), personId: person.id, kind: 'plan',
+                    intent: `Keep your promise to ${state.people[effect.toId].name}: ${effect.text}`.slice(0, MAX_LINE), placeId: effect.placeId, targetId: effect.toId, sourceSeq: event.seq, importance: PROMISE_IMPORTANCE });
+            }
+            return;
+        }
+        case 'commitment.update': {
+            const person = requirePerson(state, effect.personId);
+            const commitment = replay ? replay.get(person.id)?.get(effect.commitmentId) : person.commitments.find(candidate => candidate.id === effect.commitmentId);
+            if (!commitment)
+                throw new LivingWorldError('effect-invalid', `Unknown commitment ${effect.commitmentId}`);
+            if (commitment.status !== 'open')
+                throw new LivingWorldError('effect-invalid', `Commitment ${effect.commitmentId} is already ${commitment.status}`);
+            commitment.status = effect.status;
+            return;
+        }
+        case 'goal': {
+            const person = requirePerson(state, effect.personId);
+            if (effect.dropGoalId !== null) {
+                const goal = person.goals.find(candidate => candidate.id === effect.dropGoalId);
+                if (!goal)
+                    throw new LivingWorldError('effect-invalid', `Unknown goal ${effect.dropGoalId}`);
+                goal.status = 'dropped';
+            }
+            if (effect.doneGoalId !== undefined && effect.doneGoalId !== null) {
+                const goal = person.goals.find(candidate => candidate.id === effect.doneGoalId);
+                if (!goal)
+                    throw new LivingWorldError('effect-invalid', `Unknown goal ${effect.doneGoalId}`);
+                goal.status = 'done';
+            }
+            if (effect.add !== null)
+                person.goals.push({ id: generatedId(state.engine, 'goal', [person.id, event.seq, person.goals.length + 1], `${person.id}-goal-${event.seq}-${person.goals.length + 1}`), text: effect.add, status: 'active' });
+            return;
+        }
+        case 'mood': {
+            requirePerson(state, effect.personId).mood = effect.mood;
+            return;
+        }
+        case 'hold': {
+            const person = requirePerson(state, effect.personId);
+            if (effect.byId !== null)
+                requirePerson(state, effect.byId);
+            if (effect.reason === null)
+                delete person.held;
+            else
+                person.held = { byId: effect.byId, reason: effect.reason };
+            return;
+        }
+        case 'role': {
+            const person = requirePerson(state, effect.personId);
+            person.role = effect.role;
+            person.roleId = effect.roleId;
+            return;
+        }
+        case 'person.condition': {
+            const person = requirePerson(state, effect.personId);
+            if (effect.condition === null)
+                delete person.condition;
+            else
+                person.condition = effect.condition;
+            person.conditionChangedSeq = event.seq;
+            return;
+        }
+        case 'schedule': {
+            if (effect.personId !== null)
+                requirePerson(state, effect.personId);
+            if (effect.placeId !== null)
+                requirePlace(state, effect.placeId);
+            // A world happening may concern anything the world holds, such as the expiry a ruling just made;
+            // every other item concerns a person.
+            if (effect.targetId !== null && effect.scheduleKind === 'world')
+                requireKnown(state, effect.targetId);
+            else if (effect.targetId !== null)
+                requirePerson(state, effect.targetId);
+            if (state.schedule.some(item => item.id === effect.scheduledId))
+                throw new LivingWorldError('effect-invalid', `Scheduled item ${effect.scheduledId} already exists`);
+            if (effect.scheduleKind === 'deliver')
+                throw new LivingWorldError('effect-invalid', 'A delivery comes only from a dispatched message');
+            if (effect.scheduleKind === 'back')
+                throw new LivingWorldError('effect-invalid', 'A return comes only from someone going away');
+            if (effect.scheduleKind === 'count')
+                throw new LivingWorldError('effect-invalid', 'A vote opens and is counted only at its own written times');
+            if (effect.scheduleKind === 'finish' && (effect.targetId === null || effect.placeId === null || effect.held === undefined))
+                throw new LivingWorldError('effect-invalid', 'A long act ends for its actor where it began, as it was ruled');
+            // Someone away answers a message once they are back; from engine 49, only one asleep at night waits.
+            const away = effect.personId !== null && effect.scheduleKind === 'reply' ? state.people[effect.personId].away : undefined;
+            const waits = away !== undefined && (state.engine < AWAY_REPLY_ENGINE || isNight(event.at + effect.inMinutes));
+            insertScheduled(state, { id: effect.scheduledId, at: Math.max(event.at + effect.inMinutes, waits ? away.until : 0), personId: effect.personId, kind: effect.scheduleKind, intent: effect.intent, placeId: effect.placeId, targetId: effect.targetId, sourceSeq: event.seq, importance: effect.importance ?? event.importance,
+                ...(effect.everyMinutes === undefined ? {} : { everyMinutes: effect.everyMinutes }), ...(effect.series === undefined ? {} : { series: effect.series }),
+                ...(effect.beat === undefined ? {} : { beat: effect.beat }),
+                ...(state.engine >= BOUNDED_IDENTIFIERS_ENGINE && effect.replanned ? { replanned: true } : {}),
+                ...(effect.held === undefined ? {} : { held: { at: event.at, ...effect.held } }) });
+            return;
+        }
+        case 'deadline.passed': {
+            state.passedDeadlines = [...(state.passedDeadlines ?? []), { what: effect.what, at: event.at, outcome: effect.outcome,
+                    ...(effect.averted && state.engine >= AVERTED_ENGINE ? { averted: true } : {}) }].slice(-8);
+            return;
+        }
+        case 'unschedule': {
+            const index = state.schedule.findIndex(item => item.id === effect.scheduledId);
+            const predicted = index === -1 ? plain(state.meterSchedule).findIndex(item => item.id === effect.scheduledId) : -1;
+            if (index === -1 && predicted === -1)
+                throw new LivingWorldError('effect-invalid', `Unknown scheduled item ${effect.scheduledId}`);
+            if (index !== -1)
+                state.schedule.splice(index, 1);
+            else
+                state.meterSchedule = plain(state.meterSchedule).filter((_, index) => index !== predicted);
+            return;
+        }
+        case 'plan': {
+            const person = requirePerson(state, effect.personId);
+            if (effect.plan?.placeId)
+                requirePlace(state, effect.plan.placeId);
+            if (effect.plan?.targetId)
+                requirePerson(state, effect.plan.targetId);
+            person.plan = effect.plan;
+            // What someone has been doing lately stays in view when they decide again.
+            if (effect.plan && state.engine >= CHRONICLE_ENGINE)
+                person.planHistory = [...(person.planHistory ?? []), { at: event.at, intent: effect.plan.intent }].slice(-6);
+            return;
+        }
+        case 'fact': {
+            if (effect.aspect) {
+                const previous = state.factAspects[effect.aspect];
+                if (effect.add === null) {
+                    if (previous?.index !== undefined) {
+                        state.facts.splice(previous.index, 1);
+                        for (const current of Object.values(state.factAspects))
+                            if (current.index !== undefined && current.index > previous.index)
+                                current.index -= 1;
+                    }
+                    delete state.factAspects[effect.aspect];
+                }
+                else {
+                    const index = previous?.index ?? state.facts.length;
+                    if (previous?.index === undefined)
+                        state.facts.push(effect.add);
+                    else
+                        state.facts[index] = effect.add;
+                    state.factAspects[effect.aspect] = { text: effect.add, changedSeq: event.seq, index };
+                }
+                return;
+            }
+            if (effect.add !== null)
+                state.facts.push(effect.add);
+            return;
+        }
+        case 'tension.create': {
+            if (state.tensions.some(tension => tension.id === effect.tensionId))
+                throw new LivingWorldError('effect-invalid', `Tension ${effect.tensionId} already exists`);
+            for (const participant of effect.participantIds)
+                requirePerson(state, participant);
+            const playerCanSee = (event.perceivedBy ?? event.witnessIds).includes(state.playerId)
+                && (event.visibleTensionIds ?? (event.observed === undefined ? [effect.tensionId] : [])).includes(effect.tensionId);
+            const modern = state.engine >= PROBLEM_VIEW_ENGINE;
+            state.tensions.push({ id: effect.tensionId, title: effect.title, summary: effect.summary, participantIds: [...effect.participantIds], status: 'open', resolution: null, changedAt: event.at,
+                ...(effect.openedBy === undefined ? {} : { openedBy: effect.openedBy }),
+                playerView: playerCanSee && !modern ? { title: effect.title.slice(0, 200), summary: event.observed ?? effect.summary, status: 'open', resolution: null, latest: null } : null });
+            if (playerCanSee && modern)
+                seeTension(state, state.tensions.at(-1), event, 'created');
+            return;
+        }
+        case 'tension.update': {
+            const tension = state.tensions.find(candidate => candidate.id === effect.tensionId);
+            if (!tension)
+                throw new LivingWorldError('effect-invalid', `Unknown tension ${effect.tensionId}`);
+            const settling = tension.status === 'open' && effect.status === 'settled';
+            tension.status = effect.status;
+            tension.changedAt = event.at;
+            if (effect.note !== null) {
+                if (effect.status === 'settled')
+                    tension.resolution = effect.note;
+                else
+                    tension.summary = effect.note;
+            }
+            if (settling)
+                state.stoppingPoint = { at: event.at, tensionId: tension.id, title: tension.title, summary: tension.resolution ?? tension.summary };
+            if ((event.perceivedBy ?? event.witnessIds).includes(state.playerId)
+                && (event.visibleTensionIds ?? (event.observed === undefined ? [effect.tensionId] : [])).includes(effect.tensionId)) {
+                if (state.engine >= PROBLEM_VIEW_ENGINE) {
+                    seeTension(state, tension, event, 'changed');
+                    return;
+                }
+                tension.playerView = { title: tension.playerView?.title ?? tension.title.slice(0, 200),
+                    summary: tension.playerView?.summary ?? event.observed ?? tension.summary, status: tension.status,
+                    resolution: tension.status === 'settled' ? event.observed ?? tension.resolution : null,
+                    latest: tension.playerView ? event.observed ?? effect.note : null };
+            }
+            return;
+        }
+        case 'memory': {
+            const person = requirePerson(state, effect.personId);
+            for (const participant of effect.participantIds)
+                requirePerson(state, participant);
+            addMemory(state, person.id, event, effect.text, effect.importance, effect.participantIds);
+            return;
+        }
+        case 'incapacitate': {
+            const person = requirePerson(state, effect.personId);
+            person.incapacitated = true;
+            // A typed cause is remembered, so the person recovers when that cause no longer stops them.
+            const cause = blockedByGate(state, person.id, 'incapacitate');
+            if (cause !== null)
+                person.incapacitatedBy = cause;
+            if (person.id === state.playerId)
+                state.forcedEnding = effect.reason;
+            return;
+        }
+        case 'person.away': {
+            const person = requirePerson(state, effect.personId);
+            if (person.isPlayer)
+                throw new LivingWorldError('effect-invalid', 'The player decides where they go');
+            if (person.departed || person.away)
+                throw new LivingWorldError('effect-invalid', `${person.name} is not here to leave`);
+            if (person.incapacitated)
+                throw new LivingWorldError('effect-invalid', `${person.name} cannot leave while unable to act`);
+            if (heldHere(state, person.id))
+                throw new LivingWorldError('effect-invalid', `${person.name} is kept here and cannot leave`);
+            const gate = gatesAgainst(state, person.id, 'move')[0];
+            if (gate)
+                throw new LivingWorldError('effect-invalid', `${gate.name} (${gate.entityId}) holds ${person.name}; to free them, set its ${gate.propertyId} first in the same ruling, or keep them here`);
+            const until = event.at + effect.minutes;
+            person.away = { at: event.at, until, reason: effect.reason };
+            person.plan = { intent: effect.reason, placeId: null, targetId: null, dueAt: until };
+            leaveConversations(state, person.id, person.placeId, event.at);
+            // What they meant to do here waits; messages to them are answered when they are back.
+            // From engine 42 a long act under way is set aside too.
+            state.schedule = state.schedule.filter(item => (item.personId !== person.id || item.kind === 'reply')
+                && !(state.engine >= AWAY_APART_ENGINE && item.kind === 'finish' && item.targetId === person.id))
+                .map(item => item.personId === person.id && item.at < until
+                && !(state.engine >= AWAY_REPLY_ENGINE && item.kind === 'reply' && !isNight(item.at)) ? { ...item, at: until } : item)
+                .sort((left, right) => left.at - right.at || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+            insertScheduled(state, { id: generatedId(state.engine, 'back', [event.seq, person.id], `back-${event.seq}-${person.id}`.slice(0, 64)), at: until, personId: person.id, kind: 'back', intent: effect.reason,
+                placeId: person.placeId, targetId: null, sourceSeq: event.seq, importance: 3 });
+            // Seen going, they are known to have left for a while.
+            if (event.witnessIds.includes(state.playerId) || event.perceivedBy?.includes(state.playerId))
+                state.sightings[person.id] = { placeId: person.placeId, at: event.at, away: true };
+            return;
+        }
+        case 'person.back': {
+            const person = requirePerson(state, effect.personId);
+            if (!person.away)
+                throw new LivingWorldError('effect-invalid', `${person.name} is not away`);
+            delete person.away;
+            person.arrivedSeq = event.seq;
+            if (state.engine < SEEN_AT_EVENTS_ENGINE)
+                seeWhatLiesHere(state, person.id, person.placeId);
+            if (state.engine >= REST_ENGINE)
+                person.restedAt = event.at;
+            if (state.people[state.playerId].placeId === person.placeId)
+                state.sightings[person.id] = { placeId: person.placeId, at: event.at };
+            return;
+        }
+        case 'person.leave': {
+            const person = requirePerson(state, effect.personId);
+            if (person.isPlayer)
+                throw new LivingWorldError('effect-invalid', 'The player decides when their own story ends');
+            if (person.departed)
+                throw new LivingWorldError('effect-invalid', `${person.name} has already left`);
+            person.departed = { at: event.at, reason: effect.reason };
+            person.plan = null;
+            leaveConversations(state, person.id, person.placeId, event.at);
+            // What they meant to do here goes with them.
+            state.schedule = state.schedule.filter(item => item.personId !== person.id);
+            return;
+        }
+        case 'conversation.end': {
+            const conversation = state.conversations.find(candidate => candidate.id === effect.conversationId);
+            if (!conversation)
+                throw new LivingWorldError('effect-invalid', `Unknown conversation ${effect.conversationId}`);
+            if (conversation.endedAt === null)
+                conversation.endedAt = event.at;
+            return;
+        }
+        case 'kind.define': {
+            const definition = effect.definition;
+            if (state.kinds[definition.id])
+                throw new LivingWorldError('effect-invalid', `Kind ${definition.id} already exists`);
+            if (event.kind !== 'opening' && definition.mechanics.some(mechanic => mechanic.kind === 'signal' && mechanic.channel === GLOBAL_SIGNAL_CHANNEL)) {
+                throw new LivingWorldError('effect-invalid', `Only the world's own data may define what reaches everyone, as ${definition.id} would`);
+            }
+            const propertyIds = new Set(definition.properties.map(property => property.id));
+            const relationIds = new Set(definition.relations.map(relation => relation.id));
+            if (propertyIds.size !== definition.properties.length || relationIds.size !== definition.relations.length) {
+                throw new LivingWorldError('effect-invalid', `Kind ${definition.id} repeats a slot id`);
+            }
+            for (const relation of definition.relations) {
+                if (relation.targetKindId !== definition.id && !state.kinds[relation.targetKindId]) {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} refers to unknown target kind ${relation.targetKindId}`);
+                }
+            }
+            for (const mechanic of definition.mechanics) {
+                if ('propertyId' in mechanic && mechanic.propertyId !== null && !propertyIds.has(mechanic.propertyId)) {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} has unknown property ${mechanic.propertyId}`);
+                }
+                if ('relationId' in mechanic && mechanic.relationId !== null && !relationIds.has(mechanic.relationId)) {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} has unknown relation ${mechanic.relationId}`);
+                }
+                if (mechanic.kind === 'spread' && definition.properties.find(property => property.id === mechanic.propertyId)?.type !== 'level') {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} spreads a property that is not a level`);
+                }
+                if (mechanic.kind === 'authority' && (mechanic.propertyId === null) === (mechanic.relationId === null)) {
+                    throw new LivingWorldError('effect-invalid', 'Authority needs exactly one property or relation');
+                }
+                const targetProperty = 'propertyId' in mechanic ? definition.properties.find(property => property.id === mechanic.propertyId) : undefined;
+                if ((mechanic.kind === 'change' && (mechanic.onEvent
+                    ? mechanic.deltaPerMinute !== 0 || !targetProperty || !valueMatchesType(targetProperty.type, mechanic.onEvent.value)
+                    : targetProperty?.type !== 'number'))
+                    || mechanic.kind === 'trigger' && targetProperty?.type !== 'number') {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} changes a property that is not a number`);
+                }
+                if (mechanic.kind === 'change' && mechanic.onEvent
+                    && definition.properties.find(property => property.id === mechanic.onEvent.subjectPropertyId)?.type !== 'id') {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} needs an id subject property for event change`);
+                }
+                if (mechanic.kind === 'gate' && definition.properties.find(property => property.id === mechanic.subjectPropertyId)?.type !== 'id') {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} needs an id subject property for its gate`);
+                }
+                if (mechanic.kind === 'gate' && mechanic.atLeast !== undefined && targetProperty?.type !== 'level') {
+                    throw new LivingWorldError('effect-invalid', `Kind ${definition.id} needs a level property for a level gate`);
+                }
+            }
+            state.kinds[definition.id] = definition;
+            state.kindRequests = state.kindRequests.filter(request => request.id !== definition.id);
+            return;
+        }
+        case 'kind.request': {
+            if (state.kinds[effect.request.id])
+                return;
+            // A request is known by its id; asking again in other words is the same pending request.
+            if (!state.kindRequests.some(request => request.id === effect.request.id))
+                state.kindRequests.push(effect.request);
+            return;
+        }
+        case 'entity.create': {
+            if (!state.kinds[effect.kindId])
+                throw new LivingWorldError('effect-invalid', `Unknown kind ${effect.kindId}`);
+            if (effect.placeId !== null)
+                requirePlace(state, effect.placeId);
+            if (state.entities[effect.entityId] || state.people[effect.entityId] || state.places[effect.entityId] || state.objects[effect.entityId]) {
+                throw new LivingWorldError('effect-invalid', `Entity ${effect.entityId} already exists`);
+            }
+            if ((effect.condition !== undefined || effect.holderId !== undefined) && effect.placeId === null) {
+                throw new LivingWorldError('effect-invalid', `${effect.name} belongs to no place, so it has no condition and no one holds it`);
+            }
+            if (effect.holderId !== undefined && state.engine >= UNHELD_ENGINE && neverHeld(state.engine, effect.kindId, state.kinds[effect.kindId])) {
+                throw new LivingWorldError('effect-invalid', `${effect.name} stays where it is; no one holds it`);
+            }
+            if (effect.holderId !== undefined) {
+                const holder = requirePerson(state, effect.holderId);
+                if (holder.departed || holder.away || holder.placeId !== effect.placeId)
+                    throw new LivingWorldError('effect-invalid', `${holder.name} is not in ${state.places[effect.placeId]?.name ?? effect.placeId} to hold ${effect.name}`);
+            }
+            const deciding = effect.kindId === 'decision' && state.engine >= VOTES_ENGINE;
+            if ((effect.memberIds !== undefined || effect.settles !== undefined || effect.transfers !== undefined) && !deciding)
+                throw new LivingWorldError('effect-invalid', `Only a decision has members and settles a problem`);
+            if (deciding) {
+                if (effect.placeId === null)
+                    throw new LivingWorldError('effect-invalid', `${effect.name} needs the place where it is voted on`);
+                if (!effect.memberIds?.length)
+                    throw new LivingWorldError('effect-invalid', `${effect.name} needs the members who vote on it`);
+                for (const memberId of effect.memberIds)
+                    requirePerson(state, memberId);
+                if (effect.settles !== undefined && !state.tensions.some(tension => tension.id === effect.settles))
+                    throw new LivingWorldError('effect-invalid', `Unknown problem ${effect.settles}`);
+                // A vote called during play goes to the one already open in its room; a world's own data may hold several.
+                const open = state.engine >= OPEN_NOW_ENGINE && event.kind !== 'opening'
+                    ? (state.openDecisionIds ?? []).map(id => state.entities[id]).find(other => other?.placeId === effect.placeId) : undefined;
+                if (open)
+                    throw new LivingWorldError('effect-invalid', `${open.name} is already open to votes here; cast votes on it, not on a new one`);
+            }
+            // A world's data may say who knows one of its things; they, its holder and its members do.
+            if ((effect.knownTo !== undefined || effect.hidden) && !opening)
+                throw new LivingWorldError('effect-invalid', 'Only a world\'s opening says who knows a thing, or hides it');
+            for (const knower of effect.knownTo ?? [])
+                requirePerson(state, knower);
+            const knowers = effect.knownTo === undefined ? knownTo
+                : [...new Set([...effect.knownTo, ...(effect.holderId === undefined ? [] : [effect.holderId]), ...(effect.memberIds ?? [])])].sort();
+            state.entities[effect.entityId] = { id: effect.entityId, kindId: effect.kindId, name: effect.name, placeId: effect.placeId, holderId: effect.holderId ?? null,
+                condition: effect.condition ?? null, properties: {}, relations: {}, introducedSeq: event.seq, knownTo: knowers, ...(effect.hidden ? { hidden: true } : {}),
+                ...(deciding ? { members: [...new Set(effect.memberIds)], ballots: {}, ...(effect.settles === undefined ? {} : { settles: effect.settles }),
+                    ...(effect.transfers === undefined ? {} : { transfers: effect.transfers }) } : {}) };
+            if (deciding) {
+                state.entities[effect.entityId].condition = withSide(state.entities[effect.entityId], 'votes', tally(state.entities[effect.entityId]), state.engine >= WHOLE_SIDES_ENGINE, state.engine >= SIDE_ORDER_ENGINE);
+                state.openDecisionIds = [...(state.openDecisionIds ?? []), effect.entityId];
+            }
+            if (effect.placeId === null)
+                state.globalEntityIds.push(effect.entityId);
+            else
+                (state.entityPlaceIds[effect.placeId] ??= []).push(effect.entityId);
+            indexPlaceless(state, effect.entityId);
+            // A paper made sealed is sealed after its words are written.
+            for (const [propertyId, value] of Object.entries(effect.initialProperties ?? {}).sort(([left], [right]) => Number(left === 'sealed') - Number(right === 'sealed'))) {
+                applyEffect(state, event, { kind: 'property.set', entityId: effect.entityId, propertyId, value });
+            }
+            // From engine 50 a vote called during play without a closing time closes two game hours after it opens.
+            const called = deciding && event.kind !== 'opening' ? readEntity(state, effect.entityId) : undefined;
+            if (called && state.engine >= VOTE_CLOSES_ENGINE && called.properties['closes-at'] === undefined) {
+                const opensAt = called.properties['opens-at']?.value;
+                applyEffect(state, event, { kind: 'property.set', entityId: effect.entityId, propertyId: 'closes-at',
+                    value: (typeof opensAt === 'number' && opensAt > event.at ? opensAt : event.at) + VOTE_OPEN_MINUTES });
+            }
+            // A vote called during play with no later opening time opens now, so each member gets a turn at once.
+            if (deciding && state.engine >= OPEN_NOW_ENGINE && event.kind !== 'opening'
+                && !state.schedule.some(item => item.count?.entityId === effect.entityId && item.count.opens)) {
+                insertScheduled(state, { id: generatedId(state.engine, 'opens', [event.seq, effect.entityId], `opens-${event.seq}-${effect.entityId}`.slice(0, 64)), at: event.at, personId: null, kind: 'count',
+                    intent: `Voting opens on ${effect.name}`.slice(0, MAX_LINE), placeId: effect.placeId, targetId: null, sourceSeq: event.seq, importance: 5,
+                    count: { entityId: effect.entityId, opens: true } });
+            }
+            return;
+        }
+        case 'entity.move': {
+            const entity = state.entities[effect.entityId];
+            if (!entity)
+                throw new LivingWorldError('effect-invalid', `Unknown entity ${effect.entityId}`);
+            if (entity.placeId === null)
+                throw new LivingWorldError('effect-invalid', `${entity.name} is nowhere to be held; only a thing that is somewhere can change hands`);
+            if ((effect.holderId === null) === (effect.placeId === null))
+                throw new LivingWorldError('effect-invalid', `${entity.name} goes either to a holder or to a place`);
+            const at = state.places[entity.placeId]?.name ?? entity.placeId;
+            if (effect.holderId !== null && state.engine >= UNHELD_ENGINE && neverHeld(state.engine, entity.kindId, state.kinds[entity.kindId])) {
+                throw new LivingWorldError('effect-invalid', `${entity.name} stays where it is; no one holds it`);
+            }
+            if (effect.holderId !== null) {
+                const holder = requirePerson(state, effect.holderId);
+                if (holder.departed || holder.away || holder.placeId !== entity.placeId) {
+                    throw new LivingWorldError('effect-invalid', `${entity.name} is in ${at}, not with ${holder.name}`);
+                }
+            }
+            if (effect.placeId !== null && effect.placeId !== entity.placeId)
+                throw new LivingWorldError('effect-invalid', `${entity.name} can only be set down in ${at}, where it is`);
+            entity.holderId = effect.holderId;
+            entity.knownTo = [...new Set([...entity.knownTo, ...(event.perceivedBy ?? event.witnessIds), ...(event.actorId ? [event.actorId] : [])])];
+            return;
+        }
+        case 'entity.condition': {
+            const entity = state.entities[effect.entityId];
+            if (!entity)
+                throw new LivingWorldError('effect-invalid', `Unknown entity ${effect.entityId}`);
+            if (entity.placeId === null)
+                throw new LivingWorldError('effect-invalid', `${entity.name} is nowhere to be seen; only a thing that is somewhere shows a condition`);
+            if (entity.kindId === 'decision' && state.engine >= COUNT_ONLY_ENGINE) {
+                throw new LivingWorldError('effect-invalid', `The count on ${entity.name} is the engine's; a member casts a ballot, and the vote closes at its time or with decision.close`);
+            }
+            entity.condition = state.engine >= CONDITION_SIDES_ENGINE ? withSide(entity, effect.aspect, effect.condition, state.engine >= WHOLE_SIDES_ENGINE, state.engine >= SIDE_ORDER_ENGINE) : effect.condition;
+            entity.knownTo = [...new Set([...entity.knownTo, ...(event.perceivedBy ?? event.witnessIds), ...(event.actorId ? [event.actorId] : [])])];
+            return;
+        }
+        case 'property.set': {
+            const entity = state.entities[effect.entityId];
+            if (!entity)
+                throw new LivingWorldError('effect-invalid', `Unknown entity ${effect.entityId}`);
+            const definition = state.kinds[entity.kindId];
+            const property = definition.properties.find(slot => slot.id === effect.propertyId);
+            if (!property)
+                throw new LivingWorldError('effect-invalid', `Unknown property ${effect.propertyId}`);
+            const authority = definition.mechanics.filter((mechanic) => mechanic.kind === 'authority' && mechanic.propertyId === effect.propertyId);
+            if (event.actorId !== null && authority.length > 0 && !authority.some(mechanic => state.people[event.actorId]?.roleId === mechanic.roleId)) {
+                throw new LivingWorldError('effect-invalid', `Changing ${effect.propertyId} needs authority role ${authority.map(mechanic => mechanic.roleId).join(' or ')}`);
+            }
+            if (effect.value !== null && !valueMatchesType(property.type, effect.value)) {
+                throw new LivingWorldError('effect-invalid', `Property ${effect.propertyId} needs a ${property.type} value`);
+            }
+            if (effect.value !== null && property.type === 'id' && !readEntity(state, String(effect.value))
+                && !state.people[String(effect.value)] && !state.places[String(effect.value)] && !state.objects[String(effect.value)]) {
+                throw new LivingWorldError('effect-invalid', `Property ${effect.propertyId} refers to an unknown entity`);
+            }
+            // A decision's terms are fixed once anyone has voted on it.
+            if (entity.members !== undefined && (Object.keys(entity.ballots ?? {}).length > 0 || entity.result !== undefined)) {
+                throw new LivingWorldError('effect-invalid', `${entity.name} is being voted on; its terms no longer change`);
+            }
+            if (effect.propertyId !== 'sealed' && sealedPaper(state.engine, entity)) {
+                throw new LivingWorldError('effect-invalid', `${entity.name} is sealed; open it first, by setting sealed to false`);
+            }
+            if (effect.value !== null && namesPerson(state.engine, entity.kindId, effect.propertyId) && !state.people[String(effect.value)]) {
+                throw new LivingWorldError('effect-invalid', `The ${effect.propertyId} of ${definition.name} ${entity.name} names a person, and ${String(effect.value)} is not one`);
+            }
+            if (effect.value !== null && oneEachSlot(state.engine, entity.kindId) === effect.propertyId) {
+                const other = Object.values(state.entities).find(candidate => candidate.id !== entity.id && candidate.kindId === entity.kindId
+                    && candidate.properties[effect.propertyId]?.value === effect.value);
+                if (other)
+                    throw new LivingWorldError('effect-invalid', `${state.people[String(effect.value)]?.name ?? effect.value} already has ${definition.name} ${other.name}: change that one instead`);
+            }
+            const previousSeq = entity.properties[effect.propertyId]?.changedSeq ?? null;
+            const previousValue = state.engine < LAZY_METER_ENGINE ? entity.properties[effect.propertyId]?.value : currentValue(state, entity, effect.propertyId, event.at);
+            if (state.engine >= LAZY_METER_ENGINE)
+                keepPassedCrossings(state, entity.id, effect.propertyId, event.at);
+            for (const mechanic of definition.mechanics) {
+                if (mechanic.kind !== 'change' || mechanic.onEvent?.subjectPropertyId !== effect.propertyId)
+                    continue;
+                if (typeof previousValue === 'string')
+                    state.entityMoveSubjectIds[previousValue] =
+                        (state.entityMoveSubjectIds[previousValue] ?? []).filter(id => id !== entity.id);
+                if (typeof effect.value === 'string')
+                    (state.entityMoveSubjectIds[effect.value] ??= []).push(entity.id);
+            }
+            const previousRefs = property.type === 'id' && entity.placeId === null ? entityRefs(state.kinds, entity) : null;
+            // Before engine 45, writing on a paper adds to what it holds, marked with when and by whom.
+            const written = entity.properties[effect.propertyId]?.value;
+            const wholeText = state.engine >= WHOLE_TEXT_ENGINE;
+            if (!wholeText && state.engine >= ADDED_LINE_ENGINE && property.type === 'text' && typeof effect.value === 'string' && typeof written === 'string' && written !== ''
+                && effect.value.length > MAX_ADDED_LINE) {
+                throw new LivingWorldError('effect-invalid', `Add only the words written now, at most ${MAX_ADDED_LINE} characters, to ${entity.name}; what is already written stays on it`);
+            }
+            // The whole text as it now reads replaces the old; one that drops most of a long text is no rewrite of it.
+            if (wholeText && property.type === 'text' && typeof effect.value === 'string' && typeof written === 'string' && written.length > MAX_ADDED_LINE
+                && effect.value.length * 2 < written.length) {
+                throw new LivingWorldError('effect-invalid', `Write the whole text of ${entity.name} as it now reads, with the change; to erase it, set it to null`);
+            }
+            const stored = !wholeText && state.engine >= WRITING_GROWS_ENGINE && property.type === 'text' && typeof effect.value === 'string' && typeof written === 'string' && written !== ''
+                ? addWriting(written, `[${clockLabel(event.at)}${event.actorId && state.people[event.actorId] ? `, ${state.people[event.actorId].name}` : ''}] ${effect.value}`)
+                : effect.value;
+            if (effect.propertyId === 'body' && property.type === 'text') {
+                const prior = entity.properties.body;
+                const views = { ...entity.paperViews };
+                for (const reader of prior?.knownTo ?? [])
+                    views[reader] = { name: entity.name, words: typeof prior?.value === 'string' ? prior.value : null };
+                for (const reader of opening ? entity.knownTo : knownTo)
+                    views[reader] = { name: entity.name, words: typeof stored === 'string' ? stored : null };
+                entity.paperViews = views;
+            }
+            if (stored === null)
+                delete entity.properties[effect.propertyId];
+            // A world's own words are known to whoever knows the thing; the slot shares its list, which is never changed in place.
+            else
+                entity.properties[effect.propertyId] = { value: stored, changedSeq: event.seq, previousSeq, knownTo: opening ? entity.knownTo : knownTo, updatedAt: event.at };
+            if (previousRefs !== null)
+                reindexPlaceless(state, entity.id, previousRefs);
+            state.changes.push({ seq: event.seq, entityId: entity.id, slotKind: 'property', slotId: effect.propertyId, value: stored });
+            if (effect.value !== null && typeof effect.value === 'string' && ['none', 'low', 'medium', 'high'].includes(effect.value)) {
+                spreadLevel(state, entity.id, effect.propertyId, effect.value, event.seq, event.at);
+            }
+            if (typeof effect.value === 'number')
+                runTriggers(state, entity.id, effect.propertyId, typeof previousValue === 'number' ? previousValue : null, effect.value, event.at, event.seq);
+            if (state.engine >= LAZY_METER_ENGINE)
+                predictCrossings(state, entity.id, effect.propertyId, event.seq);
+            if (entity.members !== undefined && (effect.propertyId === 'opens-at' || effect.propertyId === 'closes-at'))
+                setCount(state, event, entity.id, effect.propertyId === 'opens-at', typeof stored === 'number' ? stored : null);
+            if (effect.propertyId === 'author' && state.engine >= AUTHORS_ENGINE)
+                noteAuthor(state, entity.id, typeof previousValue === 'string' ? previousValue : null, typeof stored === 'string' ? stored : null);
+            return;
+        }
+        case 'ballot': {
+            const decision = state.entities[effect.entityId];
+            if (!decision || decision.members === undefined)
+                throw new LivingWorldError('effect-invalid', `${decision?.name ?? effect.entityId} is not put to a vote`);
+            const voter = requirePerson(state, effect.personId);
+            const shut = votingShut(state, decision, event.at);
+            if (shut)
+                throw new LivingWorldError('effect-invalid', `${decision.name} ${shut}`);
+            if (!decision.members.includes(voter.id))
+                throw new LivingWorldError('effect-invalid', `${voter.name} is not a member voting on ${decision.name}`);
+            if (event.actorId !== voter.id)
+                throw new LivingWorldError('effect-invalid', `Only ${voter.name} casts ${voter.name}'s vote on ${decision.name}`);
+            if (decision.ballots?.[voter.id] !== undefined)
+                throw new LivingWorldError('effect-invalid', `${voter.name} has already voted on ${decision.name}`);
+            decision.ballots = { ...decision.ballots, [voter.id]: effect.choice };
+            decision.condition = withSide(decision, 'votes', tally(decision), state.engine >= WHOLE_SIDES_ENGINE, state.engine >= SIDE_ORDER_ENGINE);
+            decision.knownTo = [...new Set([...decision.knownTo, ...(event.perceivedBy ?? event.witnessIds), voter.id])];
+            // The last member's vote closes it.
+            if (decision.members.every(memberId => decision.ballots[memberId] !== undefined))
+                closeDecision(state, event, decision);
+            return;
+        }
+        case 'decision.close': {
+            const decision = state.entities[effect.entityId];
+            if (!decision || decision.members === undefined || decision.result !== undefined)
+                throw new LivingWorldError('effect-invalid', `${decision?.name ?? effect.entityId} is not an open vote`);
+            const closesAt = decision.properties['closes-at']?.value;
+            if (typeof closesAt !== 'number' || closesAt > event.at)
+                throw new LivingWorldError('effect-invalid', `${decision.name} is not yet due to be counted`);
+            if (effect.result !== countResult(decision))
+                throw new LivingWorldError('effect-invalid', `${decision.name} counts as ${countResult(decision)}, not ${effect.result}`);
+            closeDecision(state, event, decision);
+            return;
+        }
+        case 'clock': {
+            // The clock is set at the game time it had reached; from then on it runs at the new rate. From
+            // engine 40 that is where the player could see it, a short lead past what the world simulated:
+            // time it never reached is not owed afterwards.
+            const target = clockTargetAt(state, event.realAt);
+            const shown = state.engine >= SHOWN_CLOCK_ENGINE && state.clockRate !== null ? Math.min(target, state.clock + livingClockLead(state.clockRate)) : target;
+            const game = Math.max(state.clock, shown);
+            state.clockAnchor = { game, real: event.realAt };
+            state.clockRate = effect.rate;
+            state.paused = effect.paused;
+            // Once the clock runs, every two game hours the open problem nobody has acted on longest goes on by itself.
+            if (state.engine >= STALL_ENGINE && state.clockRate !== null && !state.schedule.some(item => item.series === 'stall-check')) {
+                insertScheduled(state, { id: 'stall-check', at: state.clock + STALL_MINUTES, personId: null, kind: 'world', intent: 'An open problem nobody has acted on goes on by itself.',
+                    placeId: state.people[state.playerId].placeId, targetId: null, sourceSeq: event.seq, importance: 3, everyMinutes: STALL_MINUTES, series: 'stall-check' });
+            }
+            return;
+        }
+        case 'relation.set': {
+            const entity = state.entities[effect.entityId];
+            if (!entity)
+                throw new LivingWorldError('effect-invalid', `Unknown entity ${effect.entityId}`);
+            const definition = state.kinds[entity.kindId];
+            const relation = definition.relations.find(slot => slot.id === effect.relationId);
+            if (!relation)
+                throw new LivingWorldError('effect-invalid', `Unknown relation ${effect.relationId}`);
+            const authority = definition.mechanics.filter((mechanic) => mechanic.kind === 'authority' && mechanic.relationId === effect.relationId);
+            if (event.actorId !== null && authority.length > 0 && !authority.some(mechanic => state.people[event.actorId]?.roleId === mechanic.roleId)) {
+                throw new LivingWorldError('effect-invalid', `Changing ${effect.relationId} needs authority role ${authority.map(mechanic => mechanic.roleId).join(' or ')}`);
+            }
+            if (effect.targetId !== null && readEntity(state, effect.targetId)?.kindId !== relation.targetKindId) {
+                throw new LivingWorldError('effect-invalid', `Relation ${effect.relationId} needs a ${relation.targetKindId} target`);
+            }
+            const previousSeq = entity.relations[effect.relationId]?.changedSeq ?? null;
+            const previousRefs = entity.placeId === null ? entityRefs(state.kinds, entity) : null;
+            if (effect.targetId === null)
+                delete entity.relations[effect.relationId];
+            else
+                entity.relations[effect.relationId] = { targetId: effect.targetId, changedSeq: event.seq, previousSeq, knownTo: opening ? entity.knownTo : knownTo };
+            if (previousRefs !== null)
+                reindexPlaceless(state, entity.id, previousRefs);
+            state.changes.push({ seq: event.seq, entityId: entity.id, slotKind: 'relation', slotId: effect.relationId, value: effect.targetId });
+            return;
+        }
+    }
+}
+// What the player reads of a problem is what they last saw of it, with its time. A problem they did not
+// see begin is named by the place where they saw it (before engine 45, by the moment itself); a change
+// they see is what they read of it from then on; anything else they see of it is its latest development.
+function seeTension(state, tension, event, seen) {
+    const line = observedSummary(event, state.playerId) ?? tension.summary;
+    const resolution = tension.status === 'settled' ? event.observed ?? tension.resolution : null;
+    const view = tension.playerView;
+    if (view === null || seen !== 'shown') {
+        const place = event.placeId === null ? undefined : state.places[event.placeId];
+        const where = state.engine >= SEEN_WHERE_ENGINE && place ? `Seen in ${place.name}` : line;
+        tension.playerView = { title: view?.title ?? (seen === 'created' ? tension.title : where).slice(0, 200), summary: line, status: tension.status, resolution, latest: null, since: event.at };
+        return;
+    }
+    tension.playerView = { ...view, status: tension.status, resolution, latest: line, latestAt: event.at };
+}
+function rememberEvent(state, event) {
+    // The opening is the situation everyone already lives in, not a memory of something happening.
+    if (event.kind === 'opening' || event.kind === 'keep-playing' || event.kind === 'finish' || event.kind === 'wait')
+        return;
+    const spoken = event.effects.find((effect) => effect.kind === 'say' && effect.personId === event.actorId);
+    for (const witnessId of event.witnessIds) {
+        const witness = state.people[witnessId];
+        if (!witness || witness.isPlayer)
+            continue;
+        if (event.perceivedBy && !event.perceivedBy.includes(witnessId) && event.actorId !== witnessId)
+            continue;
+        // From engine 42 one's own words are remembered as one's own, whoever else they named.
+        const mine = spoken && state.engine >= IDENTITY_ENGINE
+            ? `I said${spoken.toIds.length === 0 ? '' : ` to ${spoken.toIds.map(id => state.people[id]?.name ?? id).join(' and ')}`}: "${spoken.text}"` : null;
+        const memory = event.actorId === witnessId
+            ? mine ?? `I did this: ${event.summary}`
+            : spoken
+                ? `I heard ${state.people[spoken.personId].name} say: "${spoken.text}"`
+                : `I was there and saw this: ${event.observed ?? event.summary}`;
+        addMemory(state, witnessId, event, memory, event.importance, event.witnessIds.filter(other => other !== witnessId), { kind: spoken ? 'heard' : 'observed', eventSeq: event.seq, sourceId: spoken?.personId ?? null });
+    }
+    for (const nearbyId of event.nearbyIds) {
+        const person = state.people[nearbyId];
+        if (!person || person.isPlayer)
+            continue;
+        // Someone nearby remembers only what reached them, and where they were when it did;
+        // someone who walked in is simply seen arriving.
+        const arrival = arrivalFor(state, event, nearbyId);
+        if (arrival) {
+            addMemory(state, nearbyId, event, `${arrival}.`, 1, [], { kind: 'observed', eventSeq: event.seq, sourceId: null });
+            continue;
+        }
+        const where = state.places[person.placeId]?.name ?? person.placeId;
+        const from = event.placeId ? state.places[event.placeId]?.name ?? event.placeId : 'somewhere close';
+        const signal = signalsFor(state, event.effects).find(item => item.targetPlaceId === person.placeId || item.channel === GLOBAL_SIGNAL_CHANNEL);
+        addMemory(state, nearbyId, event, `From ${where}, I noticed something from ${from}: ${event.notice ?? 'a commotion'} (I did not see what happened.)`, Math.max(1, event.importance - 1), [], { kind: signal ? signal.channel === 'sound' || signal.channel === GLOBAL_SIGNAL_CHANNEL ? 'heard' : 'observed' : 'inferred', eventSeq: event.seq, sourceId: null });
+    }
+    for (const effect of event.effects) {
+        if (effect.kind !== 'message')
+            continue;
+        for (const recipient of effect.toIds) {
+            const person = state.people[recipient];
+            if (!person || person.isPlayer)
+                continue;
+            addMemory(state, recipient, event, `${state.people[effect.fromId]?.name ?? effect.fromId} sent me a message: "${effect.text}"`, Math.max(3, event.importance), [effect.fromId], { kind: 'told', eventSeq: event.seq, sourceId: effect.fromId });
+        }
+    }
+}
+// A message, sent at once or handed on to travel, needs a sender free to send it, other people to
+// read it, and a recorded account from anyone it passes on.
+function checkMessage(state, event, effect) {
+    requirePerson(state, effect.fromId);
+    if (state.engine >= ACT_GATE_ENGINE && event.actorId === effect.fromId) {
+        const gate = blockedByGate(state, effect.fromId, 'message');
+        if (gate)
+            throw new LivingWorldError('effect-invalid', `Messages are blocked by ${gate}`);
+    }
+    for (const target of effect.toIds)
+        requirePerson(state, target);
+    if (effect.toIds.includes(effect.fromId))
+        throw new LivingWorldError('effect-invalid', 'A message needs another recipient');
+    if (effect.sourcePersonId && effect.sourcePersonId !== effect.fromId) {
+        requirePerson(state, effect.sourcePersonId);
+        const contacted = state.messages.some(message => message.fromId === effect.sourcePersonId && message.toIds.includes(effect.fromId))
+            || state.conversations.some(conversation => conversation.lines.some(line => line.speakerId === effect.sourcePersonId && line.toIds.includes(effect.fromId)));
+        if (!contacted)
+            throw new LivingWorldError('effect-invalid', `${effect.fromId} has no recorded account from ${effect.sourcePersonId}`);
+    }
+}
+// The player's own choices and what they perceived that mattered stay for the ending however long
+// the story runs; past the limit the least weighty of the older half makes room.
+function recordChronicle(state, event) {
+    if (state.engine < CHRONICLE_ENGINE || !visibleTo(event, state.playerId))
+        return;
+    const mine = event.actorId === state.playerId && (event.kind === 'speech' || event.kind === 'message' || event.kind === 'attempt');
+    if (!mine && !(event.importance >= 6 || event.kind === 'attempt' || event.kind === 'world'))
+        return;
+    const summary = observedSummary(event, state.playerId);
+    if (summary === null)
+        return;
+    const nearbyOnly = event.nearbyIds.includes(state.playerId) && !witnessed(event, state.playerId) && event.actorId !== state.playerId;
+    state.chronicle.push({ seq: event.seq, at: event.at, kind: event.kind, placeId: nearbyOnly ? null : event.placeId, summary: summary.slice(0, 2000),
+        outcome: event.observed === undefined ? event.outcome : null, importance: event.importance, mine });
+    if (state.chronicle.length <= MAX_CHRONICLE)
+        return;
+    const older = Math.floor(state.chronicle.length / 2);
+    let drop = 0;
+    for (let index = 1; index < older; index += 1)
+        if (state.chronicle[index].importance < state.chronicle[drop].importance)
+            drop = index;
+    state.chronicle.splice(drop, 1);
+}
+function addMemory(state, personId, event, text, importance, participantIds, evidence = { kind: 'inferred', eventSeq: event.seq, sourceId: null }) {
+    const person = state.people[personId];
+    person.memoryCount = (person.memoryCount ?? person.memories.length) + 1;
+    const thingIds = state.engine >= THING_MEMORY_ENGINE ? thingsOf(event) : [];
+    const memory = {
+        id: generatedId(state.engine, 'memory', [personId, event.seq, person.memoryCount], `${personId}-memory-${event.seq}-${person.memoryCount}`), at: event.at, eventSeq: event.seq,
+        text: text.slice(0, 2000), importance, participantIds: [...new Set(participantIds)], placeId: event.placeId,
+        ...(thingIds.length === 0 ? {} : { thingIds }), evidence,
+    };
+    if (isDraft(person)) {
+        // Memories are append-only. Skip drafting and walking the immutable archive.
+        const memories = [...plain(person.memories), memory];
+        Object.freeze(memories);
+        person.memories = memories;
+    }
+    else
+        person.memories.push(memory);
+}
+// A ruling leaves each thing it concerned a note of what it did with it, so a later ruling knows;
+// the oldest note makes room past the limit.
+function noteThings(state, event) {
+    if (state.engine < THING_MEMORY_ENGINE || (event.kind !== 'attempt' && event.kind !== 'world'))
+        return;
+    const things = thingsOf(event).filter(id => readEntity(state, id) || state.objects[id]);
+    if (things.length === 0)
+        return;
+    for (const id of things)
+        state.thingNotes[id] = { seq: event.seq, at: event.at, text: event.summary.slice(0, THING_NOTE_TEXT) };
+    const ids = Object.keys(state.thingNotes);
+    if (ids.length <= MAX_THING_NOTES)
+        return;
+    for (const id of ids.sort((left, right) => state.thingNotes[left].seq - state.thingNotes[right].seq || (left < right ? -1 : left > right ? 1 : 0)).slice(0, ids.length - MAX_THING_NOTES))
+        delete state.thingNotes[id];
+}
+// From engine 49 someone who comes to a place sees what lies there in the open, and how it plainly is,
+// but reads no words: what someone holds, what the world hides, and what is written, they learn only
+// by seeing it handled or by reading it.
+function seeWhatLiesHere(state, personId, placeId) {
+    if (state.engine < THINGS_SEEN_ENGINE)
+        return;
+    for (const id of state.entityPlaceIds[placeId] ?? []) {
+        // Looked at first, so a thing already known is not rewritten.
+        const seen = readEntity(state, id);
+        if (!seen || seen.holderId !== null || seen.hidden || seen.knownTo.includes(personId))
+            continue;
+        const entity = state.entities[id];
+        entity.knownTo = [...entity.knownTo, personId];
+        const types = state.kinds[entity.kindId]?.properties ?? [];
+        for (const [propertyId, slot] of Object.entries(entity.properties)) {
+            if (types.find(property => property.id === propertyId)?.type === 'text' || slot.knownTo.includes(personId))
+                continue;
+            entity.properties[propertyId] = { ...slot, knownTo: [...slot.knownTo, personId] };
+        }
+    }
+}
+// From engine 49 those who perceive an act know the things it concerned, and the one who acted on a
+// thing, such as by reading it, knows all of it, its words too, unless it is sealed.
+function learnThings(state, event) {
+    // The opening says itself who knows each of the world's own things.
+    if (state.engine < THINGS_SEEN_ENGINE || event.kind === 'opening')
+        return;
+    const perceivers = event.perceivedBy ?? event.witnessIds;
+    const actor = event.kind === 'attempt' && event.actorId !== null && state.people[event.actorId] ? event.actorId : null;
+    const knowers = [...perceivers, ...(actor === null ? [] : [actor])];
+    for (const id of thingsOf(event)) {
+        // Looked at first, so a thing already known as it is, is not rewritten.
+        const seen = readEntity(state, id);
+        if (!seen)
+            continue;
+        const sealed = sealedPaper(state.engine, seen);
+        const types = state.kinds[seen.kindId]?.properties ?? [];
+        const unread = (propertyId, slot) => actor !== null && !slot.knownTo.includes(actor)
+            && !(sealed && types.find(property => property.id === propertyId)?.type === 'text');
+        const learns = knowers.some(knower => !seen.knownTo.includes(knower)) || Object.entries(seen.properties).some(([propertyId, slot]) => unread(propertyId, slot));
+        if (!learns)
+            continue;
+        const entity = state.entities[id];
+        if (knowers.some(knower => !entity.knownTo.includes(knower)))
+            entity.knownTo = [...new Set([...entity.knownTo, ...knowers])];
+        for (const [propertyId, slot] of Object.entries(entity.properties)) {
+            if (unread(propertyId, slot))
+                entity.properties[propertyId] = { ...slot, knownTo: [...slot.knownTo, actor] };
+        }
+    }
+}
+// The things an event concerned: those it names and those its changes touch.
+function thingsOf(event) {
+    const touched = event.effects.flatMap(effect => effect.kind === 'object.update' || effect.kind === 'object.create' ? [effect.objectId]
+        : effect.kind === 'entity.create' || effect.kind === 'property.set' || effect.kind === 'entity.move' || effect.kind === 'entity.condition' || effect.kind === 'relation.set'
+            ? [effect.entityId] : []);
+    return [...new Set([...(event.thingIds ?? []), ...touched])].slice(0, 8);
+}
+// What a person holds goes with them: each thing they carry is now where they are.
+function carryHeldEntities(state, personId, from, to) {
+    const carried = (state.entityPlaceIds[from] ?? []).filter(id => readEntity(state, id)?.holderId === personId);
+    if (carried.length === 0)
+        return;
+    // A place with nothing left has no list, as when a save is loaded.
+    const left = state.entityPlaceIds[from].filter(id => !carried.includes(id));
+    if (left.length > 0)
+        state.entityPlaceIds[from] = left;
+    else
+        delete state.entityPlaceIds[from];
+    for (const id of carried) {
+        state.entities[id].placeId = to;
+        (state.entityPlaceIds[to] ??= []).push(id);
+    }
+    if (plain(state.meterSchedule).some(item => item.targetId !== null && carried.includes(item.targetId))) {
+        state.meterSchedule = (isDraft(state.meterSchedule) ? current(state.meterSchedule) : state.meterSchedule)
+            .map(item => item.targetId !== null && carried.includes(item.targetId) ? { ...item, placeId: to } : item);
+    }
+}
+// The player learns where people are by seeing them. Looking at a room also shows who is
+// no longer there: they stay known, last seen there, with their whereabouts now unknown.
+function observePlace(state, placeId, at) {
+    for (const person of Object.values(state.people)) {
+        if (person.isPlayer)
+            continue;
+        const sighting = state.sightings[person.id];
+        const gone = person.away !== undefined || state.engine >= LEFT_UNSEEN_ENGINE && person.departed !== undefined;
+        if (person.placeId === placeId && !gone)
+            state.sightings[person.id] = { placeId, at };
+        else if (sighting?.placeId === placeId && !sighting.gone)
+            state.sightings[person.id] = { ...sighting, gone: true, ...(state.engine >= GONE_AT_ENGINE ? { goneAt: at } : {}) };
+    }
+}
+function leaveConversations(state, personId, placeId, at) {
+    for (const conversation of state.conversations) {
+        if (conversation.endedAt !== null || conversation.placeId !== placeId || !conversation.participantIds.includes(personId))
+            continue;
+        const remaining = conversation.participantIds.filter(id => id !== personId);
+        // A conversation always keeps at least its last participant on record; it ends when one person is left.
+        if (remaining.length > 0)
+            conversation.participantIds = remaining;
+        if (remaining.length < 2)
+            conversation.endedAt = at;
+    }
+}
+function openConversation(state, placeId, participantIds, at, seq) {
+    const existing = state.conversations.find(conversation => conversation.endedAt === null && conversation.placeId === placeId
+        && participantIds.some(id => conversation.participantIds.includes(id)));
+    if (existing) {
+        for (const id of participantIds)
+            if (!existing.participantIds.includes(id))
+                existing.participantIds.push(id);
+        return existing;
+    }
+    let id = `conversation-${state.conversations.length + 1}`;
+    if (state.engine >= STABLE_CONVERSATION_ENGINE) {
+        let ordinal = 0;
+        do {
+            id = `conversation-${seq}-${++ordinal}`;
+        } while (state.conversations.some(conversation => conversation.id === id));
+    }
+    const conversation = { id, placeId, participantIds: [...new Set(participantIds)], startedAt: at, endedAt: null, lines: [] };
+    state.conversations.push(conversation);
+    return conversation;
+}
+// A new line goes below the words already written; when the page is full, the first words stay and
+// the newest line is kept.
+function addWriting(written, line) {
+    const joined = `${written}\n${line}`;
+    if (joined.length <= MAX_TEXT)
+        return joined;
+    const tail = line.slice(0, MAX_TEXT - 2);
+    return `${written.slice(0, MAX_TEXT - tail.length - 2)}…\n${tail}`;
+}
+// Lines to someone who does nothing others can see in return pile up. Anything they are seen or heard
+// to do ends the count for everyone waiting on them, and a line on a new day starts it over.
+const QUIET_KINDS = new Set(['plan', 'tick', 'clock', 'opening', 'keep-playing', 'wait']);
+function noteUnanswered(state, event) {
+    const actorId = event.actorId;
+    if (actorId !== null && !QUIET_KINDS.has(event.kind) && (event.perceivedBy === undefined || event.perceivedBy.length > 0)) {
+        for (const person of Object.values(state.people)) {
+            if (person.unanswered?.[actorId] === undefined)
+                continue;
+            delete person.unanswered[actorId];
+            if (Object.keys(person.unanswered).length === 0)
+                delete person.unanswered;
+        }
+    }
+    for (const effect of event.effects) {
+        const line = effect.kind === 'say' ? { speakerId: effect.personId, toIds: effect.toIds }
+            : effect.kind === 'message' || effect.kind === 'dispatch' ? { speakerId: effect.fromId, toIds: effect.toIds } : null;
+        const speaker = line === null ? undefined : state.people[line.speakerId];
+        if (line === null || speaker === undefined || speaker.isPlayer)
+            continue;
+        for (const listenerId of line.toIds) {
+            const entry = speaker.unanswered?.[listenerId];
+            const fresh = entry === undefined || event.at - entry.firstAt >= UNANSWERED_RESET_MINUTES;
+            speaker.unanswered = { ...speaker.unanswered, [listenerId]: fresh ? { lines: 1, firstAt: event.at } : { lines: entry.lines + 1, firstAt: entry.firstAt } };
+        }
+    }
+}
+// A paper is listed under the person who wrote it, and leaves the list of anyone who no longer is its author.
+function noteAuthor(state, entityId, previous, next) {
+    const authored = { ...state.authoredIds };
+    if (previous !== null && authored[previous])
+        authored[previous] = authored[previous].filter(id => id !== entityId);
+    if (next !== null && state.people[next])
+        authored[next] = [...(authored[next] ?? []).filter(id => id !== entityId), entityId];
+    state.authoredIds = authored;
+}
+// A vote's count so far, as anyone who sees it can read it.
+function tally(decision) {
+    const cast = Object.values(decision.ballots ?? {});
+    const count = (choice) => cast.filter(value => value === choice).length;
+    return `yes ${count('yes')}, no ${count('no')}${count('abstain') > 0 ? `, abstaining ${count('abstain')}` : ''} of ${decision.members.length}`;
+}
+// The votes needed to pass: the number the decision names, or more than half its members.
+function neededVotes(decision) {
+    const needed = decision.properties.needed?.value;
+    return typeof needed === 'number' && needed > 0 ? needed : Math.floor(decision.members.length / 2) + 1;
+}
+export function countResult(decision) {
+    const cast = Object.values(decision.ballots ?? {});
+    if (cast.filter(value => value === 'yes').length >= neededVotes(decision))
+        return 'passed';
+    return cast.length === 0 ? 'lapsed' : 'failed';
+}
+// Why no vote can be cast on a decision now, or null while it is open.
+export function votingShut(state, decision, at) {
+    if (decision.result !== undefined)
+        return `was decided: ${decision.result}`;
+    const opensAt = decision.properties['opens-at']?.value;
+    if (typeof opensAt === 'number' && at < opensAt)
+        return `opens to votes at ${clockLabel(opensAt)}`;
+    const closesAt = decision.properties['closes-at']?.value;
+    if (typeof closesAt === 'number' && at >= closesAt)
+        return `closed to votes at ${clockLabel(closesAt)}`;
+    return null;
+}
+// A vote is counted when its last member votes or its time is up; a problem it settles is settled by the result.
+function closeDecision(state, event, decision) {
+    decision.result = countResult(decision);
+    decision.condition = withSide(decision, 'result', decision.result, state.engine >= WHOLE_SIDES_ENGINE, state.engine >= SIDE_ORDER_ENGINE);
+    state.openDecisionIds = (state.openDecisionIds ?? []).filter(id => id !== decision.id);
+    state.schedule = state.schedule.filter(item => item.count?.entityId !== decision.id);
+    // The money a passed decision moves; a payment that cannot be made is left out, as the count still stands.
+    if (decision.result === 'passed')
+        for (const transfer of decision.transfers ?? []) {
+            try {
+                applyEffect(state, event, { kind: 'transfer', ...transfer });
+            }
+            catch (error) {
+                if (!(error instanceof LivingWorldError))
+                    throw error;
+            }
+        }
+    const tension = decision.settles === undefined ? undefined : state.tensions.find(candidate => candidate.id === decision.settles);
+    if (tension?.status === 'open')
+        applyEffect(state, event, { kind: 'tension.update', tensionId: tension.id, status: 'settled', note: countNote(decision) });
+}
+// What a count writes as the settlement of the problem it settles: the question, the result and the count.
+export function countNote(decision) {
+    return `${String(decision.properties.question?.value ?? decision.name).slice(0, 300)}: ${decision.result}, ${tally(decision)}.`;
+}
+// A vote's written opening or closing time puts its count on the schedule, in place of any earlier one.
+function setCount(state, event, entityId, opens, at) {
+    state.schedule = state.schedule.filter(item => !(item.count?.entityId === entityId && item.count.opens === opens));
+    if (at === null || opens && at <= event.at)
+        return;
+    const decision = state.entities[entityId];
+    insertScheduled(state, { id: generatedId(state.engine, opens ? 'opens' : 'count', [event.seq, entityId], `${opens ? 'opens' : 'count'}-${event.seq}-${entityId}`.slice(0, 64)), at: Math.max(at, event.at), personId: null, kind: 'count',
+        intent: `${opens ? 'Voting opens on' : 'Votes are counted on'} ${decision.name}`.slice(0, MAX_LINE), placeId: decision.placeId, targetId: null, sourceSeq: event.seq, importance: 5,
+        count: { entityId, opens } });
+}
+// A thing's condition keeps a line for each named side; a change without a name is to its state. The
+// oldest other side gives way when a fifth arrives, and the line shows the state first and names the rest.
+// From engine 48 the order the sides were first set is kept in a list, which a save keeps; before, it was
+// the record's own key order, which a save in PostgreSQL does not keep.
+const MAX_SIDES = 4;
+const MAX_CONDITION = 200;
+function withSide(thing, aspect, text, whole, ordered) {
+    const sides = { ...(thing.aspects ?? (thing.condition === null ? {} : { state: thing.condition })) };
+    const name = aspect ?? 'state';
+    const order = (ordered && thing.sideOrder ? thing.sideOrder : Object.keys(sides)).filter(side => sides[side] !== undefined);
+    const others = order.filter(side => side !== 'state');
+    if (name !== 'state' && sides[name] === undefined && others.length >= MAX_SIDES) {
+        delete sides[others[0]];
+        order.splice(order.indexOf(others[0]), 1);
+    }
+    if (!order.includes(name))
+        order.push(name);
+    sides[name] = text;
+    const entries = [...(sides.state === undefined ? [] : [['state', sides.state]]),
+        ...order.filter(side => side !== 'state').map((side) => [side, sides[side]])];
+    const line = () => entries.map(([side, value]) => side === 'state' ? value : `${side}: ${value}`).join('; ');
+    // From engine 46 the line keeps whole sides: the oldest named side, never the one just written, gives way.
+    while (whole && line().length > MAX_CONDITION && entries.some(([side]) => side !== 'state' && side !== name)) {
+        entries.splice(entries.findIndex(([side]) => side !== 'state' && side !== name), 1);
+    }
+    thing.aspects = Object.fromEntries(entries);
+    if (ordered)
+        thing.sideOrder = entries.map(([side]) => side);
+    return line().slice(0, MAX_CONDITION);
+}
+// When someone has left this speaker's last lines unanswered long enough to stop addressing them,
+// the time of the first of those lines; otherwise null.
+export function unansweredSince(state, speakerId, listenerId) {
+    const entry = state.people[speakerId]?.unanswered?.[listenerId];
+    if (entry === undefined || entry.lines < UNANSWERED_LINES)
+        return null;
+    const waited = state.clock - entry.firstAt;
+    return waited >= UNANSWERED_MINUTES && waited < UNANSWERED_RESET_MINUTES ? entry.firstAt : null;
+}
+function requirePerson(state, personId) {
+    const person = state.people[personId];
+    if (!person)
+        throw new LivingWorldError('effect-invalid', `Unknown person ${personId}`);
+    return person;
+}
+// A person's purse or an account, read and set the same way.
+function purse(state, id) {
+    const person = state.people[id];
+    if (person) {
+        if (person.money === null)
+            throw new LivingWorldError('effect-invalid', `${person.name} keeps no money in this world`);
+        return { name: person.name, person, account: null, allowsDebt: false, balance: () => person.money, set: (value) => { person.money = value; } };
+    }
+    const account = state.accounts?.[id];
+    if (!account)
+        throw new LivingWorldError('effect-invalid', `Unknown person or account ${id}`);
+    return { name: account.name, person: null, account, allowsDebt: account.allowsDebt, balance: () => account.balance, set: (value) => { account.balance = value; } };
+}
+function requireKnown(state, id) {
+    if (state.people[id] || readEntity(state, id) || state.objects[id] || state.places[id] || state.tensions.some(tension => tension.id === id))
+        return;
+    throw new LivingWorldError('effect-invalid', `Unknown person, thing, place or problem ${id}`);
+}
+function requirePlace(state, placeId) {
+    const place = state.places[placeId];
+    if (!place)
+        throw new LivingWorldError('effect-invalid', `Unknown place ${placeId}`);
+    return place;
+}
+function clamp(value) {
+    return Math.max(-100, Math.min(100, value));
+}
+// The game time the server clock has reached at a real time. A world without a rate moves only
+// with its events, so its clock is where the last event left it.
+// How far past the game time a world has reached a player is shown the clock running, in game
+// minutes: a few real seconds at its speed.
+export function livingClockLead(rate) {
+    return 15 + Math.ceil(rate / 12);
+}
+export function clockTargetAt(state, realMs) {
+    if (state.clockRate === null || state.clockAnchor === null)
+        return state.clock;
+    if (state.paused)
+        return Math.max(state.clock, state.clockAnchor.game);
+    const passed = Math.max(0, realMs - state.clockAnchor.real);
+    return Math.max(state.clock, state.clockAnchor.game + Math.floor(passed * state.clockRate / 60_000));
+}
+// Tick and clock events belong to the world, not to anyone in it, and carry the real time.
+function checkClockEvent(previous, event) {
+    const clockEffects = event.effects.filter(effect => effect.kind === 'clock');
+    if (event.kind !== 'clock' && clockEffects.length > 0)
+        throw new LivingWorldError('effect-invalid', 'Only a clock event sets the clock');
+    if (event.kind !== 'tick' && event.kind !== 'clock')
+        return;
+    if (event.actorId !== null || event.placeId !== null || event.realAt === undefined) {
+        throw new LivingWorldError('effect-invalid', `A ${event.kind} event belongs to the world and needs a real time`);
+    }
+    if (event.kind === 'clock' && (clockEffects.length !== 1 || event.effects.length !== 1 || event.minutes !== 0)) {
+        throw new LivingWorldError('effect-invalid', 'A clock event sets the clock and nothing else');
+    }
+    if (event.kind === 'tick' && (previous.clockRate === null || event.effects.length > 0 || event.minutes < 1)) {
+        throw new LivingWorldError('effect-invalid', 'A tick moves the clock of a live world and nothing else');
+    }
+    if (event.kind === 'tick' && event.at + event.minutes > clockTargetAt(previous, event.realAt)) {
+        throw new LivingWorldError('effect-invalid', 'A tick cannot pass the server clock');
+    }
+}
+// Travel follows the place graph. Adjacent places are a short walk apart.
+export const TRAVEL_MINUTES_PER_HOP = 3;
+export function travelPath(state, from, to) {
+    if (!state.places[from] || !state.places[to])
+        return null;
+    if (from === to)
+        return [from];
+    const previous = new Map([[from, null]]);
+    const queue = [from];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const next of [...state.places[current].connections].sort()) {
+            if (previous.has(next))
+                continue;
+            previous.set(next, current);
+            if (next === to) {
+                const path = [to];
+                let step = current;
+                while (step !== null) {
+                    path.unshift(step);
+                    step = previous.get(step) ?? null;
+                }
+                return path;
+            }
+            queue.push(next);
+        }
+    }
+    return null;
+}