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

package/dist/simulation/toolkit/dynamic_progress.d.ts

@@ -0,0 +1,131 @@
+import type { SimulationDefinitionV1, SimulationDynamicMechanicDefinitionV1, SimulationDynamicPlayFrameV1 as DynamicPlayFrame } from '../../plugin/simulation_contract.js';
+type MilestoneBase = {
+    id: string;
+    label: string;
+    act?: 1 | 2 | 3;
+};
+export type MilestoneRule = (MilestoneBase & {
+    kind: 'resource';
+    resourceId: string;
+    comparator: 'at-least' | 'at-most';
+    value: number;
+}) | (MilestoneBase & {
+    kind: 'records';
+    objectKind: string;
+    status?: string | readonly string[];
+    minimum: number;
+}) | (MilestoneBase & {
+    kind: 'beats';
+    minimum: number;
+});
+export type ActStatus = 'done' | 'current' | 'locked';
+export type ActView = {
+    number: number;
+    title: string;
+    status: ActStatus;
+    met: number;
+    milestones: readonly MilestoneState[];
+};
+export declare function groupActs(rules: readonly MilestoneRule[], states: readonly MilestoneState[], version?: 'completed-acts-v1'): ActView[];
+export type MilestoneState = {
+    id: string;
+    label: string;
+    met: boolean;
+    progress: string;
+};
+export type SimulationCatalogEntry = SimulationDefinitionV1 & {
+    milestones: readonly MilestoneRule[];
+    glossary: readonly string[];
+};
+export declare function evaluateMilestones(rules: readonly MilestoneRule[], frame: Pick<DynamicPlayFrame, 'world' | 'domainObjects' | 'revision'>): readonly MilestoneState[];
+export declare function summarizeMilestones(states: readonly MilestoneState[]): string;
+export type MilestoneRelationKind = 'may-advance' | 'tests' | 'tradeoff';
+export type MilestoneRelationCondition = {
+    source: 'intent';
+    parameter: string;
+    equals: string;
+} | {
+    source: 'object';
+    parameter: string;
+    objectKind: string;
+    field: string;
+    equals: string;
+    status?: string;
+};
+export type MilestoneRelation = {
+    mechanic: string;
+    milestoneId: string;
+    relation: MilestoneRelationKind;
+    why: string;
+    when?: readonly MilestoneRelationCondition[];
+};
+export type ChoiceMilestoneLink = {
+    actionId: string;
+    milestoneId: string;
+    relation: MilestoneRelationKind;
+    why: string;
+};
+export type DynamicPublicProgress = {
+    relations?: readonly MilestoneRelation[];
+    choiceLinks?: {
+        revision: number;
+        links: readonly ChoiceMilestoneLink[];
+    };
+    revision: number;
+    rules: readonly MilestoneRule[];
+    milestones: readonly MilestoneState[];
+    acts: readonly ActView[];
+    allTargetsMet: boolean;
+};
+export declare function evaluatePublicProgress(rules: readonly MilestoneRule[], frame: Pick<DynamicPlayFrame, 'world' | 'domainObjects' | 'revision'>, relations?: readonly MilestoneRelation[], mechanics?: readonly SimulationDynamicMechanicDefinitionV1[], version?: 'completed-acts-v1'): DynamicPublicProgress;
+export declare function withPublicChoiceLinks(progress: DynamicPublicProgress, frame: Pick<DynamicPlayFrame, 'revision' | 'availableActions' | 'domainObjects'>): DynamicPublicProgress;
+/** A chapter is one act. The player earns its result inside this many decisions. */
+export declare const CHAPTER_MIN_DECISIONS = 5;
+export declare const CHAPTER_MAX_DECISIONS = 8;
+export type ChapterResult = 'open' | 'win' | 'mixed' | 'loss';
+export type ChapterStanding = {
+    act: number;
+    acts: number;
+    decisions: number;
+    /** Decisions that did real work: accepted, and not an abandonment. Only these earn a win. */
+    workingDecisions: number;
+    decisionsLeft: number;
+    goals: readonly {
+        id: string;
+        label: string;
+        met: boolean;
+        share: number;
+    }[];
+    /** Mean progress over the act's goals, from the chapter's start toward each target. */
+    score: number;
+    /** Meters that end the chapter as a loss at their bad end, with the share of starting room left. */
+    dangers: readonly {
+        resourceId: string;
+        label: string;
+        value: number;
+        bound: number;
+        room: number;
+    }[];
+    result: ChapterResult;
+    lossCause: null | {
+        kind: 'meter';
+        resourceId: string;
+        label: string;
+    } | {
+        kind: 'out-of-decisions';
+    };
+};
+/**
+ * Code decides a chapter's result from public state alone. A loss is checked first: a meter at its bad end,
+ * or the decisions spent under half way. A win needs every goal of the act and at least the minimum decisions.
+ * A meter that starts at its bad end (a count that begins at zero) can never be a way to lose.
+ */
+export declare function evaluateChapterStanding(input: {
+    rules: readonly MilestoneRule[];
+    act: number;
+    decisions: number;
+    workingDecisions: number;
+    frame: Pick<DynamicPlayFrame, 'world' | 'domainObjects' | 'revision'>;
+    startResources: Readonly<Record<string, number>>;
+}): ChapterStanding;
+export {};

package/dist/simulation/toolkit/dynamic_progress.js

@@ -0,0 +1,214 @@
+const PUBLIC_PROGRESS_MAX_BYTES = 16_384;
+const publicProgressBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).length;
+// The first incomplete act sets the current focus; later conditions can already be satisfied.
+export function groupActs(rules, states, version) {
+    const stateById = new Map(states.map(state => [state.id, state]));
+    const numbers = [...new Set(rules.map(rule => rule.act ?? 1))].sort((left, right) => left - right);
+    let opened = true;
+    return numbers.map((number) => {
+        const milestones = rules
+            .filter(rule => (rule.act ?? 1) === number)
+            .flatMap(rule => { const state = stateById.get(rule.id); return state === undefined ? [] : [state]; });
+        const met = milestones.filter(state => state.met).length;
+        const complete = milestones.length > 0 && met === milestones.length;
+        const status = complete && version === 'completed-acts-v1' ? 'done' : !opened ? 'locked' : complete ? 'done' : 'current';
+        if (!complete)
+            opened = false;
+        return { number, title: `Act ${number} of ${numbers.length}`, status, met, milestones };
+    });
+}
+// Milestones read only what the player can see: public meters, visible records, and the beat.
+export function evaluateMilestones(rules, frame) {
+    return rules.map((rule) => {
+        if (rule.kind === 'resource') {
+            const resource = frame.world.find(candidate => candidate.id === rule.resourceId);
+            if (resource === undefined)
+                return { id: rule.id, label: rule.label, met: false, progress: 'Not visible yet' };
+            if (rule.comparator === 'at-least') {
+                return { id: rule.id, label: rule.label, met: resource.value >= rule.value, progress: `${resource.label} ${resource.value} of ${rule.value}` };
+            }
+            const met = resource.value <= rule.value;
+            return {
+                id: rule.id,
+                label: rule.label,
+                met,
+                progress: met ? `${resource.label} ${resource.value}, held` : `${resource.label} ${resource.value}, needs ${rule.value} or less`,
+            };
+        }
+        if (rule.kind === 'records') {
+            // A status list names each currently qualifying record state.
+            const statuses = rule.status === undefined ? undefined : typeof rule.status === 'string' ? [rule.status] : [...rule.status];
+            const count = frame.domainObjects.filter(object => (object.kind === rule.objectKind && (statuses === undefined || statuses.includes(object.status)))).length;
+            const noun = `${rule.objectKind.replaceAll('-', ' ')}${rule.minimum === 1 ? '' : 's'}`;
+            const state = statuses === undefined ? '' : ` ${statuses.join(' or ')}`;
+            return { id: rule.id, label: rule.label, met: count >= rule.minimum, progress: `${Math.min(count, rule.minimum)} of ${rule.minimum} ${noun}${state}` };
+        }
+        return { id: rule.id, label: rule.label, met: frame.revision >= rule.minimum, progress: `Beat ${Math.min(frame.revision, rule.minimum)} of ${rule.minimum}` };
+    });
+}
+export function summarizeMilestones(states) {
+    if (states.length === 0)
+        return 'No milestones yet';
+    const met = states.filter(state => state.met).length;
+    return `${met} of ${states.length} milestone${states.length === 1 ? '' : 's'} met`;
+}
+export function evaluatePublicProgress(rules, frame, relations = [], mechanics = [], version) {
+    if (rules.length > 32 || rules.some(rule => (rule.id.length > 100 || rule.label.length > 160
+        || (rule.kind === 'resource' && rule.resourceId.length > 100)
+        || (rule.kind === 'records' && (rule.objectKind.length > 100
+            || (typeof rule.status === 'string' ? rule.status.length > 100
+                : rule.status !== undefined && (rule.status.length > 16 || rule.status.some(status => status.length > 100))))))))
+        throw new Error('Public milestone definitions exceed their context bounds');
+    const milestones = evaluateMilestones(rules, frame);
+    const projection = {
+        revision: frame.revision,
+        rules: structuredClone(rules),
+        relations: publicMilestoneRelations(rules, relations, mechanics, frame.domainObjects),
+        milestones,
+        acts: groupActs(rules, milestones, version),
+        allTargetsMet: milestones.length > 0 && milestones.every(state => state.met),
+    };
+    if (publicProgressBytes(projection) > PUBLIC_PROGRESS_MAX_BYTES) {
+        throw new Error('Public milestone projection exceeds its context budget');
+    }
+    return projection;
+}
+function publicMilestoneRelations(rules, relations, mechanics, objects) {
+    const ids = new Set(rules.map(rule => rule.id));
+    const seen = new Set();
+    return relations.slice(0, 64).flatMap(relation => {
+        const mechanic = mechanics.find(item => item.id === relation.mechanic && item.actor !== 'game-master');
+        if (!mechanic || !ids.has(relation.milestoneId)
+            || !['may-advance', 'tests', 'tradeoff'].includes(relation.relation)
+            || relation.why.trim().length === 0 || relation.why.length > 160
+            || (relation.when?.length ?? 0) > 2)
+            return [];
+        const conditions = relation.when ?? [];
+        if (conditions.some(condition => {
+            const parameter = mechanic.intentParameters.find(item => item.id === condition.parameter);
+            if (!parameter || condition.equals.length > 100)
+                return true;
+            if (condition.source === 'intent')
+                return parameter.kind !== 'enum' || !parameter.values.includes(condition.equals);
+            return parameter.kind !== 'object-reference' || !parameter.objectKinds.includes(condition.objectKind)
+                || condition.field.length === 0 || condition.field.length > 100 || (condition.status?.length ?? 0) > 100
+                || !objects.some(object => object.kind === condition.objectKind && Object.hasOwn(object.data, condition.field));
+        }))
+            return [];
+        const clean = {
+            mechanic: relation.mechanic, milestoneId: relation.milestoneId,
+            relation: relation.relation, why: relation.why,
+            ...(conditions.length === 0 ? {} : { when: conditions.map(condition => condition.source === 'intent'
+                    ? { source: condition.source, parameter: condition.parameter, equals: condition.equals }
+                    : { source: condition.source, parameter: condition.parameter, objectKind: condition.objectKind,
+                        field: condition.field, equals: condition.equals,
+                        ...(condition.status === undefined ? {} : { status: condition.status }) }) }),
+        };
+        const key = JSON.stringify(clean);
+        if (seen.has(key))
+            return [];
+        seen.add(key);
+        return [clean];
+    });
+}
+function isIntentObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+// Relations annotate accepted public choices. They do not calculate legality or effects.
+export function withPublicChoiceLinks(progress, frame) {
+    const links = [];
+    if (progress.revision === frame.revision) {
+        for (const action of frame.availableActions.slice(0, 4)) {
+            const intent = action.parameters.intent;
+            if (!isIntentObject(intent))
+                continue;
+            const seen = new Set();
+            for (const relation of progress.relations ?? []) {
+                const milestone = progress.milestones.find(item => item.id === relation.milestoneId);
+                if (relation.mechanic !== action.mechanic || !milestone
+                    || (relation.relation === 'may-advance' && milestone.met)
+                    || seen.has(relation.milestoneId) || seen.size >= 4)
+                    continue;
+                const matches = (relation.when ?? []).every(condition => {
+                    if (condition.source === 'intent')
+                        return intent[condition.parameter] === condition.equals;
+                    const object = frame.domainObjects.find(item => item.id === intent[condition.parameter] && item.kind === condition.objectKind);
+                    return object !== undefined && (condition.status === undefined || object.status === condition.status)
+                        && object.data[condition.field] === condition.equals;
+                });
+                if (!matches)
+                    continue;
+                seen.add(relation.milestoneId);
+                links.push({ actionId: action.id, milestoneId: relation.milestoneId, relation: relation.relation, why: relation.why });
+            }
+        }
+    }
+    const { choiceLinks: _previous, ...base } = progress;
+    if (publicProgressBytes(base) > PUBLIC_PROGRESS_MAX_BYTES) {
+        throw new Error('Public milestone projection exceeds its context budget');
+    }
+    const result = { ...base, choiceLinks: { revision: frame.revision, links } };
+    while (links.length > 0 && publicProgressBytes(result) > PUBLIC_PROGRESS_MAX_BYTES)
+        links.pop();
+    return publicProgressBytes(result) <= PUBLIC_PROGRESS_MAX_BYTES ? result : base;
+}
+/** A chapter is one act. The player earns its result inside this many decisions. */
+export const CHAPTER_MIN_DECISIONS = 5;
+export const CHAPTER_MAX_DECISIONS = 8;
+const clampShare = (value) => Math.min(1, Math.max(0, value));
+/**
+ * Code decides a chapter's result from public state alone. A loss is checked first: a meter at its bad end,
+ * or the decisions spent under half way. A win needs every goal of the act and at least the minimum decisions.
+ * A meter that starts at its bad end (a count that begins at zero) can never be a way to lose.
+ */
+export function evaluateChapterStanding(input) {
+    const { rules, act, decisions, workingDecisions, frame, startResources } = input;
+    const actRules = rules.filter(rule => (rule.act ?? 1) === act);
+    if (actRules.length === 0)
+        throw new Error(`Act ${act} has no goals`);
+    const states = evaluateMilestones(actRules, frame);
+    const goals = actRules.map((rule, index) => {
+        const met = states[index].met;
+        return { id: rule.id, label: rule.label, met, share: met ? 1 : unmetGoalShare(rule, frame, startResources) };
+    });
+    const score = goals.reduce((total, goal) => total + goal.share, 0) / goals.length;
+    const dangers = frame.world.flatMap((meter) => {
+        if (meter.dangerDirection === 'none' || meter.initial === undefined)
+            return [];
+        const bound = meter.dangerDirection === 'low' ? meter.minimum : meter.maximum;
+        if (meter.initial === bound)
+            return [];
+        return [{ resourceId: meter.id, label: meter.label, value: meter.value, bound, room: clampShare((meter.value - bound) / (meter.initial - bound)) }];
+    });
+    const spent = dangers.find(danger => danger.value === danger.bound);
+    const allMet = goals.every(goal => goal.met);
+    const outOfDecisions = decisions >= CHAPTER_MAX_DECISIONS;
+    // A win is earned: the goals are met and the player's own decisions did real work at least the minimum number of times.
+    const result = spent !== undefined ? 'loss'
+        : allMet && workingDecisions >= CHAPTER_MIN_DECISIONS ? 'win'
+            : !outOfDecisions ? 'open'
+                : score >= 0.5 ? 'mixed' : 'loss';
+    return {
+        act, acts: new Set(rules.map(rule => rule.act ?? 1)).size, decisions, workingDecisions,
+        decisionsLeft: Math.max(0, CHAPTER_MAX_DECISIONS - decisions), goals, score, dangers, result,
+        lossCause: result !== 'loss' ? null : spent !== undefined ? { kind: 'meter', resourceId: spent.resourceId, label: spent.label } : { kind: 'out-of-decisions' },
+    };
+}
+/** How far an unmet goal has come, from the chapter's start toward its target. */
+function unmetGoalShare(rule, frame, startResources) {
+    if (rule.kind === 'resource') {
+        const meter = frame.world.find(candidate => candidate.id === rule.resourceId);
+        const start = startResources[rule.resourceId] ?? meter?.initial;
+        if (meter === undefined || start === undefined || start === rule.value)
+            return 0;
+        return clampShare((meter.value - start) / (rule.value - start));
+    }
+    if (rule.kind === 'records') {
+        const statuses = rule.status === undefined ? undefined : typeof rule.status === 'string' ? [rule.status] : rule.status;
+        const count = frame.domainObjects.filter(object => object.kind === rule.objectKind && (statuses === undefined || statuses.includes(object.status))).length;
+        return clampShare(count / rule.minimum);
+    }
+    if (rule.kind === 'beats')
+        return clampShare(frame.revision / rule.minimum);
+    return 0;
+}

package/dist/simulation/toolkit/dynamic_projection.d.ts

@@ -0,0 +1,9 @@
+import type { SimulationDomainActionProposalV1, SimulationDynamicAgentViewV1, SimulationDynamicDomainObjectV1, SimulationDynamicDomainObjectViewV1, SimulationDynamicHistoryEntryV1, SimulationDynamicPlayFrameV1, SimulationDynamicResourceDefinitionV1, SimulationDynamicWorldEffectV1, SimulationDynamicWorldEffectViewV1, SimulationGmProposalV1, SimulationPersistentAgentStateV1 } from '../../plugin/simulation_contract.js';
+type PublicResourceDefinition = Pick<SimulationDynamicResourceDefinitionV1, 'id' | 'label' | 'visibility'>;
+export declare function projectDynamicPlayerDecision(history: readonly SimulationDynamicHistoryEntryV1[]): NonNullable<SimulationDynamicPlayFrameV1['playerDecision']> | null;
+export declare function projectDynamicTimeline(history: readonly SimulationDynamicHistoryEntryV1[], agents: readonly SimulationPersistentAgentStateV1[]): SimulationDynamicPlayFrameV1['timeline'];
+export declare function projectDynamicAgents(agents: readonly SimulationPersistentAgentStateV1[], history: readonly SimulationDynamicHistoryEntryV1[], responses: SimulationGmProposalV1['characterResponses']): SimulationDynamicAgentViewV1[];
+export declare function projectDynamicDomainObjectsForActor(objects: readonly SimulationDynamicDomainObjectV1[], actorId: string): SimulationDynamicDomainObjectViewV1[];
+export declare function projectDynamicEffectsForActor(effects: readonly SimulationDynamicWorldEffectV1[], resources: readonly PublicResourceDefinition[], actorId: string, actions?: readonly SimulationDomainActionProposalV1[], actors?: readonly Pick<SimulationPersistentAgentStateV1, 'actorId' | 'name'>[]): SimulationDynamicWorldEffectViewV1[];
+export declare function dynamicObjectVisibleToActor(object: SimulationDynamicDomainObjectV1, actorId: string): boolean;
+export {};

package/dist/simulation/toolkit/dynamic_projection.js

@@ -0,0 +1,219 @@
+export function projectDynamicPlayerDecision(history) {
+    const ruling = history.at(-1)?.gmProposal.playerAdjudication;
+    if (!ruling)
+        return null;
+    const choice = history.at(-2)?.gmProposal.availableActions
+        .find(action => action.id === ruling.playerActionId);
+    return {
+        label: history.at(-1)?.playerIntent?.slice(0, 120) ?? choice?.label ?? 'Your opening move',
+        playerActionId: ruling.playerActionId,
+        outcome: ruling.outcome,
+        reason: ruling.reason,
+    };
+}
+const MAX_TIMELINE_ACTIONS_PER_BEAT = 6;
+// The timeline tells each beat twice: one entry per committed autonomous action
+// (an interaction when it targets or changes another agent), then the beat itself.
+export function projectDynamicTimeline(history, agents) {
+    const humanIds = new Set(agents.filter(agent => agent.humanControlled).map(agent => agent.actorId));
+    return history.flatMap((entry) => {
+        const proposal = entry.gmProposal;
+        const actions = (proposal?.domainActions ?? [])
+            .filter(action => action.actorId !== undefined
+            && action.sourcePlayerActionId === undefined
+            && !humanIds.has(action.actorId))
+            .slice(0, MAX_TIMELINE_ACTIONS_PER_BEAT)
+            .map((action) => {
+            const actorId = action.actorId ?? '';
+            const citing = new Set((proposal.agentUpdates ?? [])
+                .filter(update => update.sourceActionIds.includes(action.id))
+                .map(update => update.actorId));
+            const ruling = (proposal.adjudications ?? []).find(candidate => candidate.actionIds.includes(action.id));
+            const target = action.targetActorId === undefined ? '' : ` → ${actorName(agents, action.targetActorId)}`;
+            return {
+                revision: entry.revision,
+                eventId: entry.eventId,
+                kind: action.targetActorId !== undefined || citing.size > 1
+                    ? 'agent-interaction'
+                    : 'agent-action',
+                title: clipText(`${actorName(agents, actorId)}${target} · ${humanize(action.mechanic)}`, 160),
+                summary: clipText(ruling?.reason ?? action.reason, 2_000),
+            };
+        });
+        const replans = proposal.agentUpdates.filter(update => update.sourceAdjudicationProposalIds !== undefined)
+            .slice(0, MAX_TIMELINE_ACTIONS_PER_BEAT - actions.length)
+            .map(update => {
+            const actor = agents.find(candidate => candidate.actorId === update.actorId);
+            const visiblePlan = update.nextIntent !== null && actor?.goals.some(goal => goal.id === update.nextIntent?.goalId && (goal.visibility === 'public' || goal.visibility === 'player-known'));
+            return {
+                revision: entry.revision,
+                eventId: entry.eventId,
+                kind: 'adjudication',
+                title: clipText(`${actorName(agents, update.actorId)} · Plan after failed attempt`, 160),
+                summary: clipText(`Their attempted action did not commit.${visiblePlan ? ` ${update.nextIntent?.summary}` : ''}`, 2_000),
+            };
+        });
+        const review = entry.storyReview;
+        const reviews = review === undefined ? [] : [{ revision: entry.revision, eventId: entry.eventId, kind: 'story-review',
+                title: review.status === 'rejected' ? 'Story review failed' : `Story review: ${review.decision.kind}`,
+                summary: review.status === 'rejected' ? 'No story judgment was accepted. The validated world transition remains recorded.' : review.decision.explanation }];
+        return [...actions, ...replans, ...reviews, {
+                revision: entry.revision,
+                eventId: entry.eventId,
+                kind: entry.kind,
+                title: entry.title,
+                summary: entry.summary,
+            }];
+    });
+}
+function clipText(value, maximum) {
+    return value.length <= maximum ? value : `${value.slice(0, maximum - 1)}…`;
+}
+export function projectDynamicAgents(agents, history, responses) {
+    const playerActorId = agents.find(agent => agent.humanControlled)?.actorId;
+    return agents.map(agent => {
+        const response = responses.find(item => item.actorId === agent.actorId);
+        const intentGoal = agent.currentIntent === null
+            ? undefined
+            : agent.goals.find(goal => goal.id === agent.currentIntent?.goalId);
+        const recent = history
+            .flatMap(entry => entry.gmProposal.domainActions
+            .filter(action => action.actorId === agent.actorId)
+            .map((action) => {
+            const adjudication = entry.gmProposal.adjudications
+                .find(candidate => candidate.actionIds.includes(action.id));
+            const target = action.targetActorId === undefined
+                ? 'the world'
+                : agents.find(candidate => candidate.actorId === action.targetActorId)?.name
+                    ?? action.targetActorId;
+            return {
+                action,
+                eventId: entry.eventId,
+                outcome: adjudication?.outcome ?? 'accepted',
+                target,
+            };
+        }))
+            .slice(-3);
+        return {
+            id: agent.actorId,
+            name: agent.name,
+            role: agent.role,
+            humanControlled: agent.humanControlled,
+            mood: response?.mood ?? 'Watching',
+            currentIntent: agent.currentIntent === null
+                ? null
+                : intentGoal?.visibility === 'private'
+                    ? 'Private intent'
+                    : agent.currentIntent.summary,
+            goals: agent.goals.map((goal, index) => knowledge(goal.id, goal.description, goal.visibility, `redacted-goal-${index + 1}`, goal.priority)),
+            beliefs: agent.beliefs.map((belief, index) => knowledge(belief.id, belief.claim, belief.visibility, `redacted-belief-${index + 1}`, belief.confidence, belief.evidenceEventIds.at(-1))),
+            relationships: agent.relationships.map((relationship, index) => knowledge(`relationship-${agent.actorId}-${relationship.targetActorId}`, relationship.visibility === 'private'
+                ? 'Private relationship state'
+                : `${actorName(agents, relationship.targetActorId)}: trust ${relationship.trust}, obligation ${relationship.obligation}`, relationship.visibility, `redacted-relationship-${index + 1}`, relationship.trust, relationship.changedByEventId)),
+            memories: agent.memories.slice(-6).map((memory, index) => knowledge(memory.id, memory.summary, memory.visibility, `redacted-memory-${index + 1}`, memory.salience, memory.eventId)),
+            resources: Object.entries(agent.resources)
+                .sort(([left], [right]) => left.localeCompare(right))
+                .flatMap(([id, value]) => {
+                const visibility = agent.resourceVisibility[id];
+                const visible = agent.actorId === playerActorId
+                    || visibility === 'public'
+                    || visibility === 'player-known';
+                return visible
+                    ? [{
+                            id: `resource-${agent.actorId}-${id}`,
+                            text: humanize(id),
+                            value,
+                            visibility: visibility === 'public' ? 'public' : 'player-known',
+                        }]
+                    : [];
+            }),
+            recentAutonomousActions: recent.map(item => ({
+                id: item.action.id,
+                text: `${humanize(item.action.mechanic)} → ${item.target} · ${item.outcome}: ${item.action.reason}`,
+                sourceEventId: item.eventId,
+                visibility: 'player-known',
+            })),
+        };
+    });
+}
+export function projectDynamicDomainObjectsForActor(objects, actorId) {
+    const visible = objects.filter(object => dynamicObjectVisibleToActor(object, actorId));
+    const visibleIds = new Set(visible.map(object => object.id));
+    return visible.map(object => ({
+        id: object.id,
+        kind: object.kind,
+        label: object.label,
+        status: object.status,
+        version: object.version,
+        ownerActorId: object.ownerActorId,
+        data: structuredClone(object.data),
+        links: structuredClone(object.links.filter(link => (link.targetType !== 'object' || visibleIds.has(link.targetId)))),
+        updatedRevision: object.provenance.updatedRevision,
+    }));
+}
+export function projectDynamicEffectsForActor(effects, resources, actorId, actions = [], actors = []) {
+    const resourcesById = new Map(resources
+        .filter(resource => resource.visibility !== 'private')
+        .map(resource => [resource.id, resource]));
+    return effects.flatMap((effect) => {
+        if (effect.operation === 'resource.change') {
+            const resource = resourcesById.get(effect.resourceId);
+            const source = actions.find(action => action.id === effect.actionId);
+            return resource === undefined
+                ? []
+                : [{
+                        operation: effect.operation,
+                        resourceId: effect.resourceId,
+                        resourceLabel: resource.label,
+                        delta: effect.delta,
+                        ...(source === undefined ? {} : { cause: {
+                                actor: source.actorId === undefined ? 'World event'
+                                    : actors.find(actor => actor.actorId === source.actorId)?.name ?? 'Participant',
+                                action: humanize(source.mechanic),
+                                reason: source.reason,
+                            } }),
+                    }];
+        }
+        if ('fact' in effect) {
+            return [{
+                    operation: effect.operation,
+                    fact: effect.fact,
+                }];
+        }
+        if (!dynamicObjectVisibleToActor(effect.object, actorId))
+            return [];
+        return [{
+                operation: effect.operation,
+                objectId: effect.object.id,
+                objectKind: effect.object.kind,
+                objectLabel: effect.object.label,
+                status: effect.object.status,
+                version: effect.object.version,
+                expectedVersion: effect.expectedVersion,
+                ownerActorId: effect.object.ownerActorId,
+            }];
+    });
+}
+export function dynamicObjectVisibleToActor(object, actorId) {
+    return object.visibility.scope === 'world'
+        || (object.visibility.scope === 'shared'
+            && object.visibility.actorIds.includes(actorId))
+        || (object.visibility.scope === 'private' && object.ownerActorId === actorId);
+}
+function actorName(agents, actorId) {
+    return agents.find(agent => agent.actorId === actorId)?.name ?? actorId;
+}
+function knowledge(id, text, visibility, redactedId, value, sourceEventId) {
+    return visibility === 'private'
+        ? { id: redactedId, text: 'Private knowledge', visibility: 'redacted' }
+        : {
+            id,
+            text,
+            visibility,
+            ...(value === undefined ? {} : { value }),
+            ...(sourceEventId === undefined ? {} : { sourceEventId }),
+        };
+}
+function humanize(value) {
+    return value.replaceAll('-', ' ').replace(/\b\w/g, character => character.toUpperCase());
+}