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

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

@@ -0,0 +1,54 @@
+import type { z } from 'zod';
+import type { propertyValueSchema } from './open-world.js';
+import { type LivingEffect, type LivingState } from './types.js';
+type PropertyValue = z.infer<typeof propertyValueSchema>;
+declare const LEVELS: readonly ["none", "low", "medium", "high"];
+type Level = typeof LEVELS[number];
+export type LivingSignal = {
+    sourcePlaceId: string | null;
+    targetPlaceId: string | null;
+    channel: string;
+    sourceId: string;
+};
+export declare const GLOBAL_SIGNAL_CHANNEL = "global";
+export declare function signalsFor(state: LivingState, effects: readonly LivingEffect[]): LivingSignal[];
+export declare function signalNotice(state: LivingState, effects: readonly LivingEffect[], observed?: string | null): string | null;
+export declare function importanceFloorForEffects(state: LivingState, effects: readonly LivingEffect[]): number;
+export declare const PEEK_ENTITY: unique symbol;
+export declare function readEntity(state: LivingState, entityId: string): LivingState['entities'][string] | undefined;
+export declare function nearWithMechanic(state: LivingState, nearIds: Iterable<string>, placeId: string | null, mechanicKind: string): string[];
+export declare function placelessNear(state: LivingState, nearIds: Iterable<string>, newestPerName?: number): string[];
+export declare function unindexPlaceless(state: LivingState, entityId: string): void;
+export declare function indexPlaceless(state: LivingState, entityId: string): void;
+export declare function reindexPlaceless(state: LivingState, entityId: string, previousRefs: readonly string[]): void;
+export declare function gatesOn(state: LivingState, subjectId: string): {
+    entityId: string;
+    name: string;
+    propertyId: string;
+    actionKinds: readonly string[];
+    keeperIds: readonly string[];
+}[];
+export declare function gatesAgainst(state: LivingState, subjectId: string, actionKind: string): ReturnType<typeof gatesOn>;
+export declare function heldHere(state: LivingState, personId: string): boolean;
+export declare function blockedByGate(state: LivingState, subjectId: string, actionKind: string): string | null;
+export declare function blockedActionKinds(state: LivingState, subjectId: string): string[];
+export declare function normViolationsFor(state: LivingState, actorId: string, placeId: string, actionKind: string): Extract<LivingEffect, {
+    kind: 'norm.violation';
+}>[];
+export declare function spreadLevel(state: LivingState, sourceId: string, propertyId: string, value: Level, seq: number, at: number): void;
+export declare function runTriggers(state: LivingState, entityId: string, propertyId: string, previous: number | null, next: number, at: number, seq: number): void;
+export declare const LAZY_METER_ENGINE = 32;
+export declare const ACT_GATE_ENGINE = 36;
+export declare const TIDY_PLACE_INDEX_ENGINE = 39;
+export declare const LOCAL_RECOVERY_ENGINE = 36;
+export declare function currentValue(state: LivingState, entity: LivingState['entities'][string], propertyId: string, at: number): PropertyValue | undefined;
+export declare function plain<T>(value: T): T;
+export declare function insertScheduled(state: LivingState, item: LivingState['schedule'][number], list?: 'schedule' | 'meterSchedule'): void;
+export declare function stalePrediction(state: LivingState, item: LivingState['schedule'][number]): boolean;
+export declare function predictionReady(state: LivingState, item: LivingState['schedule'][number]): boolean;
+export declare function dropStalePredictions(state: LivingState, now: number): void;
+export declare function keepPassedCrossings(state: LivingState, entityId: string, propertyId: string, at: number): void;
+export declare function predictCrossings(state: LivingState, entityId: string, propertyId: string, seq: number): void;
+export declare function advanceScopedEntities(state: LivingState, placeId: string | null, to: number, seq: number): void;
+export declare function applyEventChanges(state: LivingState, event: Pick<LivingState['events'][number], 'actorId' | 'effects' | 'seq' | 'at'>): void;
+export {};

package/dist/simulation/living/mechanics.js

@@ -0,0 +1,588 @@
+import { current, isDraft, original } from 'immer';
+import { BOUNDED_IDENTIFIERS_ENGINE, generatedId } from './identifiers.js';
+import { FULL_SCHEDULE_INTENT_ENGINE, scheduledSchema, LivingWorldError, ONE_CHECK_ENGINE, SELF_HOLD_ENGINE, SIGHT_NAMED_ENGINE, entityRefs } from './types.js';
+const LEVELS = ['none', 'low', 'medium', 'high'];
+// The one channel that reaches every place: a broadcast, a city-wide alarm, public news. Only a
+// world's own data may define a kind that signals on it.
+export const GLOBAL_SIGNAL_CHANNEL = 'global';
+// Signals follow the entities as they stand after all of an act's changes, so something made and
+// linked in the same act signals too.
+export function signalsFor(state, effects) {
+    const view = new Map();
+    const read = (id) => {
+        const known = view.get(id);
+        if (known)
+            return known;
+        const entity = state.entities[id];
+        if (!entity)
+            return undefined;
+        const copy = { kindId: entity.kindId, placeId: entity.placeId,
+            properties: Object.fromEntries(Object.entries(entity.properties).map(([key, slot]) => [key, slot.value])),
+            relations: Object.fromEntries(Object.entries(entity.relations).map(([key, slot]) => [key, slot.targetId])) };
+        view.set(id, copy);
+        return copy;
+    };
+    const touched = new Map();
+    const touch = (entityId, propertyId) => { (touched.get(entityId) ?? touched.set(entityId, new Set()).get(entityId)).add(propertyId); };
+    for (const effect of effects) {
+        if (effect.kind === 'entity.create') {
+            view.set(effect.entityId, { kindId: effect.kindId, placeId: effect.placeId, properties: { ...effect.initialProperties }, relations: {} });
+            for (const propertyId of Object.keys(effect.initialProperties ?? {}))
+                touch(effect.entityId, propertyId);
+        }
+        else if (effect.kind === 'property.set') {
+            const entity = read(effect.entityId);
+            if (!entity)
+                continue;
+            entity.properties[effect.propertyId] = effect.value;
+            touch(effect.entityId, effect.propertyId);
+        }
+        else if (effect.kind === 'relation.set') {
+            const entity = read(effect.entityId);
+            if (entity)
+                entity.relations[effect.relationId] = effect.targetId;
+        }
+    }
+    const signals = [];
+    for (const [entityId, propertyIds] of touched) {
+        const source = view.get(entityId);
+        const kind = state.kinds[source.kindId];
+        if (!kind)
+            continue;
+        for (const propertyId of propertyIds) {
+            const value = source.properties[propertyId];
+            if (value === null || value === undefined || value === false || value === 0 || value === 'none')
+                continue;
+            for (const mechanic of kind.mechanics) {
+                if (mechanic.kind !== 'signal' || mechanic.propertyId !== propertyId)
+                    continue;
+                if (mechanic.channel === GLOBAL_SIGNAL_CHANNEL) {
+                    signals.push({ sourcePlaceId: source.placeId, targetPlaceId: null, channel: mechanic.channel, sourceId: entityId });
+                    continue;
+                }
+                const targetId = source.relations[mechanic.relationId];
+                const target = targetId ? read(targetId) : undefined;
+                if (!target)
+                    continue;
+                signals.push({ sourcePlaceId: source.placeId, targetPlaceId: target.placeId, channel: mechanic.channel, sourceId: entityId });
+            }
+        }
+    }
+    return signals;
+}
+// What reaches people elsewhere: a broadcast carries what was observed where it began; any other
+// signal carries only its sense and where it came from.
+export function signalNotice(state, effects, observed = null) {
+    const signals = signalsFor(state, effects);
+    const broadcast = signals.find(signal => signal.channel === GLOBAL_SIGNAL_CHANNEL);
+    if (broadcast) {
+        const name = state.entities[broadcast.sourceId]?.name ?? effects.flatMap(effect => effect.kind === 'entity.create' && effect.entityId === broadcast.sourceId ? [effect.name] : [])[0] ?? 'A broadcast';
+        return `${name}: ${observed ?? 'an announcement'}`.slice(0, 2000);
+    }
+    const signal = signals[0];
+    if (!signal)
+        return null;
+    const from = signal.sourcePlaceId ? state.places[signal.sourcePlaceId]?.name ?? signal.sourcePlaceId : 'nearby';
+    // What is seen is the thing itself, named by its kind, never by a name that may be someone's.
+    if (signal.channel === 'sight' && state.engine >= SIGHT_NAMED_ENGINE) {
+        const kindId = state.entities[signal.sourceId]?.kindId ?? effects.flatMap(effect => effect.kind === 'entity.create' && effect.entityId === signal.sourceId ? [effect.kindId] : [])[0];
+        const kind = kindId === undefined ? undefined : state.kinds[kindId]?.name;
+        if (kind)
+            return `${kind} can be seen ${signal.sourcePlaceId ? `at ${from}` : from}.`;
+    }
+    return `A ${signal.channel.replace(/-/gu, ' ')} reaches from ${from}.`;
+}
+export function importanceFloorForEffects(state, effects) {
+    const created = new Map(effects.filter((effect) => effect.kind === 'entity.create')
+        .map(effect => [effect.entityId, effect.kindId]));
+    let floor = 1;
+    for (const effect of effects) {
+        if (effect.kind !== 'property.set' || typeof effect.value !== 'number')
+            continue;
+        const kindId = state.entities[effect.entityId]?.kindId ?? created.get(effect.entityId);
+        if (!kindId)
+            continue;
+        for (const mechanic of state.kinds[kindId]?.mechanics ?? []) {
+            if (mechanic.kind !== 'trigger' || mechanic.propertyId !== effect.propertyId)
+                continue;
+            const active = mechanic.direction === 'at-least' ? effect.value >= mechanic.threshold : effect.value <= mechanic.threshold;
+            if (active)
+                floor = Math.max(floor, mechanic.minImportance ?? 1);
+        }
+    }
+    return floor;
+}
+// Reads during the reducer go through a copy-on-access table; a scan that only reads uses this key
+// to look without copying.
+export const PEEK_ENTITY = Symbol('peek-entity');
+export function readEntity(state, entityId) {
+    const peek = state.entities[PEEK_ENTITY];
+    return peek ? peek(entityId) : state.entities[entityId];
+}
+// A placeless thing is in scope when it names nothing, like a world-wide rule, or when it names one of
+// the given people, places or things, like a debt naming its debtor. A model call takes the newest
+// few for each name, as recall does; rules and gates take them all.
+// Each index object is replaced only when something it lists changes, so the order of the things
+// it names is computed once per version of that index, however many commands read it.
+const orderedIndexes = new WeakMap();
+// The ids in an index from oldest to newest: least recently introduced first, then earliest created.
+// An index lists things in creation order and keeps that order when a thing is re-pointed, as a
+// reload does, so a stable sort by introduction chooses the same things before and after a reload.
+function orderedIds(state, rawIndex) {
+    const index = isDraft(rawIndex) ? current(rawIndex) : rawIndex;
+    let ordered = orderedIndexes.get(index);
+    if (ordered === undefined) {
+        ordered = Object.keys(index).map(id => ({ id, seq: readEntity(state, id)?.introducedSeq ?? 0 }))
+            .sort((left, right) => left.seq - right.seq)
+            .map(item => item.id);
+        if (Object.isFrozen(index))
+            orderedIndexes.set(index, ordered);
+    }
+    return ordered;
+}
+// The things in an index whose kind carries a mechanic, computed once per version of that index.
+const mechanicSubsets = new WeakMap();
+function withMechanic(state, rawSource, mechanicKind) {
+    if (rawSource === undefined)
+        return [];
+    // Inside the reducer the index is a draft: its current value is the frozen original when this event
+    // has not touched it (a cache hit), or a fresh copy that this event changed (computed, not cached).
+    const source = isDraft(rawSource) ? current(rawSource) : rawSource;
+    let subsets = mechanicSubsets.get(source);
+    const cached = subsets?.get(mechanicKind);
+    if (cached !== undefined)
+        return cached;
+    const ids = Array.isArray(source) ? source : Object.keys(source);
+    const subset = ids.filter(id => state.kinds[readEntity(state, id)?.kindId ?? '']?.mechanics.some(mechanic => mechanic.kind === mechanicKind));
+    if (Object.isFrozen(source)) {
+        if (subsets === undefined) {
+            subsets = new Map();
+            mechanicSubsets.set(source, subsets);
+        }
+        subsets.set(mechanicKind, subset);
+    }
+    return subset;
+}
+// Every thing near the given names, or at the place, whose kind carries the mechanic: what a rule reads.
+export function nearWithMechanic(state, nearIds, placeId, mechanicKind) {
+    const ids = new Set(withMechanic(state, state.worldEntityIds, mechanicKind));
+    for (const nearId of nearIds)
+        for (const entityId of withMechanic(state, state.globalEntityRefs[nearId], mechanicKind))
+            ids.add(entityId);
+    if (placeId !== null)
+        for (const entityId of withMechanic(state, state.entityPlaceIds[placeId], mechanicKind))
+            ids.add(entityId);
+    return [...ids];
+}
+export function placelessNear(state, nearIds, newestPerName = Number.POSITIVE_INFINITY) {
+    const newest = (index) => {
+        if (index === undefined)
+            return [];
+        const ordered = orderedIds(state, index);
+        return Number.isFinite(newestPerName) && ordered.length > newestPerName ? ordered.slice(ordered.length - newestPerName) : ordered;
+    };
+    const ids = new Set(newest(state.worldEntityIds));
+    for (const nearId of nearIds)
+        for (const entityId of newest(state.globalEntityRefs[nearId]))
+            ids.add(entityId);
+    return [...ids];
+}
+export function unindexPlaceless(state, entityId) {
+    const entity = state.entities[entityId];
+    if (!entity || entity.placeId !== null)
+        return;
+    delete state.worldEntityIds[entityId];
+    for (const ref of entityRefs(state.kinds, entity)) {
+        const named = state.globalEntityRefs[ref];
+        if (!named)
+            continue;
+        delete named[entityId];
+        if (Object.keys(named).length === 0)
+            delete state.globalEntityRefs[ref];
+    }
+}
+export function indexPlaceless(state, entityId) {
+    const entity = state.entities[entityId];
+    if (!entity || entity.placeId !== null)
+        return;
+    const refs = entityRefs(state.kinds, entity);
+    if (refs.length === 0)
+        state.worldEntityIds[entityId] = true;
+    for (const ref of refs)
+        (state.globalEntityRefs[ref] ??= {})[entityId] = true;
+}
+// A re-pointed thing leaves the names it no longer names and joins the new ones at the end; the
+// names it keeps naming keep it where it was, so the index stays in creation order.
+export function reindexPlaceless(state, entityId, previousRefs) {
+    const entity = state.entities[entityId];
+    if (!entity || entity.placeId !== null)
+        return;
+    const refs = entityRefs(state.kinds, entity);
+    const kept = new Set(refs);
+    for (const ref of previousRefs) {
+        if (kept.has(ref))
+            continue;
+        const named = state.globalEntityRefs[ref];
+        if (!named)
+            continue;
+        delete named[entityId];
+        if (Object.keys(named).length === 0)
+            delete state.globalEntityRefs[ref];
+    }
+    if (refs.length === 0)
+        state.worldEntityIds[entityId] = true;
+    else
+        delete state.worldEntityIds[entityId];
+    for (const ref of refs)
+        if (!previousRefs.includes(ref))
+            (state.globalEntityRefs[ref] ??= {})[entityId] = true;
+}
+// Every gate that holds on a subject now, with the action kinds it blocks. The engine's own
+// action kinds are move, speak, message and act; a ruling's action kind names a specific act.
+// Each gate also names who keeps its subject: the one its value names, or, when its value is no id,
+// the others its thing names.
+export function gatesOn(state, subjectId) {
+    const subjectPlaceId = state.people[subjectId]?.placeId ?? state.entities[subjectId]?.placeId ?? null;
+    const gates = [];
+    for (const entityId of nearWithMechanic(state, [subjectId], subjectPlaceId, 'gate')) {
+        const entity = readEntity(state, entityId);
+        const kind = state.kinds[entity.kindId];
+        for (const mechanic of kind.mechanics) {
+            if (mechanic.kind !== 'gate')
+                continue;
+            if (entity.properties[mechanic.subjectPropertyId]?.value !== subjectId)
+                continue;
+            const value = entity.properties[mechanic.propertyId]?.value;
+            // From engine 42 no one is kept in place by a hold they have on themselves.
+            if (state.engine >= SELF_HOLD_ENGINE && value === subjectId)
+                continue;
+            if (mechanic.atLeast !== undefined) {
+                const levels = ['none', 'low', 'medium', 'high'];
+                if (typeof value !== 'string' || !levels.includes(value)
+                    || levels.indexOf(value) < levels.indexOf(mechanic.atLeast))
+                    continue;
+            }
+            const keeperIds = (kind.properties.find(slot => slot.id === mechanic.propertyId)?.type === 'id' ? [value]
+                : kind.properties.filter(slot => slot.type === 'id' && slot.id !== mechanic.subjectPropertyId).map(slot => entity.properties[slot.id]?.value))
+                .filter((id) => typeof id === 'string');
+            if (value !== undefined && value !== false && value !== 0 && value !== 'none')
+                gates.push({ entityId: entity.id, name: entity.name, propertyId: mechanic.propertyId, actionKinds: mechanic.blockedActionKinds, keeperIds });
+        }
+    }
+    return gates;
+}
+// Someone else, there with the person, who can keep them where they are.
+function keeps(state, personId, keeperId) {
+    const person = state.people[personId];
+    const keeper = state.people[keeperId];
+    return keeperId !== personId && person !== undefined && keeper !== undefined && keeper.placeId === person.placeId && keeper.away === undefined && keeper.departed === undefined;
+}
+// The gates that stop a person taking a kind of act now. A gate on moving holds only while another
+// person there keeps them: with no keeper, a thing as keeper, or the keeper gone, it keeps no one.
+// That only ever refuses less, so it holds at every engine and saved worlds replay as they were.
+export function gatesAgainst(state, subjectId, actionKind) {
+    return gatesOn(state, subjectId).filter(gate => gate.actionKinds.includes(actionKind)
+        && (actionKind !== 'move' || gate.keeperIds.some(keeperId => keeps(state, subjectId, keeperId))));
+}
+// Kept where they are by the hold of another person who is there with them.
+export function heldHere(state, personId) {
+    const held = state.people[personId]?.held;
+    return held !== undefined && held.byId !== null && keeps(state, personId, held.byId);
+}
+export function blockedByGate(state, subjectId, actionKind) {
+    return gatesAgainst(state, subjectId, actionKind)[0]?.entityId ?? null;
+}
+export function blockedActionKinds(state, subjectId) {
+    return [...new Set(gatesOn(state, subjectId).flatMap(gate => gate.actionKinds.filter(actionKind => actionKind !== 'move'
+            || gate.keeperIds.some(keeperId => keeps(state, subjectId, keeperId)))))].sort();
+}
+export function normViolationsFor(state, actorId, placeId, actionKind) {
+    const actor = state.people[actorId];
+    const violations = [];
+    const near = new Set([actorId, placeId, ...Object.values(state.people).filter(person => person.placeId === placeId).map(person => person.id)]);
+    for (const entityId of nearWithMechanic(state, near, placeId, 'norm')) {
+        const entity = readEntity(state, entityId);
+        for (const mechanic of state.kinds[entity.kindId].mechanics) {
+            if (mechanic.kind !== 'norm' || !mechanic.forbidden || mechanic.actionKind !== actionKind)
+                continue;
+            if (mechanic.roleId !== null && mechanic.roleId !== actor.roleId)
+                continue;
+            violations.push({ kind: 'norm.violation', normEntityId: entity.id, actionKind, actorId });
+        }
+    }
+    return violations;
+}
+export function spreadLevel(state, sourceId, propertyId, value, seq, at) {
+    const source = state.entities[sourceId];
+    const mechanics = state.kinds[source.kindId].mechanics.filter((mechanic) => mechanic.kind === 'spread' && mechanic.propertyId === propertyId);
+    for (const mechanic of mechanics) {
+        const queue = [{ entityId: sourceId, strength: LEVELS.indexOf(value) }];
+        const reached = new Map();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current.strength <= (reached.get(current.entityId) ?? -1))
+                continue;
+            reached.set(current.entityId, current.strength);
+            const entity = state.entities[current.entityId];
+            const relation = entity.relations[mechanic.relationId];
+            if (!relation)
+                continue;
+            const target = state.entities[relation.targetId];
+            if (!target)
+                continue;
+            const nextStrength = current.strength - 1;
+            if (nextStrength <= 0)
+                continue;
+            const property = state.kinds[target.kindId].properties.find(slot => slot.id === propertyId);
+            if (property?.type !== 'level')
+                continue;
+            const previous = target.properties[propertyId];
+            const previousStrength = previous && typeof previous.value === 'string' ? LEVELS.indexOf(previous.value) : -1;
+            if (nextStrength <= previousStrength)
+                continue;
+            const next = LEVELS[nextStrength];
+            target.properties[propertyId] = { value: next, changedSeq: seq, previousSeq: previous?.changedSeq ?? null, knownTo: [], updatedAt: at };
+            state.changes.push({ seq, entityId: target.id, slotKind: 'property', slotId: propertyId, value: next });
+            queue.push({ entityId: target.id, strength: nextStrength });
+        }
+    }
+}
+export function runTriggers(state, entityId, propertyId, previous, next, at, seq) {
+    const entity = state.entities[entityId];
+    for (const [index, mechanic] of state.kinds[entity.kindId].mechanics.entries()) {
+        if (mechanic.kind !== 'trigger' || mechanic.propertyId !== propertyId)
+            continue;
+        const crossed = mechanic.direction === 'at-least'
+            ? (previous === null || previous < mechanic.threshold) && next >= mechanic.threshold
+            : (previous === null || previous > mechanic.threshold) && next <= mechanic.threshold;
+        if (!crossed)
+            continue;
+        // A thing made already past the threshold joins a check of its kind and trigger pending at its
+        // place; a change to a thing that was already there always arms its own.
+        const series = generatedId(state.engine, 'trigger', [entity.kindId, index], `trigger-${entity.kindId}-${index}`.slice(0, 64));
+        const once = state.engine >= ONE_CHECK_ENGINE;
+        if (once && entity.introducedSeq === seq && state.schedule.some(item => item.series === series && item.placeId === entity.placeId))
+            continue;
+        const id = generatedId(state.engine, 'trigger', [entityId, propertyId, seq, index], undefined, true);
+        if (state.engine >= BOUNDED_IDENTIFIERS_ENGINE && plain(state.schedule).some(item => item.id === id))
+            continue;
+        insertScheduled(state, {
+            id, at: at + mechanic.delayMinutes,
+            personId: null, kind: 'world', intent: mechanic.intent, placeId: entity.placeId,
+            targetId: entityId, sourceSeq: seq, importance: mechanic.minImportance ?? 5, ...(once ? { series } : {}),
+        });
+    }
+}
+// Engines from 32 on keep a growing value as its last written value, the time it was written, and
+// the rates of its time changes. Readers see the value at their own time, and each threshold it will
+// cross is scheduled when the value is written, so no event has to touch every growing thing.
+export const LAZY_METER_ENGINE = 32;
+// From this engine on, gates block speech and messages in the reducer as well as movement.
+export const ACT_GATE_ENGINE = 36;
+export const TIDY_PLACE_INDEX_ENGINE = 39;
+// From this engine on, recovery is decided where an event happens, never from another place.
+export const LOCAL_RECOVERY_ENGINE = 36;
+function meterRate(state, entity, propertyId) {
+    return state.kinds[entity.kindId].mechanics.reduce((rate, mechanic) => mechanic.kind === 'change' && mechanic.propertyId === propertyId && !mechanic.onEvent ? rate + mechanic.deltaPerMinute : rate, 0);
+}
+export function currentValue(state, entity, propertyId, at) {
+    const slot = entity.properties[propertyId];
+    if (!slot || typeof slot.value !== 'number' || at <= slot.updatedAt)
+        return slot?.value;
+    return slot.value + (at - slot.updatedAt) * meterRate(state, entity, propertyId);
+}
+// The schedule stays ordered by time and id; a new item goes after any equal one.
+// A large list read through a draft copies itself on the first element read; scans that change
+// nothing read the underlying list instead.
+export function plain(value) {
+    return isDraft(value) ? original(value) : value;
+}
+export function insertScheduled(state, item, list = 'schedule') {
+    if (state.engine >= FULL_SCHEDULE_INTENT_ENGINE) {
+        const parsed = scheduledSchema.safeParse(item);
+        if (!parsed.success)
+            throw new LivingWorldError('effect-invalid', `Generated schedule is invalid: ${parsed.error.message}`);
+    }
+    // Inside the reducer, splicing a large draft array traps every shifted element; one plain copy does not.
+    let items = state[list];
+    if (isDraft(items)) {
+        // An unchanged draft's current value is the previous state's own array, so copy it.
+        items = current(items).slice();
+        state[list] = items;
+    }
+    let low = 0;
+    let high = items.length;
+    while (low < high) {
+        const middle = (low + high) >> 1;
+        const other = items[middle];
+        if (other.at < item.at || (other.at === item.at && other.id <= item.id))
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    items.splice(low, 0, item);
+}
+// A prediction's id names its thing, slot, the write it was made from and its trigger.
+function predictedSlot(item) {
+    if (!item.id.startsWith('meter-') || item.targetId === null)
+        return null;
+    if (item.prediction)
+        return { entityId: item.targetId, ...item.prediction };
+    const tail = `-${item.sourceSeq}-`;
+    const cut = item.id.lastIndexOf(tail);
+    return { entityId: item.targetId, propertyId: item.id.slice(`meter-${item.targetId}-`.length, cut), index: Number(item.id.slice(cut + tail.length)) };
+}
+// A prediction holds only while the value it was made from is unchanged. A later write makes its own
+// predictions, and the older ones are dropped when they come due. A thing outside the loaded part of
+// the world cannot be checked, so its prediction waits until the thing is loaded again.
+export function stalePrediction(state, item) {
+    const slot = predictedSlot(item);
+    if (slot === null)
+        return false;
+    const entity = readEntity(state, slot.entityId);
+    return entity !== undefined && entity.properties[slot.propertyId]?.changedSeq !== item.sourceSeq;
+}
+export function predictionReady(state, item) {
+    const slot = predictedSlot(item);
+    return slot === null || (readEntity(state, slot.entityId) !== undefined && !stalePrediction(state, item));
+}
+// Stale due predictions go; a due one on a thing that is not loaded waits without holding back the rest.
+export function dropStalePredictions(state, now) {
+    // Reading an element through a draft copies the whole list; a read-only scan reads the list itself.
+    const items = plain(state.meterSchedule);
+    let due = 0;
+    let stale = 0;
+    while (due < items.length && items[due].at <= now) {
+        if (stalePrediction(state, items[due]))
+            stale += 1;
+        due += 1;
+    }
+    if (stale === 0)
+        return;
+    state.meterSchedule = [...items.slice(0, due).filter(item => !stalePrediction(state, item)), ...items.slice(due)];
+}
+// Before a growing slot is written, a crossing its value already made stays a real event: its
+// prediction moves to the schedule, where the new write cannot erase it.
+export function keepPassedCrossings(state, entityId, propertyId, at) {
+    const entity = state.entities[entityId];
+    const slot = entity?.properties[propertyId];
+    if (!entity || !slot)
+        return;
+    const delays = state.kinds[entity.kindId].mechanics.map(mechanic => mechanic.kind === 'trigger' ? mechanic.delayMinutes : 0);
+    const latest = at + Math.max(0, ...delays);
+    const passed = plain(state.meterSchedule).filter(item => {
+        if (item.at > latest || item.sourceSeq !== slot.changedSeq)
+            return false;
+        const predicted = predictedSlot(item);
+        return predicted !== null && predicted.entityId === entityId && predicted.propertyId === propertyId
+            && item.at - (delays[predicted.index] ?? 0) <= at;
+    });
+    if (passed.length === 0)
+        return;
+    const ids = new Set(passed.map(item => item.id));
+    state.meterSchedule = (isDraft(state.meterSchedule) ? current(state.meterSchedule) : state.meterSchedule).filter(item => !ids.has(item.id));
+    for (const item of passed) {
+        const slot = predictedSlot(item);
+        const { prediction: _prediction, ...settled } = item;
+        insertScheduled(state, { ...settled, id: generatedId(state.engine, 'trigger', [slot.entityId, slot.propertyId, item.sourceSeq, slot.index], `trigger-${item.id.slice('meter-'.length)}`, true) });
+    }
+}
+export function predictCrossings(state, entityId, propertyId, seq) {
+    // An event can write a slot more than once. Only its final value predicts future crossings.
+    if (state.engine >= BOUNDED_IDENTIFIERS_ENGINE && plain(state.meterSchedule).some(item => item.targetId === entityId
+        && item.prediction?.propertyId === propertyId && item.sourceSeq === seq)) {
+        state.meterSchedule = plain(state.meterSchedule).filter(item => item.targetId !== entityId
+            || item.prediction?.propertyId !== propertyId || item.sourceSeq !== seq);
+    }
+    const entity = state.entities[entityId];
+    const slot = entity.properties[propertyId];
+    const rate = meterRate(state, entity, propertyId);
+    if (!slot || typeof slot.value !== 'number' || rate === 0)
+        return;
+    for (const [index, mechanic] of state.kinds[entity.kindId].mechanics.entries()) {
+        if (mechanic.kind !== 'trigger' || mechanic.propertyId !== propertyId)
+            continue;
+        const gap = mechanic.threshold - slot.value;
+        const ahead = mechanic.direction === 'at-least' ? rate > 0 && gap > 0 : rate < 0 && gap < 0;
+        if (!ahead)
+            continue;
+        insertScheduled(state, {
+            id: generatedId(state.engine, 'meter', [entityId, propertyId, seq, index], undefined, true), at: slot.updatedAt + Math.ceil(gap / rate) + mechanic.delayMinutes,
+            personId: null, kind: 'world', intent: mechanic.intent, placeId: entity.placeId,
+            targetId: entityId, sourceSeq: seq, importance: mechanic.minImportance ?? 5,
+            ...(state.engine >= BOUNDED_IDENTIFIERS_ENGINE ? { prediction: { propertyId, index } } : {}),
+        }, 'meterSchedule');
+    }
+}
+export function advanceScopedEntities(state, placeId, to, seq) {
+    const ids = [...state.globalEntityIds, ...(placeId === null ? [] : state.entityPlaceIds[placeId] ?? [])];
+    for (const entityId of ids) {
+        const entity = state.entities[entityId];
+        for (const mechanic of state.kinds[entity.kindId].mechanics) {
+            if (mechanic.kind !== 'change')
+                continue;
+            const slot = entity.properties[mechanic.propertyId];
+            if (!slot || typeof slot.value !== 'number' || slot.updatedAt >= to)
+                continue;
+            const previous = slot.value;
+            const next = previous + (to - slot.updatedAt) * mechanic.deltaPerMinute;
+            if (!Number.isFinite(next))
+                throw new Error(`Property ${mechanic.propertyId} exceeds a finite number`);
+            entity.properties[mechanic.propertyId] = { ...slot, value: next, changedSeq: seq, previousSeq: slot.changedSeq, updatedAt: to };
+            state.changes.push({ seq, entityId: entity.id, slotKind: 'property', slotId: mechanic.propertyId, value: next });
+            runTriggers(state, entity.id, mechanic.propertyId, previous, next, to, seq);
+        }
+    }
+}
+export function applyEventChanges(state, event) {
+    for (const effect of event.effects) {
+        if (effect.kind !== 'move' || event.actorId !== effect.personId)
+            continue;
+        for (const entityId of state.entityMoveSubjectIds[effect.personId] ?? []) {
+            const entity = state.entities[entityId];
+            for (const mechanic of state.kinds[entity.kindId].mechanics) {
+                if (mechanic.kind !== 'change' || mechanic.onEvent?.kind !== 'move')
+                    continue;
+                if (entity.properties[mechanic.onEvent.subjectPropertyId]?.value !== effect.personId)
+                    continue;
+                const lazy = state.engine >= LAZY_METER_ENGINE;
+                const previous = entity.properties[mechanic.propertyId];
+                const previousValue = lazy ? currentValue(state, entity, mechanic.propertyId, event.at) : previous?.value;
+                if (previousValue === mechanic.onEvent.value)
+                    continue;
+                if (lazy)
+                    keepPassedCrossings(state, entity.id, mechanic.propertyId, event.at);
+                entity.properties[mechanic.propertyId] = {
+                    value: mechanic.onEvent.value, changedSeq: event.seq, previousSeq: previous?.changedSeq ?? null,
+                    knownTo: [...new Set([...(previous?.knownTo ?? []), ...event.effects.flatMap(item => item.kind === 'move' ? [item.personId] : [])])],
+                    updatedAt: event.at,
+                };
+                if (entity.placeId !== effect.placeId) {
+                    unindexPlaceless(state, entity.id);
+                    if (entity.placeId === null)
+                        state.globalEntityIds = state.globalEntityIds.filter(id => id !== entity.id);
+                    else {
+                        const left = (state.entityPlaceIds[entity.placeId] ?? []).filter(id => id !== entity.id);
+                        // From this engine a place with nothing left has no list, as when a save is loaded.
+                        if (left.length === 0 && state.engine >= TIDY_PLACE_INDEX_ENGINE)
+                            delete state.entityPlaceIds[entity.placeId];
+                        else
+                            state.entityPlaceIds[entity.placeId] = left;
+                    }
+                    ;
+                    (state.entityPlaceIds[effect.placeId] ??= []).push(entity.id);
+                    entity.placeId = effect.placeId;
+                    if (plain(state.meterSchedule).some(item => item.targetId === entity.id)) {
+                        state.meterSchedule = (isDraft(state.meterSchedule) ? current(state.meterSchedule) : state.meterSchedule)
+                            .map(item => item.targetId === entity.id ? { ...item, placeId: effect.placeId } : item);
+                    }
+                }
+                state.changes.push({ seq: event.seq, entityId: entity.id, slotKind: 'property', slotId: mechanic.propertyId, value: mechanic.onEvent.value });
+                if (typeof mechanic.onEvent.value === 'number')
+                    runTriggers(state, entity.id, mechanic.propertyId, typeof previousValue === 'number' ? previousValue : null, mechanic.onEvent.value, event.at, event.seq);
+                if (lazy)
+                    predictCrossings(state, entity.id, mechanic.propertyId, event.seq);
+            }
+        }
+    }
+}

package/dist/simulation/living/model-input.d.ts

@@ -0,0 +1,25 @@
+import type { LivingInferenceCall } from './inference.js';
+export declare const LIVING_INPUT_BUDGETS: {
+    readonly attempt: 16000;
+    readonly world: 16000;
+    readonly 'speech-impact': 16000;
+    readonly reaction: 32000;
+    readonly reply: 32000;
+    readonly plan: 14000;
+    readonly 'message-reply': 16000;
+    readonly epilogue: 12000;
+    readonly define: 12000;
+};
+export declare const LIVING_RESPONSE_SCHEMA_BUDGET = 96000;
+export declare const MODEL_VIEW_NOTE = "Selected context: other people and facts remain in the world. Descriptions may be excerpts. Use only the IDs shown; omission does not mean absence.";
+export declare function assertLivingModelCall(call: Pick<LivingInferenceCall, 'phase' | 'input' | 'responseSchema'>): void;
+type Data = Record<string, unknown>;
+export declare function decisionInputBudget(input: Data, ordinaryBudget: number): number;
+export declare const MODEL_PEOPLE_LIMIT = 24;
+export declare function selectModelPeople(input: Data, close: ReadonlySet<string>): ReadonlySet<string>;
+export declare function syncModelPeople(input: Data): void;
+export declare function modelTextExcerpt(text: string, limit?: number): string;
+export declare function compactModelInput(input: Data, budget: number, priority: ReadonlySet<string>, maximum?: number, things?: ReadonlySet<string>): void;
+export declare function withContextLookup(schema: Readonly<Data>, input: Readonly<Data>): Readonly<Data>;
+export declare function contextSelectionInput(input: Readonly<Data>): Data;
+export {};