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

package/dist/simulation/living/frame.js

@@ -0,0 +1,223 @@
+import { avertedAhead, clockLabel, describeScene, openVotes, personLabel } from './context.js';
+import { heldHere } from './mechanics.js';
+import { travelPath, TRAVEL_MINUTES_PER_HOP } from './reduce.js';
+import { knowsCustody, observedSummary, visibleTo, witnessed } from './projection.js';
+export function makeLivingPlayerFrame(state) {
+    const player = state.people[state.playerId];
+    const scene = describeScene(state, player.placeId, player.id);
+    const places = Object.values(state.places).map((place) => {
+        const path = travelPath(state, player.placeId, place.id);
+        const people = Object.entries(state.sightings).filter(([, sighting]) => sighting.placeId === place.id).map(([id]) => id);
+        return {
+            id: place.id, name: place.name, kind: place.kind, summary: place.summary, conditions: place.id === player.placeId ? [...place.conditions] : [],
+            here: place.id === player.placeId, reachable: path !== null, travelMinutes: path === null ? null : (path.length - 1) * TRAVEL_MINUTES_PER_HOP,
+            knownPeopleIds: people, connections: [...place.connections], introducedAt: place.introducedAt,
+        };
+    });
+    // Someone who left the world, or is away for a while, is not here, though the player may still recall where they last saw them.
+    const present = (person) => person.placeId === player.placeId && person.departed === undefined && person.away === undefined;
+    // The player knows whoever they have seen, and whoever they have written to or heard from.
+    const correspondents = new Set(state.messages.flatMap(message => message.fromId === player.id ? message.toIds
+        : message.toIds.includes(player.id) ? [message.fromId] : []));
+    const people = Object.values(state.people).filter(person => !person.isPlayer && (present(person) || state.sightings[person.id] || correspondents.has(person.id))).map((person) => {
+        const sighting = state.sightings[person.id] ?? null;
+        const here = present(person);
+        return {
+            id: person.id, name: person.name, role: here ? person.role : null, summary: person.summary,
+            // When someone brought in mid-story came.
+            arrived: person.arrivedAt === undefined ? null : { at: person.arrivedAt, label: clockLabel(person.arrivedAt) },
+            here, mood: null, condition: here ? person.condition ?? null : null, incapacitated: here ? person.incapacitated : false,
+            lastSeen: sighting ? { placeId: sighting.placeId, at: sighting.at, label: clockLabel(sighting.at), current: here || sighting.at === state.clock, heading: sighting.heading === true, gone: !here && sighting.gone === true, away: !here && sighting.away === true,
+                // When the player found them no longer there, where the world kept that.
+                goneAt: !here && sighting.gone === true && sighting.goneAt !== undefined ? sighting.goneAt : null,
+                goneLabel: !here && sighting.gone === true && sighting.goneAt !== undefined ? clockLabel(sighting.goneAt) : null } : null,
+            holding: here ? Object.values(state.objects).filter(object => object.holderId === person.id && knowsCustody(state, object, player.id)).map(object => object.name) : [],
+        };
+    });
+    // The player sees what happened in front of them, and what reached them from nearby.
+    const seen = state.events.filter(event => visibleTo(event, player.id));
+    // A long act the player has under way here, and when its end comes.
+    const underWay = state.schedule.find(item => item.kind === 'finish' && item.targetId === player.id && item.placeId === player.placeId);
+    const doing = underWay ? { what: underWay.intent, until: clockLabel(underWay.at) } : null;
+    // Where messages travel, the player's own count from when they were sent, and those still on the way say so.
+    const travel = state.messageTravel?.minutes ?? 0;
+    const letter = (id, at, fromId, toIds, text, onTheWay) => ({
+        id, at, label: clockLabel(at), fromId, from: personLabel(state, fromId), toIds: [...toIds], to: toIds.map(id => personLabel(state, id)), text, mine: fromId === player.id, onTheWay,
+    });
+    const inbox = [
+        ...state.messages.filter(message => message.fromId === player.id || message.toIds.includes(player.id))
+            .map(message => letter(message.id, message.fromId === player.id ? message.at - travel : message.at, message.fromId, message.toIds, message.text, false)),
+        ...state.schedule.flatMap(item => item.kind === 'deliver' && item.delivery?.fromId === player.id
+            ? [letter(item.id, item.at - travel, player.id, item.delivery.toIds, item.delivery.text, true)] : []),
+    ].sort((left, right) => left.at - right.at);
+    // The thread stays readable after the other person walks out: the latest conversation here that the
+    // player took part in since they last came in, open or ended.
+    const arrivedAt = [...state.events].reverse().find(event => event.actorId === player.id && event.effects.some(effect => effect.kind === 'move'))?.at ?? 0;
+    const openConversation = [...state.conversations].reverse().find(conversation => conversation.placeId === player.placeId && conversation.participantIds.includes(player.id) && (conversation.endedAt === null || conversation.lines.some(line => line.at >= arrivedAt))) ?? null;
+    const heardLines = new Set(state.events.filter(event => witnessed(event, player.id) || event.actorId === player.id).map(event => event.seq));
+    // Every line the player heard here since they came in, whichever conversation carried it.
+    const talkHere = state.conversations.filter(conversation => conversation.placeId === player.placeId
+        && conversation.lines.some(line => line.at >= arrivedAt && heardLines.has(line.seq)));
+    const shownThread = openConversation ?? talkHere.at(-1) ?? null;
+    const heardHere = talkHere.flatMap(conversation => conversation.lines).filter(line => line.at >= arrivedAt && heardLines.has(line.seq))
+        .sort((left, right) => left.seq - right.seq);
+    return {
+        revision: state.revision,
+        status: state.status,
+        gameKind: state.gameKind,
+        // A live world's clock runs between events: the browser moves it from the anchor at the rate.
+        clock: { minutes: state.clock, label: clockLabel(state.clock), rate: state.clockRate, paused: state.paused, anchor: state.clockAnchor ? { ...state.clockAnchor } : null },
+        player: { id: player.id, name: player.name, role: player.role, summary: player.summary, placeId: player.placeId, money: player.money, incapacitated: player.incapacitated, condition: player.condition ?? null, held: player.held && heldHere(state, player.id) ? { by: player.held.byId ? personLabel(state, player.held.byId) : null, reason: player.held.reason } : null,
+            doing,
+            holding: [...Object.values(state.objects).filter(object => object.holderId === player.id).map(object => ({ id: object.id, name: object.name, condition: object.condition })),
+                ...(state.entityPlaceIds[player.placeId] ?? []).filter(id => state.entities[id].holderId === player.id)
+                    .map(id => ({ id, name: state.entities[id].name, condition: state.kinds[state.entities[id].kindId]?.name ?? '' }))] },
+        opening: { ...state.opening },
+        currency: state.currency ? { ...state.currency } : null,
+        // How messages travel here and how long they take; null when they arrive at once.
+        messageTravel: state.messageTravel ? { ...state.messageTravel } : null,
+        scene: { ...scene, people: scene.people.map(person => ({ ...person, canTalk: !person.incapacitated })),
+            // A thing lying here, apart from a deal or claim that is in play but at no place.
+            entities: scene.entities.map(entity => ({ ...entity, here: state.entities[entity.id]?.placeId === scene.id, details: readableDetails(state, entity, player.id), writing: writtenWords(state, entity) })) },
+        places,
+        people,
+        conversation: shownThread ? { id: shownThread.id, participantIds: [...new Set(talkHere.flatMap(conversation => conversation.participantIds))], ended: shownThread.endedAt !== null,
+            lines: (openConversation && heardHere.length === 0 ? openConversation.lines.filter(line => heardLines.has(line.seq)) : heardHere).slice(-60)
+                .map(line => ({ speaker: personLabel(state, line.speakerId), speakerId: line.speakerId, to: line.toIds.map(id => personLabel(state, id)), text: line.text })) } : null,
+        suggestions: [...state.suggestions],
+        // The world's public deadlines, as everyone counts them: the four nearest ahead and those passed
+        // within the day, each at its time. What came of one is learned only by seeing it.
+        // One averted says so; one whose problem is already settled is no longer ahead; one ahead names the
+        // problem that would avert it, as the player knows that problem.
+        deadlines: [
+            ...(state.passedDeadlines ?? []).filter(entry => state.clock - entry.at <= 1440).slice(-3)
+                .map(entry => ({ what: entry.what, label: clockLabel(entry.at), passed: true, ...(entry.averted ? { averted: true } : {}) })),
+            ...state.schedule.filter(item => item.kind === 'world' && item.beat?.deadline && !avertedAhead(state, item)).sort((left, right) => left.at - right.at).slice(0, 4)
+                .map(item => {
+                const unless = item.beat?.unless ? state.tensions.find(tension => tension.id === item.beat.unless.settled)?.playerView?.title : undefined;
+                return { what: item.intent, label: clockLabel(item.at), passed: false, ...(unless ? { unless } : {}) };
+            }),
+        ],
+        // The votes open to the player now, which they cast with a vote command.
+        votes: (openVotes(state, player.id).votes ?? []).map(vote => ({ id: vote.id, name: state.entities[vote.id].name, question: vote.question, closes: vote.closes, count: vote.count })),
+        inbox,
+        tensions: state.tensions.filter(tension => tension.playerView !== null).map(tension => ({ id: tension.id, title: tension.playerView.title, summary: tension.playerView.summary, latest: tension.playerView.latest ?? null, status: tension.playerView.status, resolution: tension.playerView.resolution, participants: tension.participantIds.filter(id => state.sightings[id] || id === player.id).map(id => personLabel(state, id)),
+            // When the player learned what the summary says, and when they saw the latest development.
+            sinceLabel: tension.playerView.since === undefined ? null : clockLabel(tension.playerView.since),
+            latestLabel: tension.playerView.latest && tension.playerView.latestAt !== undefined ? clockLabel(tension.playerView.latestAt) : null })),
+        recent: seen.slice(-40).map(event => feedItem(state, event)),
+        engine: state.engine,
+        stoppingPoint: state.stoppingPoint && state.tensions.find(tension => tension.id === state.stoppingPoint.tensionId)?.playerView?.status === 'settled'
+            ? { at: state.stoppingPoint.at, tensionId: state.stoppingPoint.tensionId,
+                title: state.tensions.find(tension => tension.id === state.stoppingPoint.tensionId).playerView.title,
+                summary: state.tensions.find(tension => tension.id === state.stoppingPoint.tensionId).playerView.resolution ?? '',
+                label: clockLabel(state.stoppingPoint.at) } : null,
+        forcedEnding: state.forcedEnding,
+        epilogue: state.epilogue ? { ...state.epilogue, label: clockLabel(state.epilogue.at) } : null,
+    };
+}
+// What the player's person perceived, in order: what happened in front of them, their own acts,
+// and what reached them from elsewhere, including anything carried to every place.
+export function livingPlayerFeed(state, events) {
+    return events.filter(event => visibleTo(event, state.playerId)).map(event => feedItem(state, event));
+}
+// A thing's details as the player reads them: names instead of ids, clock times, and yes or no.
+function readableDetails(state, entity, viewerId) {
+    const nameOf = (id) => id === viewerId ? 'you'
+        : state.people[id]?.name ?? state.places[id]?.name ?? state.objects[id]?.name
+            ?? (state.entities[id]?.knownTo.includes(viewerId) ? state.entities[id].name : null);
+    const held = [...(entity.condition ? [entity.condition] : []), ...(entity.holderId ? [`held by ${nameOf(entity.holderId) ?? 'someone'}`] : [])];
+    return [...held, ...(state.kinds[entity.kindId]?.properties ?? []).flatMap((property) => {
+            const value = entity.properties[property.id];
+            if (value === undefined || value === null)
+                return [];
+            const label = property.id.replaceAll('-', ' ');
+            switch (property.type) {
+                case 'flag': return [value === true ? label : `not ${label}`];
+                case 'time': return typeof value === 'number' ? [`${label}: ${clockLabel(value)}`] : [];
+                case 'id': {
+                    const name = nameOf(String(value));
+                    return name === null ? [] : [`${label}: ${name}`];
+                }
+                case 'text': return [];
+                default: return [`${label}: ${String(value)}`];
+            }
+        })];
+}
+// What is written on a thing, read as its words rather than as one of its facts.
+function writtenWords(state, entity) {
+    return (state.kinds[entity.kindId]?.properties ?? []).flatMap(property => {
+        const value = entity.properties[property.id];
+        return property.type === 'text' && typeof value === 'string' && value !== '' ? [value] : [];
+    });
+}
+function feedItem(state, event) {
+    const player = state.people[state.playerId];
+    // Something noticed from another room shows only what reached the player, not what happened.
+    const noticed = !witnessed(event, player.id) && event.actorId !== player.id && event.nearbyIds.includes(player.id);
+    // A message that reached the player from elsewhere shows as the message, with its sender and words.
+    const letters = !witnessed(event, player.id) && event.actorId !== player.id && !noticed
+        ? event.effects.flatMap(effect => effect.kind === 'message' && effect.toIds.includes(player.id) ? [`${personLabel(state, effect.fromId)} messages you: "${effect.text}"`] : []) : [];
+    if (letters.length > 0) {
+        return { seq: event.seq, at: event.at, label: clockLabel(event.at), kind: event.kind, actorId: event.actorId, actor: event.actorId ? personLabel(state, event.actorId) : null,
+            placeId: null, place: null, summary: letters.join(' ').slice(0, 2000), narration: null, outcome: null, mine: false, noticed: false, changes: [] };
+    }
+    const from = event.placeId ? state.places[event.placeId]?.name ?? null : null;
+    const arrival = noticed ? arrivalNotice(state, event) : null;
+    const notice = arrival ?? `From ${from ?? 'nearby'}: ${event.notice ?? 'a commotion'}`;
+    // An arrival is logged under the room it arrived in, which is where the player saw it.
+    const arrivedInto = arrival ? event.effects.find(effect => effect.kind === 'move') : undefined;
+    const place = arrivedInto && arrivedInto.kind === 'move' ? state.places[arrivedInto.placeId]?.name ?? from : from;
+    // The player's own act reads as the Game Master told it to them; others' acts as they looked.
+    const mine = event.actorId === player.id;
+    const told = mine ? event.narration : null;
+    // A long act of theirs that this set aside is named, with when it began.
+    const leftOff = mine ? event.effects.flatMap(effect => effect.kind === 'unschedule' && effect.leftOff
+        ? [`You leave off: "${effect.leftOff.intent}" (begun ${clockLabel(effect.leftOff.begunAt)}).`] : []) : [];
+    return {
+        seq: event.seq, at: event.at, label: clockLabel(event.at), kind: event.kind, actorId: noticed ? null : event.actorId, actor: noticed || !event.actorId ? null : personLabel(state, event.actorId),
+        placeId: event.placeId, place, summary: noticed ? notice : told ?? observedSummary(event, player.id), narration: noticed ? notice : told ?? event.observed ?? event.narration, outcome: noticed || event.observed !== undefined ? null : event.outcome, mine, noticed,
+        changes: [...leftOff, ...(noticed || event.observed !== undefined ? [] : event.effects.filter(effect => ['move', 'object.update', 'object.create', 'entity.move', 'entity.condition', 'place.condition', 'money', 'transfer', 'person.condition', 'incapacitate'].includes(effect.kind)).map(effect => describeEffect(state, effect)))],
+    };
+}
+// Someone who walked into the player's room is seen arriving; the room they came from is the event's place.
+function arrivalNotice(state, event) {
+    const move = event.effects.find(effect => effect.kind === 'move' && effect.personId !== state.playerId);
+    if (!move || move.kind !== 'move' || event.reach !== 'here')
+        return null;
+    return `${personLabel(state, move.personId)} comes in from ${event.placeId ? state.places[event.placeId]?.name ?? event.placeId : 'elsewhere'}.`;
+}
+function describeEffect(state, effect) {
+    const name = (id) => personLabel(state, id);
+    const place = (id) => state.places[id]?.name ?? id;
+    const moneyHolder = (id) => state.accounts?.[id]?.name ?? name(id);
+    switch (effect.kind) {
+        case 'move': return `${name(effect.personId)} goes to ${place(effect.placeId)}`;
+        case 'message': return `${name(effect.fromId)} messages ${effect.toIds.map(name).join(', ')}`;
+        case 'entity.move': return `${state.entities[effect.entityId]?.name ?? effect.entityId}${effect.holderId ? `, held by ${name(effect.holderId)}` : ` is set down at ${place(effect.placeId ?? '')}`}`;
+        case 'entity.condition': return `${state.entities[effect.entityId]?.name ?? effect.entityId} is now ${effect.condition}`;
+        case 'object.update': return `${state.objects[effect.objectId]?.name ?? effect.objectId}${effect.condition ? ` is now ${effect.condition}` : ''}${effect.holderId ? `, held by ${name(effect.holderId)}` : ''}${effect.placeId ? `, at ${place(effect.placeId)}` : ''}${effect.ownerId ? `, claimed by ${name(effect.ownerId)}` : ''}`;
+        case 'object.create': return `${effect.name} appears${effect.placeId ? ` at ${place(effect.placeId)}` : effect.holderId ? ` with ${name(effect.holderId)}` : ''}`;
+        case 'place.condition': return `${place(effect.placeId)}: ${effect.add ? `now ${effect.add}` : ''}${effect.add && effect.remove ? '; ' : ''}${effect.remove ? `no longer ${effect.remove}` : ''}`;
+        case 'place.create': return `A new place: ${effect.name}`;
+        case 'person.create': return `${effect.name} (${effect.role}) arrives at ${place(effect.placeId)}`;
+        case 'money': return `${name(effect.personId)} ${effect.delta < 0 ? 'pays' : 'receives'} ${Math.abs(effect.delta)}`;
+        case 'transfer': return effect.fromId === null ? `${moneyHolder(effect.toId)} receives ${effect.amount}` : effect.toId === null ? `${moneyHolder(effect.fromId)} pays ${effect.amount}`
+            : `${moneyHolder(effect.fromId)} pays ${effect.amount} to ${moneyHolder(effect.toId)}`;
+        case 'relationship': return `${name(effect.personId)}'s view of ${name(effect.targetId)} shifts`;
+        case 'belief': return `${name(effect.personId)} now believes: ${effect.claim}`;
+        case 'commitment': return `${name(effect.personId)} promises ${name(effect.toId)}: ${effect.text}`;
+        case 'commitment.update': return `${name(effect.personId)} has ${effect.status} a promise`;
+        case 'goal': return effect.add ? `${name(effect.personId)} sets out to ${effect.add}` : `${name(effect.personId)} drops a goal`;
+        case 'mood': return `${name(effect.personId)} seems ${effect.mood.toLowerCase()}`;
+        case 'hold': return effect.reason ? `${name(effect.personId)} is held: ${effect.reason}` : `${name(effect.personId)} is free to go`;
+        case 'role': return `${name(effect.personId)} is now ${effect.role.toLowerCase()}`;
+        case 'person.condition': return effect.condition ? `${name(effect.personId)}: ${effect.condition}` : `${name(effect.personId)} is no longer marked`;
+        case 'fact': return effect.add ? `It is now known: ${effect.add}` : `No longer true: ${effect.remove}`;
+        case 'tension.create': return `A new problem: ${effect.title}`;
+        case 'tension.update': return effect.status === 'settled' ? `Settled: ${state.tensions.find(tension => tension.id === effect.tensionId)?.title ?? effect.tensionId}` : `Changed: ${state.tensions.find(tension => tension.id === effect.tensionId)?.title ?? effect.tensionId}`;
+        case 'incapacitate': return `${name(effect.personId)} can no longer act: ${effect.reason}`;
+        case 'conversation.end': return 'The conversation ends';
+        default: return effect.kind;
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare const BOUNDED_IDENTIFIERS_ENGINE = 51;
+export declare function generatedId(engine: number, family: string, parts: readonly (string | number)[], legacy?: string, framed?: boolean): string;

package/dist/simulation/living/identifiers.js

@@ -0,0 +1,12 @@
+import { createHash } from 'node:crypto';
+export const BOUNDED_IDENTIFIERS_ENGINE = 51;
+// Keep semantic prefixes, but hash framed components so neither long IDs nor hyphens alias.
+// Historical reducers must reproduce their original spelling, including their old truncation.
+export function generatedId(engine, family, parts, legacy = `${family}-${parts.join('-')}`, framed = false) {
+    if (engine < BOUNDED_IDENTIFIERS_ENGINE)
+        return legacy;
+    // Reserve exactly 64 characters for hashes. Short legacy spellings cannot impersonate one.
+    if (!framed && legacy.length < 64)
+        return legacy;
+    return `${family}-${createHash('sha256').update(JSON.stringify([family, ...parts])).digest('hex').slice(0, 63 - family.length)}`;
+}

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

@@ -0,0 +1,15 @@
+export { modelContextPeople } from './context.js';
+export { assertLivingModelCall, LIVING_INPUT_BUDGETS, LIVING_RESPONSE_SCHEMA_BUDGET, MODEL_VIEW_NOTE, modelTextExcerpt } from './model-input.js';
+export * from './types.js';
+export { defineLivingKind, kindDefinitionResponseSchema, DEFINER_SYSTEM } from './definer.js';
+export { kindDefinitionSchema, kindRequestSchema, type LivingKindDefinition } from './open-world.js';
+export { definitionSchema, parseLivingWorldDefinition, createLivingState, type LivingWorldDefinition, type LivingWorldDefinitionInput } from './definition.js';
+export { applyLivingEvent, clockTargetAt, livingClockLead, peopleAt, witnessesFor, nearbyFor, arrivalFor, travelPath, unansweredSince, TRAVEL_MINUTES_PER_HOP } from './reduce.js';
+export { recallMemories, recallBeliefs, type RecalledMemory } from './recall.js';
+export { LIVING_INFERENCE_LIMITS, GM_EFFECT_KINDS, gmEffectSchema, attemptResponseSchema, scopedAttemptResponseSchema, reactionResponseSchema, scopedReactionResponseSchema, speechImpactResponseSchema, planResponseSchema, scopedPlanResponseSchema, messageReplyResponseSchema, epilogueResponseSchema, type LivingInference, type LivingInferenceCall, type LivingInferenceRole, type GmEffectRecord, } from './inference.js';
+export { clockLabel, describeScene, gameMasterAttemptInput, gameMasterWorldInput, characterReactionInput, characterPlanInput, characterMessageReplyInput, epilogueInput, pressingMatters, joinedPlaceSeq, conversationLines, recentLinesBy, GAME_MASTER_SYSTEM, SPEECH_IMPACT_SYSTEM, CHARACTER_REACTION_SYSTEM, CHARACTER_PLAN_SYSTEM, CHARACTER_MESSAGE_SYSTEM, NARRATOR_EPILOGUE_SYSTEM, PRESSING_MINUTES, PRESSING_IMPORTANCE, } from './context.js';
+export { startLivingWorld, runLivingCommand, translateGmEffect, livingClockTarget, setLivingClock, tickLivingWorld, livingDueWork, runLivingWork, advanceLivingWorld, carryOnLivingWork, livingWorkIsRoutine, DEFAULT_ACTIVITY_MINUTES, type LivingWorldCell, type LivingWork, MAX_DUE_ITEMS_PER_STEP, MAX_REACTORS, MAX_MODEL_CALLS_PER_COMMAND, SHOCK_IMPORTANCE, SPEECH_MINUTES, MESSAGE_MINUTES, MESSAGE_REPLY_DELAY_MINUTES, IDLE_WAIT_MINUTES, PLAYER_MAX_TEXT_BYTES, type LivingCommand, type LivingStep, type LivingAuditRecord, } from './runtime.js';
+export { replayLivingWorld, verifyLivingWorld } from './replay.js';
+export { makeLivingPlayerFrame, livingPlayerFeed, type LivingPlayerFrame, type LivingFeedItem } from './frame.js';
+export { blockedActionKinds, blockedByGate, gatesOn } from './mechanics.js';
+export { sharedKindMap } from './shared-kinds.js';

package/dist/simulation/living/index.js

@@ -0,0 +1,15 @@
+export { modelContextPeople } from './context.js';
+export { assertLivingModelCall, LIVING_INPUT_BUDGETS, LIVING_RESPONSE_SCHEMA_BUDGET, MODEL_VIEW_NOTE, modelTextExcerpt } from './model-input.js';
+export * from './types.js';
+export { defineLivingKind, kindDefinitionResponseSchema, DEFINER_SYSTEM } from './definer.js';
+export { kindDefinitionSchema, kindRequestSchema } from './open-world.js';
+export { definitionSchema, parseLivingWorldDefinition, createLivingState } from './definition.js';
+export { applyLivingEvent, clockTargetAt, livingClockLead, peopleAt, witnessesFor, nearbyFor, arrivalFor, travelPath, unansweredSince, TRAVEL_MINUTES_PER_HOP } from './reduce.js';
+export { recallMemories, recallBeliefs } from './recall.js';
+export { LIVING_INFERENCE_LIMITS, GM_EFFECT_KINDS, gmEffectSchema, attemptResponseSchema, scopedAttemptResponseSchema, reactionResponseSchema, scopedReactionResponseSchema, speechImpactResponseSchema, planResponseSchema, scopedPlanResponseSchema, messageReplyResponseSchema, epilogueResponseSchema, } from './inference.js';
+export { clockLabel, describeScene, gameMasterAttemptInput, gameMasterWorldInput, characterReactionInput, characterPlanInput, characterMessageReplyInput, epilogueInput, pressingMatters, joinedPlaceSeq, conversationLines, recentLinesBy, GAME_MASTER_SYSTEM, SPEECH_IMPACT_SYSTEM, CHARACTER_REACTION_SYSTEM, CHARACTER_PLAN_SYSTEM, CHARACTER_MESSAGE_SYSTEM, NARRATOR_EPILOGUE_SYSTEM, PRESSING_MINUTES, PRESSING_IMPORTANCE, } from './context.js';
+export { startLivingWorld, runLivingCommand, translateGmEffect, livingClockTarget, setLivingClock, tickLivingWorld, livingDueWork, runLivingWork, advanceLivingWorld, carryOnLivingWork, livingWorkIsRoutine, DEFAULT_ACTIVITY_MINUTES, MAX_DUE_ITEMS_PER_STEP, MAX_REACTORS, MAX_MODEL_CALLS_PER_COMMAND, SHOCK_IMPORTANCE, SPEECH_MINUTES, MESSAGE_MINUTES, MESSAGE_REPLY_DELAY_MINUTES, IDLE_WAIT_MINUTES, PLAYER_MAX_TEXT_BYTES, } from './runtime.js';
+export { replayLivingWorld, verifyLivingWorld } from './replay.js';
+export { makeLivingPlayerFrame, livingPlayerFeed } from './frame.js';
+export { blockedActionKinds, blockedByGate, gatesOn } from './mechanics.js';
+export { sharedKindMap } from './shared-kinds.js';

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

@@ -0,0 +1,219 @@
+export type LivingInferenceRole = 'game-master' | 'character' | 'narrator' | 'definer';
+export type LivingInferenceCall = {
+    role: LivingInferenceRole;
+    actorId?: string | null;
+    revision?: number;
+    inputRefs?: readonly {
+        path: string;
+        inputSha256: string;
+        kind: string;
+        id: string;
+        evidenceEventSeq: number;
+    }[];
+    phase: 'attempt' | 'world' | 'speech-impact' | 'reaction' | 'reply' | 'plan' | 'epilogue' | 'message-reply' | 'define';
+    system: string;
+    input: Readonly<Record<string, unknown>>;
+    responseSchema: Readonly<Record<string, unknown>>;
+    maxTokens: number;
+    timeoutMs: number;
+    reserveRetry?: () => boolean;
+    stillWanted?: () => boolean;
+    rebuild?: () => Pick<LivingInferenceCall, 'input' | 'responseSchema' | 'inputRefs' | 'revision'>;
+};
+export interface LivingInference {
+    complete(call: LivingInferenceCall): Promise<unknown>;
+}
+export declare const LIVING_INFERENCE_LIMITS: Readonly<{
+    attempt: {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    world: {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    'speech-impact': {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    reaction: {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    reply: {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    plan: {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    'message-reply': {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    epilogue: {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+    define: {
+        maxTokens: number;
+        timeoutMs: number;
+    };
+}>;
+export declare const GM_EFFECT_KINDS: readonly ["move", "take", "drop", "object.update", "object.create", "place.condition", "place.create", "person.create", "money", "transfer", "relationship", "belief", "commitment", "goal", "mood", "person.condition", "hold", "role", "schedule", "fact", "tension.update", "tension.create", "incapacitate", "message", "entity.create", "property.set", "relation.set", "request.open", "person.leave", "person.away", "ballot"];
+export declare function kindFirst(container: string): (arm: {
+    required: readonly string[];
+    properties: Record<string, unknown>;
+}) => Record<string, unknown>;
+export declare const gmEffectSchema: {
+    anyOf: Record<string, unknown>[];
+};
+export declare function responseFieldLines(schema: {
+    properties: Record<string, {
+        description?: string;
+    }>;
+}): string;
+export type GmEffectRecord = {
+    kind: typeof GM_EFFECT_KINDS[number];
+    personId: string | null;
+    targetId: string | null;
+    sourcePersonId?: string | null;
+    placeId: string | null;
+    objectId: string | null;
+    tensionId: string | null;
+    name: string | null;
+    text: string | null;
+    condition: string | null;
+    role?: string | null;
+    amount: number | null;
+    trust: number | null;
+    warmth: number | null;
+    minutes: number | null;
+    connections: string[] | null;
+    participantIds: string[] | null;
+    status: 'open' | 'settled' | null;
+    entityId?: string | null;
+    kindId?: string | null;
+    propertyId?: string | null;
+    relationId?: string | null;
+    roleId?: string | null;
+    priorId?: string | null;
+    value?: boolean | number | string | null;
+    initialProperties?: Record<string, boolean | number | string>;
+    choice?: 'yes' | 'no' | 'abstain' | null;
+};
+export declare const SIGNAL_SENSES: readonly ["sound", "voices", "shouting", "scream", "crash", "bang", "alarm", "machinery", "footsteps", "music", "loudspeaker", "sight", "light", "smoke", "burning", "smell"];
+export declare const SIGNAL_NOTICES: Readonly<Record<typeof SIGNAL_SENSES[number], string>>;
+export declare const attemptResponseSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["narration", "record", "observed", "perceivedBy", "visibleObjectIds", "visibleTensionIds", "outcome", "minutes", "importance", "reach", "signalChannel", "actionKind", "reactorIds", "settledTensionId", "settlement", "newTension", "stateKindFit", "stateNewKind", "stateUpdates", "thingIds"];
+    readonly properties: {
+        readonly narration: Record<string, unknown>;
+        readonly record: Record<string, unknown>;
+        readonly observed: Record<string, unknown>;
+        readonly perceivedBy: Record<string, unknown>;
+        readonly visibleObjectIds: Record<string, unknown>;
+        readonly visibleTensionIds: Record<string, unknown>;
+        readonly outcome: Record<string, unknown>;
+        readonly minutes: Record<string, unknown>;
+        readonly importance: Record<string, unknown>;
+        readonly reach: Record<string, unknown>;
+        readonly signalChannel: Record<string, unknown>;
+        readonly actionKind: Record<string, unknown>;
+        readonly reactorIds: Record<string, unknown>;
+        readonly settledTensionId: Record<string, unknown>;
+        readonly settlement: Record<string, unknown>;
+        readonly newTension: Record<string, unknown>;
+        readonly stateKindFit: Record<string, unknown>;
+        readonly stateNewKind: Record<string, unknown>;
+        readonly stateUpdates: Record<string, unknown>;
+        readonly thingIds: Record<string, unknown>;
+    };
+};
+export declare function scopedAttemptResponseSchema(input: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+export declare const reactionResponseSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["say", "act", "toIds", "mood", "weight", "leaveToPlaceId", "trust", "warmth", "relationshipNote", "belief", "commitment", "newGoal", "goalDone", "plan", "tell", "suggestedReplies", "endConversation", "request", "requestDecision", "answered", "stance"];
+    readonly properties: {
+        readonly say: Record<string, unknown>;
+        readonly request: Record<string, unknown>;
+        readonly requestDecision: Record<string, unknown>;
+        readonly answered: Record<string, unknown>;
+        readonly act: Record<string, unknown>;
+        readonly toIds: Record<string, unknown>;
+        readonly mood: Record<string, unknown>;
+        readonly weight: Record<string, unknown>;
+        readonly stance: Record<string, unknown>;
+        readonly leaveToPlaceId: Record<string, unknown>;
+        readonly trust: Record<string, unknown>;
+        readonly warmth: Record<string, unknown>;
+        readonly relationshipNote: Record<string, unknown>;
+        readonly belief: Record<string, unknown>;
+        readonly commitment: Record<string, unknown>;
+        readonly newGoal: Record<string, unknown>;
+        readonly goalDone: Record<string, unknown>;
+        readonly plan: Record<string, unknown>;
+        readonly tell: Record<string, unknown>;
+        readonly suggestedReplies: Record<string, unknown>;
+        readonly endConversation: Record<string, unknown>;
+    };
+};
+export declare const ENGINE_ACTION_KINDS: ReadonlySet<string>;
+export declare function scopedReactionResponseSchema(input: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+export declare function scopedPlanResponseSchema(input: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+export declare const speechImpactResponseSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["importance", "pressure", "loud", "addressedIds", "aboutIds"];
+    readonly properties: {
+        readonly importance: Record<string, unknown>;
+        readonly pressure: Record<string, unknown>;
+        readonly loud: Record<string, unknown>;
+        readonly addressedIds: Record<string, unknown>;
+        readonly aboutIds: Record<string, unknown>;
+    };
+};
+export declare function scopedSpeechImpactResponseSchema(presentIds: readonly string[], thingIds?: readonly string[]): Readonly<Record<string, unknown>>;
+export declare const planResponseSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["action", "placeId", "targetId", "text", "mood", "nextPlan", "request", "stance"];
+    readonly properties: {
+        readonly action: Record<string, unknown>;
+        readonly placeId: Record<string, unknown>;
+        readonly targetId: Record<string, unknown>;
+        readonly text: Record<string, unknown>;
+        readonly request: Record<string, unknown>;
+        readonly mood: Record<string, unknown>;
+        readonly nextPlan: Record<string, unknown>;
+        readonly stance: Record<string, unknown>;
+    };
+};
+export declare const messageReplyResponseSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["reply", "mood", "trust", "warmth", "belief", "plan"];
+    readonly properties: {
+        readonly reply: Record<string, unknown>;
+        readonly mood: Record<string, unknown>;
+        readonly trust: Record<string, unknown>;
+        readonly warmth: Record<string, unknown>;
+        readonly belief: Record<string, unknown>;
+        readonly plan: Record<string, unknown>;
+    };
+};
+export declare const epilogueResponseSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["title", "verdict", "highlights", "cast", "closing"];
+    readonly properties: {
+        readonly title: Record<string, unknown>;
+        readonly verdict: Record<string, unknown>;
+        readonly highlights: Record<string, unknown>;
+        readonly cast: Record<string, unknown>;
+        readonly closing: Record<string, unknown>;
+    };
+};