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

package/dist/simulation/living/definition.js

@@ -0,0 +1,341 @@
+import { BOUNDED_PERSON_RECORDS_ENGINE, MAX_WORKING_BELIEFS } from './types.js';
+import { generatedId } from './identifiers.js';
+import { z } from 'zod';
+import { LIVING_ENGINE_VERSION, LIVING_SCHEMA_VERSION, MAX_CLOCK_RATE, MESSAGE_TRAVEL_ENGINE, PROBLEM_VIEW_ENGINE, LivingWorldError, messageTravelSchema, parseLivingState, DEADLINE_ENGINE, beatRulesSchema, } from './types.js';
+import { kindDefinitionSchema, propertyValueSchema } from './open-world.js';
+import { sharedKindMap } from './shared-kinds.js';
+// A world definition is authored content: the place graph, the cast, the objects,
+// and the opening tension. The engine turns it into a revision-0 state.
+const id = z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/u);
+const characterSchema = z.object({
+    voice: z.string().min(1).max(200),
+    values: z.array(z.string().min(1).max(200)).min(1),
+    redLines: z.array(z.string().min(1).max(200)).min(1),
+    privateConcerns: z.array(z.string().min(1).max(200)).min(1),
+});
+export const definitionSchema = z.object({
+    kind: id,
+    title: z.string().min(1).max(120),
+    tagline: z.string().min(1).max(240),
+    setting: z.string().min(1).max(2000),
+    startClock: z.number().int().min(0).max(1_000_000),
+    // A live world runs on the server clock at this many game minutes per real minute.
+    clock: z.object({ rate: z.number().int().min(1).max(MAX_CLOCK_RATE) }).optional(),
+    // How private messages travel here, such as "by a runner", and the game minutes they take.
+    // Left out, messages arrive at once, as by phone.
+    messages: messageTravelSchema.optional(),
+    currency: z.object({ symbol: z.string().min(1).max(4), name: z.string().min(1).max(40) }).nullable(),
+    // Money kept apart from anyone's purse; one held by no one moves only by the world's own happenings.
+    accounts: z.array(z.object({ id, name: z.string().min(1).max(200), holderId: id.nullable().default(null), balance: z.number(), allowsDebt: z.boolean().default(false) })).default([]),
+    places: z.array(z.object({
+        id,
+        name: z.string().min(1).max(120),
+        kind: z.enum(['room', 'outdoors', 'transit', 'private']),
+        summary: z.string().min(1).max(2000),
+        connections: z.array(id),
+        conditions: z.array(z.string().min(1).max(200)).default([]),
+    })).min(2),
+    player: z.object({
+        id,
+        name: z.string().min(1).max(120),
+        role: z.string().min(1).max(120),
+        roleId: id.nullable().default(null),
+        summary: z.string().min(1).max(2000),
+        pronouns: z.string().min(1).max(40).optional(),
+        placeId: id,
+        money: z.number().nullable(),
+    }),
+    cast: z.array(z.object({
+        id,
+        name: z.string().min(1).max(120),
+        role: z.string().min(1).max(120),
+        roleId: id.nullable().default(null),
+        summary: z.string().min(1).max(2000),
+        persona: z.string().min(1).max(2000).optional(),
+        character: characterSchema.optional(),
+        pronouns: z.string().min(1).max(40).optional(),
+        placeId: id,
+        money: z.number().nullable(),
+        mood: z.string().min(1).max(120),
+        goals: z.array(z.string().min(1).max(600)),
+        beliefs: z.array(z.object({ subject: z.string().min(1).max(200), claim: z.string().min(1).max(600) })),
+        relationships: z.record(id, z.object({ trust: z.number().int().min(-100).max(100), warmth: z.number().int().min(-100).max(100), note: z.string().max(600) })),
+        plan: z.object({ intent: z.string().min(1).max(600), seen: z.string().min(1).max(200).optional(), placeId: id.nullable(), targetId: id.nullable(), inMinutes: z.number().int().min(1).max(100_000) }).nullable(),
+        // The player starts knowing where this person is when the opening says so.
+        knownAtStart: z.boolean().default(false),
+    }).refine(person => person.persona !== undefined || person.character !== undefined, 'A character needs a profile')).min(2),
+    objects: z.array(z.object({
+        id,
+        name: z.string().min(1).max(120),
+        summary: z.string().min(1).max(2000),
+        placeId: id.nullable(),
+        holderId: id.nullable(),
+        ownerId: id.nullable(),
+        condition: z.string().min(1).max(200),
+        singlePersonMovable: z.boolean().default(true),
+        // A hidden thing is seen only by those who know where it is: these people, and its holder.
+        knownTo: z.array(id).max(64).optional(), hidden: z.boolean().optional(),
+    })),
+    kinds: z.array(kindDefinitionSchema).default([]),
+    entities: z.array(z.object({
+        id, kindId: id, name: z.string().min(1).max(200), placeId: id.nullable().default(null),
+        properties: z.record(id, propertyValueSchema).default({}), relations: z.record(id, id).default({}),
+        // A decision's voting members, and the world's problem its result settles.
+        members: z.array(id).min(1).max(12).optional(), settles: id.optional(),
+        // Who knows it from the start; left out, everyone in the world does. A hidden thing is not seen by
+        // whoever comes to its place.
+        knownTo: z.array(id).max(64).optional(), hidden: z.boolean().optional(),
+        // Money that moves when the decision passes.
+        transfers: z.array(z.object({ fromId: id.nullable(), toId: id.nullable(), amount: z.number().positive().max(1_000_000_000) })).max(4).optional(),
+    })).default([]),
+    // A fact may name its aspect, so a later happening can replace it, such as a deadline that has passed.
+    facts: z.array(z.union([z.string().min(1).max(600), z.object({ aspect: id, text: z.string().min(1).max(600) })])),
+    opening: z.object({ title: z.string().min(1).max(200), situation: z.string().min(1).max(2000), stakes: z.string().min(1).max(2000) }),
+    tension: z.object({ id, title: z.string().min(1).max(200), summary: z.string().min(1).max(2000), participantIds: z.array(id) }),
+    playerRelationships: z.record(id, z.object({ trust: z.number().int().min(-100).max(100), warmth: z.number().int().min(-100).max(100), note: z.string().max(600) })).default({}),
+    // Beats are the happenings the opening promises (the ambulances, the storm, the vote).
+    // The world carries them out when they fall due, whatever the player does.
+    // A beat with everyMinutes comes back after each time it happens: visitors, deliveries, shift changes.
+    beats: z.array(z.object({ id, inMinutes: z.number().int().min(1).max(100_000), placeId: id, text: z.string().min(1).max(600),
+        everyMinutes: z.number().int().min(1).max(100_000).optional(),
+        // What it concerns, and the typed results the world's data gives it (see docs/world-data.md).
+        concerns: id.optional(), ...beatRulesSchema.shape })).default([]),
+});
+export function parseLivingWorldDefinition(value) {
+    const parsed = definitionSchema.safeParse(value);
+    if (!parsed.success)
+        throw new LivingWorldError('definition-invalid', parsed.error.message);
+    const definition = parsed.data;
+    const placeIds = new Set(definition.places.map(place => place.id));
+    const peopleIds = new Set([definition.player.id, ...definition.cast.map(person => person.id)]);
+    if (peopleIds.size !== definition.cast.length + 1)
+        throw new LivingWorldError('definition-invalid', 'Every person needs a distinct id');
+    for (const place of definition.places) {
+        for (const connection of place.connections) {
+            if (!placeIds.has(connection))
+                throw new LivingWorldError('definition-invalid', `Place ${place.id} connects to unknown place ${connection}`);
+            if (connection === place.id)
+                throw new LivingWorldError('definition-invalid', `Place ${place.id} connects to itself`);
+        }
+    }
+    for (const person of [definition.player, ...definition.cast]) {
+        if (!placeIds.has(person.placeId))
+            throw new LivingWorldError('definition-invalid', `${person.id} starts in unknown place ${person.placeId}`);
+    }
+    for (const person of definition.cast) {
+        for (const target of Object.keys(person.relationships)) {
+            if (!peopleIds.has(target))
+                throw new LivingWorldError('definition-invalid', `${person.id} relates to unknown person ${target}`);
+        }
+        if (person.plan?.placeId && !placeIds.has(person.plan.placeId))
+            throw new LivingWorldError('definition-invalid', `${person.id} plans to reach unknown place ${person.plan.placeId}`);
+    }
+    for (const target of Object.keys(definition.playerRelationships)) {
+        if (!peopleIds.has(target))
+            throw new LivingWorldError('definition-invalid', `Player relates to unknown person ${target}`);
+    }
+    for (const object of definition.objects) {
+        if (object.placeId !== null && !placeIds.has(object.placeId))
+            throw new LivingWorldError('definition-invalid', `${object.id} sits in unknown place ${object.placeId}`);
+        if (object.holderId !== null && !peopleIds.has(object.holderId))
+            throw new LivingWorldError('definition-invalid', `${object.id} is held by unknown person ${object.holderId}`);
+        if (object.ownerId !== null && !peopleIds.has(object.ownerId))
+            throw new LivingWorldError('definition-invalid', `${object.id} is owned by unknown person ${object.ownerId}`);
+        if ((object.placeId === null) === (object.holderId === null))
+            throw new LivingWorldError('definition-invalid', `${object.id} needs exactly one of a place or a holder`);
+    }
+    for (const participant of definition.tension.participantIds) {
+        if (!peopleIds.has(participant))
+            throw new LivingWorldError('definition-invalid', `Tension names unknown person ${participant}`);
+    }
+    const accountIds = new Set(definition.accounts.map(account => account.id));
+    if (accountIds.size !== definition.accounts.length)
+        throw new LivingWorldError('definition-invalid', 'Every account needs a distinct id');
+    for (const account of definition.accounts) {
+        if (peopleIds.has(account.id))
+            throw new LivingWorldError('definition-invalid', `Account ${account.id} has the id of a person`);
+        if (account.holderId !== null && !peopleIds.has(account.holderId))
+            throw new LivingWorldError('definition-invalid', `Account ${account.id} is held by unknown person ${account.holderId}`);
+    }
+    // A vote names who may cast it and the problem it settles, and only a decision is voted on.
+    for (const entity of definition.entities) {
+        if ((entity.members !== undefined || entity.settles !== undefined || entity.transfers !== undefined) && entity.kindId !== 'decision' || entity.kindId === 'decision' && entity.members === undefined)
+            throw new LivingWorldError('definition-invalid', `${entity.id}: a decision, and only a decision, names its members`);
+        for (const member of entity.members ?? [])
+            if (!peopleIds.has(member))
+                throw new LivingWorldError('definition-invalid', `${entity.id} names unknown member ${member}`);
+        for (const knower of entity.knownTo ?? [])
+            if (!peopleIds.has(knower))
+                throw new LivingWorldError('definition-invalid', `${entity.id} is known to unknown person ${knower}`);
+        if (entity.settles !== undefined && entity.settles !== definition.tension.id)
+            throw new LivingWorldError('definition-invalid', `${entity.id} settles unknown problem ${entity.settles}`);
+        for (const end of (entity.transfers ?? []).flatMap(transfer => [transfer.fromId, transfer.toId])) {
+            const person = [definition.player, ...definition.cast].find(candidate => candidate.id === end);
+            if (end !== null && !accountIds.has(end) && person?.money === undefined)
+                throw new LivingWorldError('definition-invalid', `${entity.id} moves money through unknown person or account ${end}`);
+            if (person?.money === null)
+                throw new LivingWorldError('definition-invalid', `${entity.id} moves money through ${person.name}, who keeps no money in this world`);
+        }
+    }
+    for (const object of definition.objects) {
+        for (const knower of object.knownTo ?? [])
+            if (!peopleIds.has(knower))
+                throw new LivingWorldError('definition-invalid', `${object.id} is known to unknown person ${knower}`);
+    }
+    const aspects = definition.facts.flatMap(fact => typeof fact === 'string' ? [] : [fact.aspect]);
+    const repeated = aspects.filter((aspect, index) => aspects.indexOf(aspect) !== index);
+    if (repeated.length > 0)
+        throw new LivingWorldError('definition-invalid', `Every fact aspect is named once; ${repeated.join(', ')} is repeated`);
+    // A beat's typed results name only what the world has, or they would change nothing when it falls due.
+    const thingIds = new Set([...definition.objects.map(object => object.id), ...definition.entities.map(entity => entity.id)]);
+    const people = [definition.player, ...definition.cast];
+    for (const beat of definition.beats) {
+        const refuse = (message) => new LivingWorldError('definition-invalid', `Beat ${beat.id} ${message}`);
+        if (!placeIds.has(beat.placeId))
+            throw refuse(`happens in unknown place ${beat.placeId}`);
+        if (beat.concerns !== undefined && !thingIds.has(beat.concerns) && !peopleIds.has(beat.concerns) && !placeIds.has(beat.concerns) && beat.concerns !== definition.tension.id) {
+            throw refuse(`concerns ${beat.concerns}, which is no thing, person, place or problem of this world`);
+        }
+        if (beat.unless !== undefined && beat.unless.settled !== definition.tension.id)
+            throw refuse(`waits on unknown problem ${beat.unless.settled}`);
+        if (beat.then?.tension !== undefined && beat.then.tension.id !== definition.tension.id)
+            throw refuse(`changes unknown problem ${beat.then.tension.id}`);
+        for (const fact of beat.then?.facts ?? [])
+            if (!aspects.includes(fact.aspect))
+                throw refuse(`changes fact aspect ${fact.aspect}, which no fact of this world has`);
+        for (const end of (beat.then?.transfers ?? []).flatMap(transfer => [transfer.fromId, transfer.toId])) {
+            if (end === null || accountIds.has(end))
+                continue;
+            const person = people.find(candidate => candidate.id === end);
+            if (person === undefined)
+                throw refuse(`moves money through unknown person or account ${end}`);
+            if (person.money === null)
+                throw refuse(`moves money through ${person.name}, who keeps no money in this world`);
+        }
+    }
+    if (new Set(definition.beats.map(beat => beat.id)).size !== definition.beats.length)
+        throw new LivingWorldError('definition-invalid', 'Every beat needs a distinct id');
+    const objectIds = new Set(definition.objects.map(object => object.id));
+    if (objectIds.size !== definition.objects.length)
+        throw new LivingWorldError('definition-invalid', 'Every object needs a distinct id');
+    return definition;
+}
+// Revision 0 holds only authored facts. The opening event is the first accepted event.
+export function createLivingState(definition, seed, engine = LIVING_ENGINE_VERSION) {
+    const person = (input) => ({
+        id: input.id,
+        name: input.name,
+        role: input.role,
+        roleId: input.roleId,
+        summary: input.summary,
+        persona: input.persona ?? input.character.voice,
+        ...(input.character ? { character: input.character } : {}),
+        ...(input.pronouns ? { pronouns: input.pronouns } : {}),
+        isPlayer: false,
+        placeId: input.placeId,
+        money: input.money,
+        mood: input.mood,
+        goals: input.goals.map((text, index) => ({ id: generatedId(engine, 'goal', [input.id, index + 1], `${input.id}-goal-${index + 1}`), text, status: 'active' })),
+        relationships: { ...input.relationships },
+        beliefs: (engine >= BOUNDED_PERSON_RECORDS_ENGINE ? input.beliefs.slice(-MAX_WORKING_BELIEFS) : input.beliefs).map((belief, index) => ({
+            id: generatedId(engine, 'belief', [input.id, index + 1], `${input.id}-belief-${index + 1}`), subject: belief.subject, claim: belief.claim,
+            source: { kind: 'initial', personId: null, eventSeq: 0 }, at: definition.startClock,
+        })),
+        memories: [],
+        commitments: [],
+        plan: input.plan ? { intent: input.plan.intent, ...(input.plan.seen ? { seen: input.plan.seen } : {}), placeId: input.plan.placeId, targetId: input.plan.targetId,
+            dueAt: definition.startClock + input.plan.inMinutes } : null,
+        incapacitated: false,
+    });
+    const player = {
+        id: definition.player.id,
+        name: definition.player.name,
+        role: definition.player.role,
+        roleId: definition.player.roleId,
+        summary: definition.player.summary,
+        persona: definition.player.summary,
+        ...(definition.player.pronouns ? { pronouns: definition.player.pronouns } : {}),
+        isPlayer: true,
+        placeId: definition.player.placeId,
+        money: definition.player.money,
+        mood: 'Present',
+        goals: [],
+        relationships: Object.fromEntries(definition.cast.map(other => [other.id, definition.playerRelationships[other.id] ?? { trust: 0, warmth: 0, note: '' }])),
+        beliefs: [],
+        memories: [],
+        commitments: [],
+        plan: null,
+        incapacitated: false,
+    };
+    const state = {
+        schemaVersion: LIVING_SCHEMA_VERSION,
+        engine,
+        gameKind: definition.kind,
+        seed,
+        revision: 0,
+        clock: definition.startClock,
+        startClock: definition.startClock,
+        status: 'open',
+        playerId: player.id,
+        places: Object.fromEntries(definition.places.map(place => [place.id, { ...place, conditions: [...place.conditions], conditionAspects: {}, connections: [...place.connections], introducedAt: 0 }])),
+        people: Object.fromEntries([player, ...definition.cast.map(person)].map(entry => [entry.id, entry])),
+        objects: Object.fromEntries(definition.objects.map(({ knownTo, hidden, ...object }) => [object.id, {
+                ...object, introducedAt: 0, ...(hidden ? { hidden: true } : {}),
+                custodyKnownTo: [...new Set([...(object.holderId && definition.cast.some(person => person.id === object.holderId
+                            && (person.knownAtStart || person.placeId === definition.player.placeId)) ? [definition.player.id] : []), ...(knownTo ?? [])])],
+                conditionKnownTo: object.placeId === definition.player.placeId || object.holderId === definition.player.id
+                    ? [definition.player.id] : [],
+            }])),
+        facts: definition.facts.map(fact => typeof fact === 'string' ? fact : fact.text),
+        factAspects: Object.fromEntries(definition.facts.flatMap((fact, index) => typeof fact === 'string' ? [] : [[fact.aspect, { text: fact.text, changedSeq: 0, index }]])),
+        conversations: [],
+        messages: [],
+        requests: [],
+        stances: [],
+        tensions: [{ ...definition.tension, participantIds: [...definition.tension.participantIds], status: 'open', resolution: null, changedAt: definition.startClock,
+                playerView: { title: definition.tension.title, summary: definition.tension.summary, status: 'open', resolution: null, ...(engine >= PROBLEM_VIEW_ENGINE ? { since: definition.startClock } : {}) } }],
+        schedule: [
+            ...definition.cast.flatMap(member => member.plan ? [{
+                    id: generatedId(engine, 'opening-plan', [member.id], `${member.id}-opening-plan`, true), at: definition.startClock + member.plan.inMinutes, personId: member.id, kind: 'plan',
+                    intent: member.plan.intent, placeId: member.plan.placeId, targetId: member.plan.targetId, sourceSeq: 0, importance: 3,
+                }] : []),
+            ...definition.beats.map(beat => {
+                const { id: beatId, inMinutes, placeId, text, everyMinutes, concerns, ...rules } = beat;
+                const typed = engine >= DEADLINE_ENGINE && Object.keys(rules).length > 0;
+                return {
+                    id: generatedId(engine, 'beat', [beatId]), at: definition.startClock + inMinutes, personId: null, kind: 'world',
+                    intent: text, placeId, targetId: engine >= DEADLINE_ENGINE ? concerns ?? null : null, sourceSeq: 0, importance: 5,
+                    ...(everyMinutes === undefined ? {} : { everyMinutes, series: generatedId(engine, 'beat', [beatId]) }),
+                    ...(typed ? { beat: { ...rules, ...(rules.deadline === undefined && rules.then !== undefined ? { deadline: true } : {}) } } : {}),
+                };
+            }),
+        ].sort((a, b) => a.at - b.at || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)),
+        sightings: Object.fromEntries(definition.cast.filter(member => member.knownAtStart || member.placeId === definition.player.placeId).map(member => [member.id, { placeId: member.placeId, at: definition.startClock }])),
+        events: [],
+        stoppingPoint: null,
+        forcedEnding: null,
+        epilogue: null,
+        opening: { ...definition.opening },
+        currency: definition.currency ? { ...definition.currency } : null,
+        ...(definition.accounts.length === 0 ? {} : { accounts: Object.fromEntries(definition.accounts.map(account => [account.id, { ...account }])) }),
+        setting: definition.setting,
+        suggestions: [],
+        kinds: sharedKindMap(engine),
+        kindRequests: [],
+        entities: {},
+        entityPlaceIds: {},
+        globalEntityIds: [],
+        entityMoveSubjectIds: {},
+        globalEntityRefs: {},
+        worldEntityIds: {},
+        meterSchedule: [],
+        changes: [],
+        clockRate: null,
+        paused: false,
+        clockAnchor: null,
+        messageTravel: engine >= MESSAGE_TRAVEL_ENGINE && definition.messages ? { ...definition.messages } : null,
+        chronicle: [],
+        thingNotes: {},
+    };
+    return parseLivingState(state);
+}

package/dist/simulation/living/frame.d.ts

@@ -0,0 +1,259 @@
+import type { LivingEvent } from './types.js';
+import type { LivingState } from './types.js';
+export type LivingPlayerFrame = ReturnType<typeof makeLivingPlayerFrame>;
+export declare function makeLivingPlayerFrame(state: LivingState): {
+    revision: number;
+    status: "open" | "finished";
+    gameKind: string;
+    clock: {
+        minutes: number;
+        label: string;
+        rate: number | null;
+        paused: boolean;
+        anchor: {
+            game: number;
+            real: number;
+        } | null;
+    };
+    player: {
+        id: string;
+        name: string;
+        role: string;
+        summary: string;
+        placeId: string;
+        money: number | null;
+        incapacitated: boolean;
+        condition: string | null;
+        held: {
+            by: string | null;
+            reason: string;
+        } | null;
+        doing: {
+            what: string;
+            until: string;
+        } | null;
+        holding: {
+            id: string;
+            name: string;
+            condition: string;
+        }[];
+    };
+    opening: {
+        title: string;
+        situation: string;
+        stakes: string;
+    };
+    currency: {
+        symbol: string;
+        name: string;
+    } | null;
+    messageTravel: {
+        minutes: number;
+        how: string;
+    } | null;
+    scene: {
+        people: {
+            canTalk: boolean;
+            holding: string[];
+            mood: null;
+            condition: string | null;
+            doing: string | null;
+            held: null;
+            incapacitated: boolean;
+            arrived?: string | undefined;
+            id: string;
+            name: string;
+            role: string;
+            pronouns: string;
+            summary: string;
+        }[];
+        entities: {
+            here: boolean;
+            details: string[];
+            writing: string[];
+            refereeOnly?: {
+                when: string;
+                what: string;
+            } | undefined;
+            properties: {
+                [k: string]: string | number | boolean | undefined;
+            };
+            relations: {
+                [k: string]: string;
+            };
+            members?: string[] | undefined;
+            condition?: string | undefined;
+            holderId?: string | null | undefined;
+            id: string;
+            kindId: string;
+            kindName: string;
+            name: string;
+        }[];
+        id: string;
+        name: string;
+        kind: "private" | "transit" | "room" | "outdoors";
+        summary: string;
+        conditions: string[];
+        objects: {
+            refereeOnly?: {
+                when: string;
+                what: string;
+            } | undefined;
+            id: string;
+            name: string;
+            summary: string;
+            condition: string;
+            singlePersonMovable: boolean;
+            ownerName: string | null;
+        }[];
+        exits: {
+            id: string;
+            name: string;
+        }[];
+    };
+    places: {
+        id: string;
+        name: string;
+        kind: "private" | "transit" | "room" | "outdoors";
+        summary: string;
+        conditions: string[];
+        here: boolean;
+        reachable: boolean;
+        travelMinutes: number | null;
+        knownPeopleIds: string[];
+        connections: string[];
+        introducedAt: number;
+    }[];
+    people: {
+        id: string;
+        name: string;
+        role: string | null;
+        summary: string;
+        arrived: {
+            at: number;
+            label: string;
+        } | null;
+        here: boolean;
+        mood: null;
+        condition: string | null;
+        incapacitated: boolean;
+        lastSeen: {
+            placeId: string;
+            at: number;
+            label: string;
+            current: boolean;
+            heading: boolean;
+            gone: boolean;
+            away: boolean;
+            goneAt: number | null;
+            goneLabel: string | null;
+        } | null;
+        holding: string[];
+    }[];
+    conversation: {
+        id: string;
+        participantIds: string[];
+        ended: boolean;
+        lines: {
+            speaker: string;
+            speakerId: string;
+            to: string[];
+            text: string;
+        }[];
+    } | null;
+    suggestions: string[];
+    deadlines: {
+        what: string;
+        label: string;
+        passed: boolean;
+        averted?: true;
+        unless?: string;
+    }[];
+    votes: {
+        id: string;
+        name: string;
+        question: string;
+        closes: string | null;
+        count: string | null;
+    }[];
+    inbox: {
+        id: string;
+        at: number;
+        label: string;
+        fromId: string;
+        from: string;
+        toIds: string[];
+        to: string[];
+        text: string;
+        mine: boolean;
+        onTheWay: boolean;
+    }[];
+    tensions: {
+        id: string;
+        title: string;
+        summary: string;
+        latest: string | null;
+        status: "settled" | "open";
+        resolution: string | null;
+        participants: string[];
+        sinceLabel: string | null;
+        latestLabel: string | null;
+    }[];
+    recent: {
+        seq: number;
+        at: number;
+        label: string;
+        kind: "message" | "plan" | "finish" | "wait" | "tick" | "world" | "attempt" | "move" | "opening" | "clock" | "arrive" | "speech" | "reaction" | "keep-playing";
+        actorId: string | null;
+        actor: string | null;
+        placeId: string | null;
+        place: string | null;
+        summary: string;
+        narration: string | null;
+        outcome: "failed" | "partial" | "succeeded" | "impossible" | null;
+        mine: boolean;
+        noticed: boolean;
+        changes: string[];
+    }[];
+    engine: number;
+    stoppingPoint: {
+        at: number;
+        tensionId: string;
+        title: string;
+        summary: string;
+        label: string;
+    } | null;
+    forcedEnding: string | null;
+    epilogue: {
+        label: string;
+        title: string;
+        text: string;
+        at: number;
+        verdict?: string | undefined;
+        highlights?: string[] | undefined;
+        cast?: {
+            name: string;
+            line: string;
+        }[] | undefined;
+        closing?: string | undefined;
+    } | null;
+};
+export declare function livingPlayerFeed(state: LivingState, events: readonly LivingEvent[]): LivingFeedItem[];
+export type LivingFeedItem = ReturnType<typeof feedItem>;
+declare function feedItem(state: LivingState, event: LivingEvent): {
+    seq: number;
+    at: number;
+    label: string;
+    kind: "message" | "plan" | "finish" | "wait" | "tick" | "world" | "attempt" | "move" | "opening" | "clock" | "arrive" | "speech" | "reaction" | "keep-playing";
+    actorId: string | null;
+    actor: string | null;
+    placeId: string | null;
+    place: string | null;
+    summary: string;
+    narration: string | null;
+    outcome: "failed" | "partial" | "succeeded" | "impossible" | null;
+    mine: boolean;
+    noticed: boolean;
+    changes: string[];
+};
+export {};