@dsh-agentic-roleplay/state 0.0.0-stage → 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,3299 @@
+import { Context, Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { ObjectJsonSchema, ToolDefinition } from "@deepseek-ai/dsh-tools";
+//#region ../dsh-roleplay-model/src/json.d.ts
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+//#endregion
+//#region ../dsh-roleplay-model/src/emotion.d.ts
+/** Each axis runs from -1 to 1. */
+interface EmotionVector {
+  valence: number;
+  arousal: number;
+  dominance: number;
+}
+interface EmotionStart {
+  /** Slow-moving temperament. */
+  baseline: EmotionVector;
+  /** How the character feels right now; the baseline when not given. */
+  immediate: EmotionVector;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/intent.d.ts
+declare const INTENT_TYPES: readonly ["need", "obligation", "quest", "agenda", "aspiration", "relationship", "habit", "reaction"];
+declare const INTENT_STATUSES: readonly ["active", "paused", "completed", "failed", "abandoned"];
+declare const INTENT_HORIZONS: readonly ["immediate", "short", "day", "long", "open_ended"];
+type IntentType = typeof INTENT_TYPES[number];
+type IntentStatus = typeof INTENT_STATUSES[number];
+type IntentHorizon = typeof INTENT_HORIZONS[number];
+/** A driving thread behind what a character does. */
+interface Intent {
+  type: IntentType;
+  name: string;
+  description: string;
+  status: IntentStatus;
+  horizon: IntentHorizon;
+  /** 0 to 1. */
+  priority: number;
+  /** 0 to 1. */
+  urgency: number;
+  plan: string[];
+  openThreads: string[];
+  constraints: string[];
+  /** ISO 8601 date-time. */
+  deadline?: string;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/state.d.ts
+/**
+ * Where a character stands when the story begins, as if loaded from a save
+ * made just after the story started.
+ */
+interface CharacterStart {
+  /** What anyone present can see or work out. */
+  publicState: string;
+  /** What the character thinks and feels; nobody else can see it. */
+  innerState: string;
+  /** What the character is concretely doing, which may differ from how it looks. */
+  activity: string;
+  emotion?: EmotionStart;
+  intents: Intent[];
+  /** The place it stands in, by its id in the world's files, and where in it. */
+  place?: {
+    location: string;
+    position?: string;
+    feature?: string;
+  };
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/session.d.ts
+declare const CHARACTER_CONTROLS: readonly ["player", "agent"];
+type CharacterId = number;
+type IntentId = number;
+/** Who decides what a character does in a session. */
+type CharacterControl = typeof CHARACTER_CONTROLS[number];
+/**
+ * Where a session's world came from. The session keeps no copy of the world,
+ * so this is only a reference; further provenance can go in `extra` without a
+ * schema change.
+ */
+interface WorldReference {
+  /** The world's stable id, kept in its `world.json`; not a database id. */
+  id: string;
+  name: string;
+  version?: string;
+  /** Identifies the exact world content the session was started from. */
+  fingerprint?: string;
+  source?: string;
+  extra?: Record<string, JsonValue>;
+}
+interface NewSession {
+  /** Also the name of the session's folder. */
+  id: string;
+  /** What the player calls the session; usually starts as the world's name. */
+  name: string;
+  world: WorldReference;
+}
+interface SessionMetadata extends NewSession {
+  createdAt: string;
+  /** When the last turn was played; absent for a session that has not been played yet. */
+  lastPlayedAt?: string;
+  /** Turns played so far. */
+  turns: number;
+}
+/** A character in a session: the definition without its start state, under a session-local id. */
+interface Character extends Omit<CharacterDefinition, 'id' | 'start'> {
+  id: CharacterId;
+  /** The character's provisional id in the world it came from; absent when created during play. */
+  sourceId?: string;
+  control: CharacterControl;
+  createdAt: string;
+}
+type NewCharacter = Omit<Character, 'id' | 'createdAt'>;
+/** What of a character can be edited: who it is, not who controls it. A field left out stays; `null` takes an optional one away. */
+interface CharacterPatch {
+  name?: string;
+  aliases?: string[];
+  age?: string | null;
+  gender?: string | null;
+  pronouns?: string | null;
+  kind?: Character['kind'];
+  tier?: Character['tier'];
+  role?: Character['role'];
+  summary?: string;
+  personality?: string;
+  background?: string;
+  appearance?: string;
+  speech?: Character['speech'];
+  voice?: string | null;
+}
+interface CharacterFilter {
+  role?: Character['role'];
+  tier?: Character['tier'];
+  kind?: Character['kind'];
+  control?: CharacterControl;
+}
+/** A character's current state; it starts as the world's `start` block and changes during play. */
+interface CharacterState extends Omit<CharacterStart, 'intents' | 'emotion'> {
+  characterId: CharacterId;
+  /** Increases with every change, for detecting conflicting updates. */
+  version: number;
+  updatedAt: string;
+}
+type NewCharacterState = Omit<CharacterStart, 'intents' | 'emotion'>;
+/** Fields left out stay as they are. */
+interface CharacterStatePatch {
+  publicState?: string;
+  innerState?: string;
+  activity?: string;
+}
+interface CharacterIntent extends Intent {
+  id: IntentId;
+  characterId: CharacterId;
+  createdAt: string;
+  updatedAt: string;
+}
+/** Fields left out stay as they are; `null` removes the deadline. */
+type IntentPatch = Partial<Omit<Intent, 'deadline'>> & {
+  deadline?: string | null;
+};
+interface IntentFilter {
+  status?: Intent['status'];
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/variable.d.ts
+/** What a variable holds: a number within bounds, a yes or no, or one of a list of words. */
+declare const VARIABLE_KINDS: readonly ["number", "flag", "choice"];
+type VariableKind = (typeof VARIABLE_KINDS)[number];
+/** What a variable is about: each character, item or place has its own value; `world` has one value for the whole story. */
+declare const VARIABLE_SUBJECTS: readonly ["character", "item", "location", "world"];
+type VariableSubject = (typeof VARIABLE_SUBJECTS)[number];
+/**
+ * Who can tell what the value is. `public`: anyone present (what shows). `private`: the character it belongs to, and the
+ * game master (what it feels or knows of itself). `hidden`: only the game master and the record keeper.
+ */
+declare const VARIABLE_VISIBILITIES: readonly ["public", "private", "hidden"];
+type VariableVisibility = (typeof VARIABLE_VISIBILITIES)[number];
+type VariableValue = number | boolean | string;
+/** The word for a number up to a bound: values up to `upTo` (and above the previous band) are called `label`. */
+interface VariableBand {
+  upTo: number;
+  label: string;
+}
+/** A kind of thing the story keeps track of, declared by a world, by the story, or built in. */
+interface VariableDefinition {
+  /** Lowercase letters, digits and underscores, starting with a letter. */
+  key: string;
+  name: string;
+  /** What it measures or means, for the models that read and change it. */
+  description: string;
+  kind: VariableKind;
+  subject: VariableSubject;
+  /** The subjects it applies to, by their keys; every subject of its kind when empty. */
+  only: string[];
+  /** The bounds of a number. */
+  min?: number;
+  max?: number;
+  /** Whether a number is a whole number. */
+  integer: boolean;
+  /** The words a choice is one of. */
+  options: string[];
+  /** What it is for a subject that has no value of its own yet. */
+  default: VariableValue;
+  /** Whether each value has a baseline beside the current one: the slow-moving temperament the current value is measured from (feelings). */
+  baseline: boolean;
+  visibility: VariableVisibility;
+  /** Words for ranges of a number, lowest first; the last one covers whatever is above. */
+  bands: VariableBand[];
+  /** Whether it is always told, even at its default; otherwise only once it differs from it. */
+  always: boolean;
+  /** Built in: it cannot be removed, and what it is cannot be changed. */
+  builtin: boolean;
+}
+/** A variable as the world's files write it: what is left out takes its default. */
+type VariableDefinitionInput = Pick<VariableDefinition, 'key' | 'name' | 'kind' | 'subject'> & Partial<Omit<VariableDefinition, 'key' | 'name' | 'kind' | 'subject' | 'builtin'>>;
+interface StoredVariable {
+  variable: string;
+  subject: VariableSubject;
+  /** 0 for the world. */
+  subjectId: number;
+  value: VariableValue;
+  baseline?: VariableValue;
+  updatedTurn: number;
+}
+declare const VARIABLE_KEY: RegExp;
+/** At most this many variables in a story, so that what is tracked stays something a model can hold. */
+declare const MAX_VARIABLES = 60;
+/** The feelings every character has: built in, from -1 to 1, with a temperament beside the current value. */
+declare const EMOTION_VARIABLES: readonly VariableDefinition[];
+//#endregion
+//#region ../dsh-roleplay-model/src/visual.d.ts
+declare const VISUAL_SUBJECT_KINDS: readonly ["character", "location", "item"];
+type VisualSubjectKind = typeof VISUAL_SUBJECT_KINDS[number];
+/** Stable, provider-neutral visual facts that every image of an entity should preserve. */
+interface VisualIdentityInput {
+  description: string;
+  tags: string[];
+  negativeTags: string[];
+  /** A globally unique identity when the entity has one; world-local ids remain valid without it. */
+  globalId?: string;
+}
+/** A visual identity attached to one entity of a session. */
+interface VisualIdentity extends VisualIdentityInput {
+  subjectKind: VisualSubjectKind;
+  subjectId: number;
+  /** Increases when the canonical identity changes, so an image can name what it was made from. */
+  version: number;
+  updatedAt: string;
+}
+type VisualIdentityPatch = Partial<VisualIdentityInput>;
+//#endregion
+//#region ../dsh-roleplay-model/src/location.d.ts
+type LocationId = number;
+type ExitId = number;
+/** A named thing in a place that a story can point at: a desk, a window, a notice board. */
+interface LocationFeature {
+  /** Unique within its location; how authors and tools refer to it. */
+  key: string;
+  name: string;
+  description: string;
+}
+/** At most this many features describe one place, so that a place never overwhelms a prompt. */
+declare const MAX_LOCATION_FEATURES = 30;
+interface Location {
+  id: LocationId;
+  /** The id of the place in the world's files; absent for a place made up in play. */
+  sourceId?: string;
+  name: string;
+  description: string;
+  /** The place this one is in (a room in a building, a building in a district). Containment only: it does not say how to get from one to the other. */
+  parentId?: LocationId;
+  features: LocationFeature[];
+  createdAt: string;
+}
+type NewLocation = Omit<Location, 'id' | 'createdAt'>;
+/** What may change about a place once it exists; where it is stays. */
+type LocationPatch = Partial<Pick<Location, 'name' | 'description' | 'features'>>;
+/** Whether people can go through an exit now. */
+declare const EXIT_STATES: readonly ["open", "locked", "blocked"];
+type ExitState = (typeof EXIT_STATES)[number];
+/** A way from one place to another, one direction at a time; a door usually has one each way. */
+interface Exit {
+  id: ExitId;
+  fromId: LocationId;
+  toId: LocationId;
+  /** What it looks like from the place it leaves: "a narrow stair down to the cellar". */
+  description: string;
+  /** How long going through takes, when it is known. Authored data; nothing here runs a clock. */
+  travelSeconds?: number;
+  /** Open to use; locked until something unlocks it; blocked until the way is cleared. */
+  state: ExitState;
+  /** Why it is locked or blocked, or what opens it. */
+  note: string;
+}
+type NewExit = Omit<Exit, 'id' | 'state' | 'note'> & {
+  state?: ExitState;
+  note?: string;
+};
+type ExitPatch = Partial<Omit<Pick<Exit, 'description' | 'travelSeconds' | 'state' | 'note'>, 'travelSeconds'> & {
+  travelSeconds: number | null;
+}>;
+/** The kinds of thing that can stand in a place. Characters now; items and containers are placed the same way. */
+declare const PLACEABLE_KINDS: readonly ["character"];
+type PlaceableKind = (typeof PLACEABLE_KINDS)[number];
+interface Placement {
+  kind: PlaceableKind;
+  entityId: CharacterId;
+  locationId: LocationId;
+  /** Where in the place, in words: "at the bar", "by the door". */
+  position: string;
+  /** The feature of the place it is at or by, when it is one. */
+  featureKey?: string;
+}
+interface NewPlacement {
+  locationId: LocationId;
+  position?: string;
+  featureKey?: string;
+}
+/** A request to go somewhere. */
+interface Move {
+  to: LocationId;
+  position?: string;
+  featureKey?: string;
+  /** Skip the exits: the story itself carries the character (carried off, teleported, falls). */
+  ignoreExits?: boolean;
+}
+/** How a move would go: the places passed through, in order, ending at the destination. */
+interface MovePlan {
+  from?: LocationId;
+  to: LocationId;
+  via: LocationId[];
+  /** The summed travel time when every exit on the way has one. */
+  travelSeconds?: number;
+}
+/** One way out of a place as the world's files write it. */
+interface ExitDefinition {
+  /** The id of the place it leads to. */
+  to: string;
+  description: string;
+  /** Whether there is no way back; otherwise the way back is made too. */
+  oneWay: boolean;
+  backDescription?: string;
+  travelSeconds?: number;
+  state: ExitState;
+  note: string;
+  /** The ids of the items that open it when it is locked. */
+  openedBy?: string[];
+}
+/** A place as the world's files write it, before it is put in a session. */
+interface LocationDefinition {
+  id: string;
+  name: string;
+  description: string;
+  visualIdentity?: VisualIdentityInput;
+  /** The id of the place it is in. */
+  parent?: string;
+  features: LocationFeature[];
+  exits: ExitDefinition[];
+  /** What it starts with of what the world tracks, by variable key. */
+  variables?: Record<string, VariableValue>;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/agenda.d.ts
+/** A recurring stretch of the day in which a character is occupied with something, in a place. */
+interface RoutineWindow {
+  /** The days of the week it applies on, 0 for Sunday; every day when empty. A window past midnight belongs to the day it starts on. */
+  days: number[];
+  /** The minute of the day it starts, 0 to 1439. */
+  start: number;
+  /** The minute it ends (exclusive); before `start` it ends the next day. Equal to `start` is not a window. */
+  end: number;
+  activity: string;
+  locationId?: LocationId;
+  featureKey?: string;
+  /** Where in the place, in words. */
+  position?: string;
+  /** Whether the character will drop it to join something that comes up; a shift at work may not be. */
+  interruptible: boolean;
+}
+interface StoredRoutineWindow extends RoutineWindow {
+  id: number;
+  characterId: CharacterId;
+}
+/** A routine window as a world's files write it. */
+interface RoutineDefinition {
+  /** Three-letter days (`mon` to `sun`); every day when left out. */
+  days: string[];
+  /** `HH:MM`. */
+  from: string;
+  to: string;
+  activity: string;
+  /** The id of a place in the world. */
+  location?: string;
+  feature?: string;
+  position?: string;
+  interruptible: boolean;
+}
+declare const WEEKDAY_NAMES: readonly ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+type EngagementId = number;
+declare const ENGAGEMENT_STATUSES: readonly ["pending", "kept", "missed", "cancelled"];
+type EngagementStatus = (typeof ENGAGEMENT_STATUSES)[number];
+/** Something dated that characters have committed to: a meeting, an errand, an event they are to attend. */
+interface Engagement {
+  id: EngagementId;
+  title: string;
+  /** When it is due, in UTC milliseconds. */
+  at: number;
+  /** When it is over, when that is not simply soon after `at`. */
+  until?: number;
+  locationId?: LocationId;
+  participants: CharacterId[];
+  status: EngagementStatus;
+  note: string;
+  createdTurn: number;
+  updatedTurn: number;
+}
+interface NewEngagement {
+  title: string;
+  at: number;
+  until?: number;
+  locationId?: LocationId;
+  participants: CharacterId[];
+  note?: string;
+  turn: number;
+}
+interface EngagementPatch {
+  title?: string;
+  at?: number;
+  until?: number;
+  locationId?: LocationId;
+  participants?: CharacterId[];
+  status?: EngagementStatus;
+  note?: string;
+  turn: number;
+}
+interface EngagementFilter {
+  status?: EngagementStatus;
+  participant?: CharacterId;
+  /** Only those due at or after this instant. */
+  from?: number;
+  /** Only those due before this instant. */
+  to?: number;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/relationship.d.ts
+type RelationshipId = number;
+/** How a character stands towards another: a short profile, not a single edge. Each direction is its own profile. */
+interface Relationship {
+  id: RelationshipId;
+  /** Whose view it is. */
+  fromId: CharacterId;
+  toId: CharacterId;
+  /** What the other is to this character, in a word or two: "sister", "rival", "landlord". */
+  label: string;
+  /** The relationship in a sentence or two: how it came about, what it is like now. */
+  summary: string;
+  /** How well it knows the other, from 0 (a stranger) to 1 (intimately). */
+  familiarity: number;
+  /** From -1 (distrusts) to 1 (trusts completely). */
+  trust: number;
+  /** From -1 (dislikes) to 1 (is fond of). */
+  affinity: number;
+  /** How strained it is right now, from 0 to 1. */
+  tension: number;
+  /** The turn it last changed. */
+  updatedTurn: number;
+  createdAt: string;
+}
+interface NewRelationship {
+  fromId: CharacterId;
+  toId: CharacterId;
+  label: string;
+  summary?: string;
+  familiarity?: number;
+  trust?: number;
+  affinity?: number;
+  tension?: number;
+}
+type RelationshipPatch = Partial<Pick<Relationship, 'label' | 'summary' | 'familiarity' | 'trust' | 'affinity' | 'tension'>>;
+/** A relationship as the world's files write it: from the character whose file it is in, to another by its id in the world. */
+interface RelationshipDefinition {
+  to: string;
+  label: string;
+  summary: string;
+  familiarity: number;
+  trust: number;
+  affinity: number;
+  tension: number;
+}
+/** What was made up in play and still has to be fitted into the rest of the world. */
+declare const CONSOLIDATION_KINDS: readonly ["character", "location", "item"];
+type ConsolidationKind = (typeof CONSOLIDATION_KINDS)[number];
+type ConsolidationItemId = number;
+interface ConsolidationItem {
+  id: ConsolidationItemId;
+  kind: ConsolidationKind;
+  /** The id of the character or place. */
+  subjectId: number;
+  /** Why it was made, in the words of whoever asked for it. */
+  note: string;
+  createdTurn: number;
+  resolvedTurn?: number;
+  /** What was done to fit it in, when it is resolved. */
+  resolution?: string;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/knowledge.d.ts
+declare const KNOWLEDGE_KINDS: readonly ["location", "item", "exit", "lore"];
+type KnowledgeKind = typeof KNOWLEDGE_KINDS[number];
+/** That a character knows a place, thing or way exists. Current facts about it come from perception and memory. */
+interface EntityKnowledge {
+  characterId: CharacterId;
+  subjectKind: KnowledgeKind;
+  subjectId: number;
+  learnedTurn: number;
+  lastObservedTurn?: number;
+}
+/** What a character file says the character knows when the story starts. */
+interface KnowledgeDefinition {
+  locations: string[];
+  items: string[];
+  exits: {
+    from: string;
+    to: string;
+  }[];
+  lore?: string[];
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/character.d.ts
+declare const CHARACTER_ROLES: readonly ["playable", "npc"];
+declare const CHARACTER_TIERS: readonly ["principal", "supporting", "background"];
+declare const CHARACTER_KINDS: readonly ["person", "group"];
+/** Whether the player may choose the character; a world can offer several. */
+type CharacterRole = typeof CHARACTER_ROLES[number];
+/**
+ * How much simulation a character gets: principals act on their own,
+ * supporting characters act when the scene involves them, background
+ * characters only react as the world changes.
+ */
+type CharacterTier = typeof CHARACTER_TIERS[number];
+/** A single person, or a crowd or organisation treated as one participant. */
+type CharacterKind = typeof CHARACTER_KINDS[number];
+interface CharacterSpeech {
+  style: string;
+  examples: string[];
+}
+/** A character as authored in a world. */
+interface CharacterDefinition {
+  /** Provisional, unique within the world; only for links inside the exported files. */
+  id: string;
+  name: string;
+  /** Nicknames and other names the character answers to. */
+  aliases: string[];
+  age?: string;
+  gender?: string;
+  /** May differ from the gender, for example "she/her". */
+  pronouns?: string;
+  kind: CharacterKind;
+  tier: CharacterTier;
+  role: CharacterRole;
+  /** One or two sentences, for lists and previews. */
+  summary: string;
+  personality: string;
+  background: string;
+  appearance: string;
+  /** Stable visual facts; current expression, clothing, activity and surroundings do not belong here. */
+  visualIdentity?: VisualIdentityInput;
+  speech: CharacterSpeech;
+  /** Provider voice id used for spoken utterances. */
+  voice?: string;
+  start: CharacterStart;
+  /** How this character stands towards others of the world, by their ids. */
+  relationships?: RelationshipDefinition[];
+  /** Places, things and ways this character knows exist when the story starts. */
+  knowledge?: KnowledgeDefinition;
+  /** The recurring day of the character: what it is doing and where, by the clock. */
+  routine?: RoutineDefinition[];
+  /** What it starts with of what the world tracks (a value for each of the variables named), by variable key. */
+  variables?: Record<string, VariableValue>;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/item.d.ts
+type ItemId = number;
+/** Whether a container can be got into. */
+declare const CONTAINER_STATES: readonly ["open", "closed", "locked"];
+type ContainerState = (typeof CONTAINER_STATES)[number];
+/** A place on the body something can be worn. Worlds can have their own; these are what a world starts with. */
+interface Slot {
+  /** Short and lowercase: how items and tools name it. */
+  id: string;
+  name: string;
+  /** How many things can be worn there at once. */
+  capacity: number;
+}
+declare const SLOT_ID: RegExp;
+declare const DEFAULT_SLOTS: readonly Slot[];
+/** What can hold other things: a chest, a satchel, a drawer. */
+interface ContainerSpec {
+  state: ContainerState;
+}
+/**
+ * A thing that can be moved, held, worn, opened or used: one kind for everything physical. What it
+ * can do is what it has: a slot it is worn in, a container it holds things in, a quantity when there
+ * are several alike. Scenery that cannot be moved (a desk, a window) is a feature of its place instead.
+ */
+interface Item {
+  id: ItemId;
+  /** The id in the world's files; absent for something made up in play. */
+  sourceId?: string;
+  name: string;
+  description: string;
+  /** How many there are, for things that come in numbers (coins, arrows). */
+  quantity: number;
+  /** Only one exists in the story: it is never split or merged. */
+  unique: boolean;
+  /** Its condition, in words: "worn", "freshly oiled". */
+  quality: string;
+  /** Matters to the story: told first and never left out of a short list. */
+  notable: boolean;
+  /** Not seen by anyone until it is found. */
+  hidden: boolean;
+  /** The slot it is worn in, when it can be worn. */
+  wearableSlot?: string;
+  container?: ContainerSpec;
+  /** Whose it is, which is not the same as who has it. */
+  ownerId?: CharacterId;
+  createdAt: string;
+}
+type NewItem = Omit<Item, 'id' | 'createdAt'>;
+type ItemPatch = Partial<Pick<Item, 'name' | 'description' | 'quantity' | 'quality' | 'notable' | 'hidden' | 'ownerId'>> & {
+  container?: ContainerSpec;
+};
+/** What holds an item: a place, a character (in its hands, or worn) or another item (inside it). */
+type Holder = {
+  kind: 'location';
+  locationId: LocationId;
+  position?: string;
+  featureKey?: string;
+} | {
+  kind: 'character';
+  characterId: CharacterId;
+  mode: 'held';
+} | {
+  kind: 'character';
+  characterId: CharacterId;
+  mode: 'worn';
+  slot: string;
+  position?: string;
+} | {
+  kind: 'item';
+  itemId: ItemId;
+  position?: string;
+};
+interface Holding {
+  itemId: ItemId;
+  holder: Holder;
+}
+/** What an item is, as the world's files write it, before it is put in a session. */
+interface ItemDefinition {
+  id: string;
+  name: string;
+  description: string;
+  visualIdentity?: VisualIdentityInput;
+  quantity: number;
+  unique: boolean;
+  quality: string;
+  notable: boolean;
+  hidden: boolean;
+  wearable?: string;
+  container?: {
+    state: ContainerState;
+    openedBy: string[];
+  };
+  owner?: string;
+  /** What it starts with of what the world tracks, by variable key. */
+  variables?: Record<string, VariableValue>;
+  /** Where it starts: one of these. */
+  start: {
+    kind: 'location';
+    location: string;
+    position?: string;
+    feature?: string;
+  } | {
+    kind: 'held';
+    character: string;
+  } | {
+    kind: 'worn';
+    character: string;
+    slot?: string;
+    position?: string;
+  } | {
+    kind: 'inside';
+    item: string;
+    position?: string;
+  };
+}
+/** The things the world says open its exits, by place and the id of the place it leads to. */
+interface ExitOpener {
+  from: string;
+  to: string;
+  items: string[];
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/memory.d.ts
+/** How a character came to take in an event. */
+declare const PERCEPTION_MODES: readonly ["witnessed", "heard", "told", "inferred"];
+type PerceptionMode = (typeof PERCEPTION_MODES)[number];
+/** How well what a character took in matches what happened; recorded for checking, never shown to the character. */
+declare const ACCURACIES: readonly ["accurate", "partial", "mistaken"];
+type Accuracy = (typeof ACCURACIES)[number];
+declare const MEMORY_KINDS: readonly ["belief", "relationship", "knowledge"];
+type MemoryKind = (typeof MEMORY_KINDS)[number];
+declare const THREAD_STATUSES: readonly ["open", "resolved"];
+type ThreadStatus = (typeof THREAD_STATUSES)[number];
+/** A digest covers a stretch of recent turns closely; a chapter covers older turns briefly. */
+declare const SUMMARY_LEVELS: readonly ["digest", "chapter"];
+type SummaryLevel = (typeof SUMMARY_LEVELS)[number];
+declare const IMPORTANCE_MIN = 1;
+declare const IMPORTANCE_MAX = 5;
+type EventId = number;
+type PerceptionId = number;
+type MemoryId = number;
+type ThreadId = number;
+type SummaryId = number;
+/** Something that objectively happened in the story: the ground truth the rest is derived from. */
+interface StoryEvent {
+  id: EventId;
+  turn: number;
+  round: number;
+  text: string;
+  /** From 1 (passing) to 5 (turns the story). */
+  importance: number;
+  tags: string[];
+  /** The characters the event is about: who acted, and who it was done to. */
+  involves: CharacterId[];
+  /** The things it is about: what was taken, opened, found. */
+  items: ItemId[];
+  /** Where it happened, when that is known. */
+  locationId?: LocationId;
+  /**
+   * Events are ground truth and cannot change once sealed, which happens when the records of the rounds they
+   * belong to are complete. Until then they are a draft that its writer may still correct.
+   */
+  sealed: boolean;
+  createdAt: string;
+}
+type NewStoryEvent = Omit<StoryEvent, 'id' | 'createdAt' | 'sealed' | 'items'> & {
+  items?: ItemId[];
+};
+interface StoryEventPatch {
+  text?: string;
+  importance?: number;
+  tags?: string[];
+  involves?: CharacterId[];
+  locationId?: LocationId;
+  items?: ItemId[];
+}
+interface StoryEventFilter {
+  /** Only events that happened in this place. */
+  locationId?: LocationId;
+  turn?: number;
+  round?: number;
+  fromTurn?: number;
+  toTurn?: number;
+  involving?: CharacterId;
+  /** Only events about this item. */
+  aboutItem?: ItemId;
+  minImportance?: number;
+}
+/** What one character took in of an event: its own version, which may be partial or wrong. */
+interface Perception {
+  id: PerceptionId;
+  eventId: EventId;
+  characterId: CharacterId;
+  mode: PerceptionMode;
+  /** What the character took in, in full. */
+  content: string;
+  /** The essence of it in a few words, which is what is left of it as it fades. */
+  gist: string;
+  accuracy: Accuracy;
+  recalls: number;
+  lastRecalledTurn?: number;
+  createdAt: string;
+}
+/** What may change about a perception: a character's version of an event is revised as it learns more or remembers it differently. */
+type PerceptionPatch = Partial<Pick<Perception, 'mode' | 'content' | 'gist' | 'accuracy'>>;
+interface NewPerception {
+  characterId: CharacterId;
+  mode: PerceptionMode;
+  content: string;
+  gist: string;
+  accuracy: Accuracy;
+}
+interface PerceivedEvent {
+  perception: Perception;
+  event: StoryEvent;
+}
+/** What a character has come to believe or know, beyond single events. */
+interface CharacterMemory {
+  id: MemoryId;
+  characterId: CharacterId;
+  kind: MemoryKind;
+  text: string;
+  /** The characters it is about. */
+  about: CharacterId[];
+  importance: number;
+  /** The turn it was formed in. */
+  turn: number;
+  recalls: number;
+  lastRecalledTurn?: number;
+  createdAt: string;
+}
+type NewCharacterMemory = Omit<CharacterMemory, 'id' | 'createdAt' | 'recalls' | 'lastRecalledTurn'>;
+interface CharacterMemoryPatch {
+  text?: string;
+  about?: CharacterId[];
+  importance?: number;
+}
+/** Something in the story that is not settled yet: a promise, a mystery, a goal. */
+interface StoryThread {
+  id: ThreadId;
+  text: string;
+  status: ThreadStatus;
+  openedTurn: number;
+  resolvedTurn?: number;
+}
+/** A written account of a stretch of turns, built from the events in it. */
+interface Summary {
+  id: SummaryId;
+  level: SummaryLevel;
+  fromTurn: number;
+  toTurn: number;
+  text: string;
+  createdAt: string;
+}
+type NewSummary = Omit<Summary, 'id' | 'createdAt'>;
+/** One recorded round whose events and memories have not been written yet. */
+interface PendingCommit {
+  turn: number;
+  round: number;
+  payload: JsonValue;
+  createdAt: string;
+}
+/** What a stored text belongs to: what a character took in, what it believes, or what happened (not any character's). */
+declare const RECALL_ITEM_KINDS: readonly ["perception", "memory", "event"];
+type RecallItemKind = (typeof RECALL_ITEM_KINDS)[number];
+/** One thing found by a search, by the key the recall uses for it: `p:<id>`, `m:<id>`, `e:<id>`. */
+interface RecallHit {
+  key: string;
+  kind: RecallItemKind;
+  /** The id of the perception, memory or event. */
+  refId: number;
+  /** From 0 (not related) to 1 (the best match of the search); for a lexical search relative to the best hit, for a vector search the cosine similarity. */
+  score: number;
+}
+/** What the vectors of a session were made by. They are only comparable with each other. */
+interface EmbeddingIndexInfo {
+  model: string;
+  dimensions: number;
+  /** How many texts have a vector. */
+  embedded: number;
+  /** How many texts still wait for one. */
+  pending: number;
+}
+/** A text that has no vector yet. */
+interface PendingEmbedding {
+  /** The id to give back with its vector. */
+  id: number;
+  kind: RecallItemKind;
+  text: string;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/faction.d.ts
+type FactionId = number;
+interface Faction {
+  id: FactionId;
+  sourceId?: string;
+  name: string;
+  aliases: string[];
+  summary: string;
+  description: string;
+  values: string[];
+  structure: string;
+  createdAt: string;
+}
+type NewFaction = Omit<Faction, 'id' | 'createdAt'>;
+type FactionPatch = Partial<Pick<Faction, 'name' | 'aliases' | 'summary' | 'description' | 'values' | 'structure'>>;
+interface FactionState {
+  factionId: FactionId;
+  publicState: string;
+  innerState: string;
+  version: number;
+  updatedAt: string;
+}
+interface NewFactionState {
+  publicState?: string;
+  innerState?: string;
+}
+type FactionStatePatch = Partial<NewFactionState>;
+declare const MEMBERSHIP_STATUSES: readonly ["active", "inactive", "former"];
+type MembershipStatus = typeof MEMBERSHIP_STATUSES[number];
+interface FactionMembership {
+  factionId: FactionId;
+  characterId: number;
+  role: string;
+  rank: string;
+  status: MembershipStatus;
+  public: boolean;
+  commitment: number;
+  joinedTurn: number;
+  leftTurn?: number;
+}
+type MembershipPatch = Partial<Pick<FactionMembership, 'role' | 'rank' | 'status' | 'public' | 'commitment' | 'leftTurn'>>;
+type SocialSubjectKind = 'character' | 'faction';
+interface FactionRelationship {
+  id: number;
+  fromKind: SocialSubjectKind;
+  fromId: number;
+  toKind: SocialSubjectKind;
+  toId: number;
+  label: string;
+  summary: string;
+  familiarity: number;
+  trust: number;
+  affinity: number;
+  tension: number;
+  updatedTurn: number;
+  createdAt: string;
+}
+interface FactionIntent extends Intent {
+  id: number;
+  factionId: FactionId;
+  createdAt: string;
+  updatedAt: string;
+}
+interface FactionRelationshipDefinition extends RelationshipPatch {
+  to: {
+    kind: SocialSubjectKind;
+    id: string;
+  };
+  label: string;
+}
+interface FactionMembershipDefinition {
+  character: string;
+  role: string;
+  rank: string;
+  status: MembershipStatus;
+  public: boolean;
+  commitment: number;
+}
+interface FactionDefinition {
+  id: string;
+  name: string;
+  aliases: string[];
+  summary: string;
+  description: string;
+  values: string[];
+  structure: string;
+  start: {
+    publicState: string;
+    innerState: string;
+    goals: Intent[];
+  };
+  members: FactionMembershipDefinition[];
+  relationships: FactionRelationshipDefinition[];
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/clock.d.ts
+/**
+ * How the story's time passes: `simulated` moves only when the story does (the game master says how
+ * long things take and may skip ahead), `real` follows the wall clock.
+ */
+declare const CLOCK_MODES: readonly ["simulated", "real"];
+type ClockMode = (typeof CLOCK_MODES)[number];
+/** The story's clock: the instant it is in the story, in milliseconds since the Unix epoch (UTC). */
+interface ClockState {
+  mode: ClockMode;
+  now: number;
+}
+/** Why the story's time moved. */
+declare const TIME_CHANGE_KINDS: readonly ["start", "elapsed", "real", "skip", "resync"];
+type TimeChangeKind = (typeof TIME_CHANGE_KINDS)[number];
+/** One step of the story's time. `round` is 0 for what happens outside a round. */
+interface TimeChange {
+  id: number;
+  turn: number;
+  round: number;
+  kind: TimeChangeKind;
+  from: number;
+  to: number;
+  reason: string;
+}
+interface TimeChangeFilter {
+  turn?: number;
+  round?: number;
+  fromTurn?: number;
+  toTurn?: number;
+  kind?: TimeChangeKind;
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/trigger.d.ts
+type TriggerId = number;
+declare const COMPARISONS: readonly ["eq", "ne", "lt", "le", "gt", "ge"];
+type Comparison = (typeof COMPARISONS)[number];
+/**
+ * When something happens, decided in code from what the story has recorded; nothing here is judged by a model.
+ * Keys name characters, places, items and variables as the world's files and the tools do. Times are local to
+ * the story's zone: `YYYY-MM-DDTHH:MM`, and `HH:MM` for a time of day.
+ */
+type TriggerCondition =
+/** True from `from` on, until `to`; or while the time of day is in `window` (past midnight when it ends before it starts), on `days` (`mon` to `sun`) when given. */
+{
+  type: 'time';
+  from?: string;
+  to?: string;
+  window?: {
+    from: string;
+    to: string;
+  };
+  days?: string[];
+} |
+/** A character is in a place, at a feature of it when given. */
+{
+  type: 'place';
+  character: string;
+  location: string;
+  feature?: string;
+} |
+/** A variable compares to a value; `subject` is the key of the character, item or place it is about, none for a world variable. */
+{
+  type: 'variable';
+  variable: string;
+  subject?: string;
+  op: Comparison;
+  value: VariableValue;
+} |
+/** An item is held by a character, or lies in a place (also inside something there). */
+{
+  type: 'item';
+  item: string;
+  heldBy?: string;
+  at?: string;
+} |
+/** An event with this tag was recorded. */
+{
+  type: 'event';
+  tag: string;
+} |
+/** Another trigger has fired. */
+{
+  type: 'fired';
+  trigger: string;
+} | {
+  type: 'all';
+  conditions: TriggerCondition[];
+} | {
+  type: 'any';
+  conditions: TriggerCondition[];
+} | {
+  type: 'not';
+  condition: TriggerCondition;
+};
+/** Who a cue is for, or who knows of something coming: everyone, named characters, or whoever is in a place at that moment. */
+type TriggerAudience = 'everyone' | {
+  characters: string[];
+} | {
+  place: string;
+};
+/**
+ * What is known before a trigger fires, and by whom: a scheduled event that is no secret (an exam, a ball, a deadline).
+ * Without it a trigger is a secret until it fires.
+ */
+interface TriggerAnnouncement {
+  audience: TriggerAudience;
+  /** What is known beforehand: the public side of it, never what the effects do. */
+  text: string;
+  /** When it becomes known, a local time; known from the start when left out. */
+  from?: string;
+  /** When it is to happen, a local time, as told with the announcement; the time the condition waits for when it is a plain one, if left out. */
+  at?: string;
+}
+/** What happens when a trigger fires. */
+type TriggerEffect =
+/** A checked change of the story's records, in the format of an edit (events, variable changes, exit and item changes, moves, goals, engagements). */
+{
+  type: 'edit';
+  edit: Record<string, unknown>;
+} |
+/** Something the game master is told to weave into the story, until it says it did or a few turns pass. */
+{
+  type: 'beat';
+  text: string;
+} |
+/** Something the audience notices, said to each of them the next time they act. */
+{
+  type: 'cue';
+  audience: TriggerAudience;
+  text: string;
+};
+declare const TRIGGER_STATUSES: readonly ["dormant", "fired", "failed", "expired"];
+type TriggerStatus = (typeof TRIGGER_STATUSES)[number];
+/** A trigger as a world's files, or the world author, write it. */
+interface TriggerDefinition {
+  key: string;
+  name: string;
+  condition: TriggerCondition;
+  effects: TriggerEffect[];
+  /** Whether it can fire again after it fired and its condition went false and true again. */
+  repeat: boolean;
+  /** With `repeat`, the least story time between two firings, in seconds. */
+  cooldownSeconds?: number;
+  /** The chance, 0 to 1, that a rising condition fires; a failed roll uses that rise up. */
+  chance?: number;
+  /** The higher goes first when several are due at once. */
+  priority: number;
+  /** After this local time it never fires. */
+  expires?: string;
+  /** Known beforehand by whom, and what; without it, nobody knows until it fires. */
+  announce?: TriggerAnnouncement;
+}
+interface Trigger extends TriggerDefinition {
+  id: TriggerId;
+  status: TriggerStatus;
+  fireCount: number;
+  lastFiredMs?: number;
+  /** What the condition was when it was last looked at, to see it rise. */
+  lastResult: boolean;
+  /** Why it failed, when it did. */
+  problem?: string;
+  origin: 'world' | 'story';
+  createdTurn: number;
+}
+declare const TRIGGER_NOTE_KINDS: readonly ["beat", "cue"];
+type TriggerNoteKind = (typeof TRIGGER_NOTE_KINDS)[number];
+/** What a fired trigger leaves to be told: a beat for the game master, a cue for characters. */
+interface TriggerNote {
+  id: number;
+  triggerId: TriggerId;
+  kind: TriggerNoteKind;
+  text: string;
+  /** The characters a cue is for. */
+  characterIds: number[];
+  turn: number;
+  status: 'pending' | 'done' | 'lapsed';
+}
+interface NewTriggerNote {
+  triggerId: TriggerId;
+  kind: TriggerNoteKind;
+  text: string;
+  characterIds?: number[];
+  turn: number;
+}
+/** At most this many triggers in a story. */
+declare const MAX_TRIGGERS = 200;
+//#endregion
+//#region ../dsh-roleplay-model/src/lore.d.ts
+type LoreId = number;
+declare const LORE_KINDS: readonly ["history", "culture", "religion", "politics", "geography", "science", "custom", "legend", "other"];
+type LoreKind = typeof LORE_KINDS[number];
+declare const LORE_SUBJECT_KINDS: readonly ["character", "faction", "location", "item", "lore"];
+type LoreSubjectKind = typeof LORE_SUBJECT_KINDS[number];
+interface LoreSubject {
+  kind: LoreSubjectKind;
+  id: number;
+}
+interface Lore {
+  id: LoreId;
+  sourceId?: string;
+  title: string;
+  kind: LoreKind;
+  summary: string;
+  body: string;
+  startsAt?: number;
+  endsAt?: number;
+  subjects: LoreSubject[];
+  related: LoreId[];
+  sources: string[];
+  createdAt: string;
+}
+type NewLore = Omit<Lore, 'id' | 'createdAt'>;
+type LorePatch = Partial<Pick<Lore, 'title' | 'kind' | 'summary' | 'body' | 'subjects' | 'related' | 'sources'>> & {
+  startsAt?: number | null;
+  endsAt?: number | null;
+};
+interface LoreSubjectDefinition {
+  kind: LoreSubjectKind;
+  id: string;
+}
+/** One independently addressable piece of canonical world lore. */
+interface LoreDefinition {
+  id: string;
+  title: string;
+  kind: LoreKind;
+  summary: string;
+  body: string;
+  startsAt?: number;
+  endsAt?: number;
+  subjects: LoreSubjectDefinition[];
+  related: string[];
+  sources: string[];
+}
+//#endregion
+//#region ../dsh-roleplay-model/src/plot.d.ts
+declare const PLOT_STATUSES: readonly ["dormant", "available", "engaged", "cooling", "resolved", "abandoned"];
+type PlotStatus = (typeof PLOT_STATUSES)[number];
+declare const PLOT_NUDGE_MODES: readonly ["opportunity", "reminder", "character", "consequence", "escalation", "breathing_room"];
+type PlotNudgeMode = (typeof PLOT_NUDGE_MODES)[number];
+interface PlotDevelopment {
+  id: string;
+  text: string;
+  mode: PlotNudgeMode;
+  prerequisites: string[];
+  guidance: string;
+  avoid: string[];
+}
+interface PlotDefinition {
+  id: string;
+  name: string;
+  premise: string;
+  themes: string[];
+  hooks: PlotDevelopment[];
+  developments: PlotDevelopment[];
+  stakes: string[];
+  resolutions: string[];
+  participants: string[];
+  start: PlotStatus;
+  pacing: {
+    quietTurns: number;
+    cooldownTurns: number;
+    cooldownDays: number;
+  };
+}
+interface PlotProgress {
+  plot: PlotDefinition;
+  status: PlotStatus;
+  introduced: string[];
+  rejected: string[];
+  lastNudgeTurn: number;
+  lastNudgeAt?: number;
+}
+//#endregion
+//#region src/clock.d.ts
+type Clock = () => Date;
+declare const systemClock: Clock;
+//#endregion
+//#region src/driver/types.d.ts
+type SqlValue = string | number | bigint | null | Uint8Array;
+interface RunResult {
+  changes: number;
+  lastInsertRowid: number;
+}
+/**
+ * The part of a SQLite connection the repositories rely on. It is synchronous
+ * because the embedded drivers are; a driver for a different SQLite library
+ * implements this interface and nothing else changes.
+ */
+interface SqlDatabase {
+  /** Run one or more statements without parameters or results. */
+  exec(sql: string): void;
+  run(sql: string, params?: readonly SqlValue[]): RunResult;
+  get<Row = Record<string, SqlValue>>(sql: string, params?: readonly SqlValue[]): Row | undefined;
+  all<Row = Record<string, SqlValue>>(sql: string, params?: readonly SqlValue[]): Row[];
+  /**
+   * Run `fn` atomically: its changes are kept when it returns and undone when
+   * it throws. A call inside another transaction joins it, and an error that
+   * is caught inside only undoes the inner part.
+   */
+  transaction<T>(fn: () => T): T;
+  close(): void;
+}
+interface OpenOptions {
+  /** Default `delete`, which keeps the database in a single file that can be copied. */
+  journalMode?: 'delete' | 'wal';
+  /** How long to wait for another connection's lock. Default 5000. */
+  busyTimeoutMs?: number;
+  /** Paths of loadable SQLite extensions to load into the connection; opening fails if one cannot be loaded. */
+  extensions?: readonly string[];
+}
+interface SqlDriver {
+  /** Open the database at `location` (a file path, or `:memory:`), creating the file when missing. */
+  open(location: string, options?: OpenOptions): SqlDatabase;
+}
+//#endregion
+//#region src/driver/node-sqlite.d.ts
+/** The driver built on Node's bundled SQLite (`node:sqlite`); it needs no native dependency. */
+declare const nodeSqliteDriver: SqlDriver;
+//#endregion
+//#region src/errors.d.ts
+declare class StateError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+/** The requested row does not exist. */
+declare class NotFoundError extends StateError {}
+/** The change clashes with existing data, such as a repeated id or a stale version. */
+declare class ConflictError extends StateError {}
+/** A value is outside what the schema allows. */
+declare class InvalidValueError extends StateError {}
+/** The file is not a session database, or was written by a newer version. */
+declare class SchemaError extends StateError {}
+/** Stored data cannot be read back as a canonical model. */
+declare class CorruptDataError extends StateError {}
+/** An edit of the story's records cannot be applied; it names every problem, and nothing was written. */
+declare class InvalidEditError extends StateError {
+  readonly problems: readonly string[];
+  constructor(problems: readonly string[]);
+}
+/** A character cannot go where it was sent; it names every reason, and nothing changed. */
+declare class InvalidMoveError extends StateError {
+  readonly problems: readonly string[];
+  constructor(problems: readonly string[]);
+}
+//#endregion
+//#region src/repositories.d.ts
+/**
+ * The repositories are the only way the rest of the code reads and writes a
+ * session. They take and return canonical models, so callers never see rows or
+ * SQL, and an implementation over another store can replace the SQLite one.
+ * Methods are synchronous and throw the errors in `errors.ts`.
+ */
+interface MetadataRepository {
+  get(): SessionMetadata;
+  /** @throws {RangeError} when the name is blank. */
+  setName(name: string): void;
+  /** Make the database the identity of a session: its id and name, and the time it was created (now unless given). Used for a copy and for a state put back; everything else stays as it was. */
+  rebrand(id: string, name: string, createdAt?: string): void;
+  setWorld(world: WorldReference): void;
+  /** Count one more played turn and set the time of the last play to now. */
+  recordTurn(): SessionMetadata;
+  /**
+   * Free-form entries for whatever else wants to remember something about the
+   * session. Keys should be namespaced, such as `mymodule.lastExport`; the
+   * session's own keys are reserved.
+   */
+  getValue(key: string): JsonValue | undefined;
+  setValue(key: string, value: JsonValue): void;
+  deleteValue(key: string): boolean;
+}
+interface CharacterRepository {
+  /** @throws {ConflictError} when `sourceId` is already used by another character. */
+  add(character: NewCharacter): Character;
+  get(id: CharacterId): Character | undefined;
+  getBySourceId(sourceId: string): Character | undefined;
+  list(filter?: CharacterFilter): Character[];
+  /** Characters whose name or alias matches, ignoring case. */
+  findByName(name: string): Character[];
+  /** @throws {NotFoundError} */
+  setControl(id: CharacterId, control: CharacterControl): Character;
+  /**
+   * Change who a character is. A playable character cannot be a group or a background character.
+   * @throws {NotFoundError} when the character does not exist. @throws {InvalidValueError} when the name is blank or the result is not allowed.
+   */
+  update(id: CharacterId, patch: CharacterPatch): Character;
+}
+interface CharacterStateRepository {
+  /**
+   * @throws {NotFoundError} when the character does not exist.
+   * @throws {ConflictError} when it already has a state.
+   */
+  create(characterId: CharacterId, state: NewCharacterState): CharacterState;
+  get(characterId: CharacterId): CharacterState | undefined;
+  /**
+   * @param options.expectedVersion - when given, the update only applies to that version of the state.
+   * @throws {NotFoundError} when the character has no state.
+   * @throws {ConflictError} when the state is at another version than expected.
+   */
+  update(characterId: CharacterId, patch: CharacterStatePatch, options?: {
+    expectedVersion?: number;
+  }): CharacterState;
+}
+interface FactionRepository {
+  add(faction: NewFaction): Faction;
+  get(id: FactionId): Faction | undefined;
+  getBySourceId(sourceId: string): Faction | undefined;
+  list(): Faction[];
+  findByName(name: string): Faction[];
+  update(id: FactionId, patch: FactionPatch): Faction;
+}
+interface FactionStateRepository {
+  create(factionId: FactionId, state: NewFactionState): FactionState;
+  get(factionId: FactionId): FactionState | undefined;
+  update(factionId: FactionId, patch: FactionStatePatch, options?: {
+    expectedVersion?: number;
+  }): FactionState;
+}
+interface FactionMembershipRepository {
+  upsert(factionId: FactionId, characterId: CharacterId, patch: MembershipPatch & {
+    status?: MembershipStatus;
+  }, turn: number): FactionMembership;
+  get(factionId: FactionId, characterId: CharacterId): FactionMembership | undefined;
+  ofFaction(factionId: FactionId, status?: MembershipStatus): FactionMembership[];
+  ofCharacter(characterId: CharacterId, status?: MembershipStatus): FactionMembership[];
+  remove(factionId: FactionId, characterId: CharacterId): boolean;
+}
+interface FactionRelationshipRepository {
+  upsert(fromKind: SocialSubjectKind, fromId: number, toKind: SocialSubjectKind, toId: number, patch: RelationshipPatch, turn: number): FactionRelationship;
+  get(fromKind: SocialSubjectKind, fromId: number, toKind: SocialSubjectKind, toId: number): FactionRelationship | undefined;
+  from(kind: SocialSubjectKind, id: number): FactionRelationship[];
+  to(kind: SocialSubjectKind, id: number): FactionRelationship[];
+  list(): FactionRelationship[];
+  remove(fromKind: SocialSubjectKind, fromId: number, toKind: SocialSubjectKind, toId: number): boolean;
+}
+interface FactionIntentRepository {
+  add(factionId: FactionId, intent: Intent): FactionIntent;
+  get(id: IntentId): FactionIntent | undefined;
+  list(factionId: FactionId, filter?: IntentFilter): FactionIntent[];
+  update(id: IntentId, patch: IntentPatch): FactionIntent;
+  remove(id: IntentId): boolean;
+}
+interface IntentRepository {
+  /** @throws {NotFoundError} when the character does not exist. */
+  add(characterId: CharacterId, intent: Intent): CharacterIntent;
+  get(id: IntentId): CharacterIntent | undefined;
+  list(characterId: CharacterId, filter?: IntentFilter): CharacterIntent[];
+  /** @throws {NotFoundError} */
+  update(id: IntentId, patch: IntentPatch): CharacterIntent;
+  /** Whether an intent was removed. */
+  remove(id: IntentId): boolean;
+}
+interface EventRepository {
+  /**
+   * Record an event together with what each character took in of it, atomically.
+   * @throws {NotFoundError} when a character does not exist.
+   */
+  add(event: NewStoryEvent, perceptions: readonly NewPerception[]): {
+    event: StoryEvent;
+    perceptions: Perception[];
+  };
+  get(id: EventId): StoryEvent | undefined;
+  /** In story order: by turn, round, then the order recorded. */
+  list(filter?: StoryEventFilter): StoryEvent[];
+  /** @throws {NotFoundError} @throws {ConflictError} when the event is sealed. */
+  update(id: EventId, patch: StoryEventPatch): StoryEvent;
+  /** Replace what the characters took in of a draft event. @throws {NotFoundError} @throws {ConflictError} when the event is sealed. */
+  setPerceptions(id: EventId, perceptions: readonly NewPerception[]): Perception[];
+  /** Make events final: they can no longer be changed or removed. Without ids, every draft event is sealed. Returns how many were sealed. */
+  seal(ids?: readonly EventId[]): number;
+  perceptionsOf(id: EventId): Perception[];
+  getPerception(id: PerceptionId): Perception | undefined;
+  /**
+   * Add what one more character took in of an event, also a sealed one (it learns of it later). A
+   * character has one perception of an event.
+   * @throws {NotFoundError} when the event or the character does not exist.
+   * @throws {ConflictError} when the character already has a perception of the event: revise that one.
+   */
+  addPerception(id: EventId, perception: NewPerception): Perception;
+  /** Revise a perception, of a sealed event too. @throws {NotFoundError} */
+  updatePerception(id: PerceptionId, patch: PerceptionPatch): Perception;
+  /** What one character took in, with the events, in story order. */
+  perceivedBy(characterId: CharacterId, filter?: {
+    fromTurn?: number;
+    toTurn?: number;
+  }): PerceivedEvent[];
+  /** Count a perception as recalled in `turn`. */
+  touchPerceptions(ids: readonly number[], turn: number): void;
+  /** Whether a draft event was removed, with its perceptions. @throws {ConflictError} when the event is sealed. */
+  remove(id: EventId): boolean;
+}
+interface MemoryRepository {
+  /** @throws {NotFoundError} when the character does not exist. */
+  add(memory: NewCharacterMemory): CharacterMemory;
+  get(id: MemoryId): CharacterMemory | undefined;
+  list(characterId: CharacterId): CharacterMemory[];
+  /** @throws {NotFoundError} */
+  update(id: MemoryId, patch: CharacterMemoryPatch): CharacterMemory;
+  /** Count a memory as recalled in `turn`. */
+  touch(ids: readonly MemoryId[], turn: number): void;
+  remove(id: MemoryId): boolean;
+}
+interface ThreadRepository {
+  open(text: string, turn: number): StoryThread;
+  get(id: ThreadId): StoryThread | undefined;
+  list(status?: ThreadStatus): StoryThread[];
+  /** @throws {NotFoundError} */
+  resolve(id: ThreadId, turn: number): StoryThread;
+  /** Whether a thread was removed. */
+  remove(id: ThreadId): boolean;
+}
+interface SummaryRepository {
+  add(summary: NewSummary): Summary;
+  /** Oldest first. */
+  list(level?: SummaryLevel): Summary[];
+  remove(ids: readonly SummaryId[]): void;
+}
+interface PendingCommitRepository {
+  /** Replaces what is stored for the same round. */
+  enqueue(turn: number, round: number, payload: PendingCommit['payload']): void;
+  /** In story order. */
+  list(): PendingCommit[];
+  complete(rounds: readonly {
+    turn: number;
+    round: number;
+  }[]): void;
+}
+/** Whether vector search works in this session, and why not when it does not. */
+interface VectorSupport {
+  available: boolean;
+  error?: string;
+}
+interface RecallSearch {
+  /** What to look for: matched by its words. */
+  text: string;
+  /** Only what this character took in or believes. Events belong to no character, so leave it out to search them. */
+  characterId?: number;
+  kinds?: readonly RecallItemKind[];
+  limit: number;
+}
+interface VectorSearch {
+  /** The vector of what to look for, from the same model as the stored ones. */
+  vector: readonly number[];
+  characterId?: number;
+  limit: number;
+}
+/**
+ * What a session can be searched by: its texts, indexed by words and, once vectors are stored,
+ * by meaning. The repositories keep the index of their own texts up to date; vectors come from
+ * whoever has an embedding model.
+ */
+interface RecallIndexRepository {
+  readonly vectors: VectorSupport;
+  /** Matches by words, best first; each score is relative to the best hit. */
+  lexical(search: RecallSearch): RecallHit[];
+  /** Nearest by meaning, best first; each score is the cosine similarity. Empty when no vectors are stored or support is missing. */
+  vector(search: VectorSearch): RecallHit[];
+  /** What the stored vectors are made by, or `undefined` while there are none. */
+  info(): EmbeddingIndexInfo | undefined;
+  /** Texts without a vector, oldest first. */
+  pending(limit: number): PendingEmbedding[];
+  /**
+   * Store vectors for texts, by the ids `pending` gave. The first call fixes the model and the number of
+   * dimensions of the session's vectors.
+   * @throws {ConflictError} when the model or dimensions differ from the stored ones, or vector search is not available.
+   * @throws {InvalidValueError} when the vectors differ in size.
+   * @returns how many were stored.
+   */
+  store(model: string, vectors: readonly {
+    id: number;
+    vector: readonly number[];
+  }[]): number;
+  /** Forget every vector (the texts stay), to start again with another model. */
+  reset(): void;
+}
+interface LocationRepository {
+  /**
+   * @throws {NotFoundError} when the parent does not exist.
+   * @throws {ConflictError} when the id in the world's files or a feature key is used twice.
+   * @throws {InvalidValueError} when the name or the features are not acceptable.
+   */
+  add(location: NewLocation): Location;
+  get(id: LocationId): Location | undefined;
+  getBySourceId(sourceId: string): Location | undefined;
+  list(): Location[];
+  childrenOf(id: LocationId): Location[];
+  /** @throws {NotFoundError} @throws {ConflictError} when a feature that someone is at would go. */
+  update(id: LocationId, patch: LocationPatch): Location;
+  /** @throws {NotFoundError} when a place does not exist. @throws {ConflictError} when there already is an exit between them in that direction. */
+  addExit(exit: NewExit): Exit;
+  getExit(fromId: LocationId, toId: LocationId): Exit | undefined;
+  exitsFrom(id: LocationId): Exit[];
+  allExits(): Exit[];
+  /** @throws {NotFoundError} */
+  updateExit(id: ExitId, patch: ExitPatch): Exit;
+  removeExit(id: ExitId): boolean;
+}
+/** Where things stand. Characters now; the same table places items and containers later. */
+interface PlacementRepository {
+  /**
+   * Put something in a place, replacing where it was.
+   * @throws {NotFoundError} when the place or the thing does not exist.
+   * @throws {InvalidValueError} when the place has no such feature.
+   */
+  place(kind: PlaceableKind, entityId: number, placement: NewPlacement): Placement;
+  get(kind: PlaceableKind, entityId: number): Placement | undefined;
+  /** Everything in a place, in a stable order. */
+  at(locationId: LocationId, kind?: PlaceableKind): Placement[];
+  list(kind?: PlaceableKind): Placement[];
+}
+/** How each character stands towards each other character: one profile per direction. */
+interface RelationshipRepository {
+  /**
+   * Create the profile, or change what is given of an existing one.
+   * @throws {NotFoundError} when a character does not exist.
+   * @throws {InvalidValueError} for a new profile without a label, towards itself, or with a value out of range.
+   */
+  upsert(fromId: CharacterId, toId: CharacterId, patch: RelationshipPatch, turn: number): Relationship;
+  get(fromId: CharacterId, toId: CharacterId): Relationship | undefined;
+  /** How a character sees others. */
+  from(characterId: CharacterId): Relationship[];
+  /** How others see a character. */
+  to(characterId: CharacterId): Relationship[];
+  list(): Relationship[];
+  remove(fromId: CharacterId, toId: CharacterId): boolean;
+}
+/** Places, things and ways a character knows exist. Character awareness is represented by relationships. */
+interface KnowledgeRepository {
+  /** Learn or observe an entity. Repeated learning preserves the first turn. @throws {NotFoundError} when either side does not exist. */
+  learn(characterId: CharacterId, subjectKind: KnowledgeKind, subjectId: number, turn: number, observed?: boolean): EntityKnowledge;
+  knows(characterId: CharacterId, subjectKind: KnowledgeKind, subjectId: number): boolean;
+  get(characterId: CharacterId, subjectKind: KnowledgeKind, subjectId: number): EntityKnowledge | undefined;
+  list(characterId: CharacterId, subjectKind?: KnowledgeKind): EntityKnowledge[];
+  forget(characterId: CharacterId, subjectKind: KnowledgeKind, subjectId: number): boolean;
+}
+interface LoreRepository {
+  add(entry: NewLore): Lore;
+  get(id: LoreId): Lore | undefined;
+  getBySourceId(sourceId: string): Lore | undefined;
+  list(): Lore[];
+  update(id: LoreId, patch: LorePatch): Lore;
+  remove(id: LoreId): boolean;
+}
+/** What was made up in play and still has to be fitted into the rest of the world. */
+interface ConsolidationRepository {
+  enqueue(item: {
+    kind: ConsolidationKind;
+    subjectId: number;
+    note: string;
+    turn: number;
+  }): ConsolidationItem;
+  get(id: ConsolidationItemId): ConsolidationItem | undefined;
+  /** Not yet resolved, oldest first. */
+  pending(): ConsolidationItem[];
+  /** Everything made up in a turn, resolved or not. */
+  createdIn(turn: number): ConsolidationItem[];
+  /** Mark it fitted in, with what was done. Resolving a resolved item changes nothing. @throws {NotFoundError} */
+  resolve(id: ConsolidationItemId, turn: number, resolution: string): ConsolidationItem;
+}
+/** The places on the body something can be worn, and how many things fit in each. */
+interface SlotRepository {
+  /** Add the slots a world starts with, leaving any that exist. */
+  ensureDefaults(): void;
+  list(): Slot[];
+  get(id: string): Slot | undefined;
+  /** Make or change a slot. @throws {ConflictError} when it would hold fewer than are worn in it. */
+  upsert(slot: Slot): Slot;
+}
+/** Things that can be moved, held, worn, opened or used, and where each is. */
+interface ItemRepository {
+  /**
+   * Make an item and put it where it starts, together.
+   * @throws {InvalidValueError} for a bad name, quantity, state, or a holder that cannot hold it.
+   * @throws {ConflictError} when its id in the world's files is used, or the slot is full.
+   */
+  add(item: NewItem, holder: Holder): Item;
+  get(id: ItemId): Item | undefined;
+  getBySourceId(sourceId: string): Item | undefined;
+  list(): Item[];
+  /** @throws {NotFoundError} */
+  update(id: ItemId, patch: ItemPatch): Item;
+  /** Whether an item was removed (used up, destroyed). @throws {ConflictError} when it still holds things. */
+  remove(id: ItemId): boolean;
+  holding(id: ItemId): Holding | undefined;
+  /**
+   * Put an item somewhere else, replacing where it was.
+   * @throws {InvalidValueError} when the holder cannot hold it: a place without that feature, something worn that cannot be worn there, a thing that is not a container, an item inside itself.
+   * @throws {ConflictError} when the slot is full.
+   */
+  place(id: ItemId, holder: Holder): Holding;
+  /** What a place, a character or an item holds directly. */
+  contents(holder: {
+    kind: 'location' | 'character' | 'item';
+    id: number;
+  }): {
+    item: Item;
+    holding: Holding;
+  }[];
+  /** The containers an item is inside, innermost first. */
+  ancestors(id: ItemId): ItemId[];
+  /** The place an item is in, following what holds it, and the character that has it when one does. */
+  where(id: ItemId): {
+    locationId?: number;
+    characterId?: number;
+  };
+  /** The items that open an item that is a container, or an exit. */
+  openers(target: {
+    kind: 'item' | 'exit';
+    id: number;
+  }): ItemId[];
+  setOpeners(target: {
+    kind: 'item' | 'exit';
+    id: number;
+  }, items: readonly ItemId[]): void;
+}
+/** Stable visual facts of entities; generated image files and their metadata remain on the filesystem. */
+interface VisualIdentityRepository {
+  /** Create or replace an identity. Replacing it advances its version. @throws {NotFoundError} when the subject does not exist. */
+  set(subjectKind: VisualSubjectKind, subjectId: number, identity: VisualIdentityInput): VisualIdentity;
+  get(subjectKind: VisualSubjectKind, subjectId: number): VisualIdentity | undefined;
+  /** Everything with an identity, in stable subject order. */
+  list(subjectKind?: VisualSubjectKind): VisualIdentity[];
+  /** Change only the supplied canonical fields and advance the version. @throws {NotFoundError} */
+  update(subjectKind: VisualSubjectKind, subjectId: number, patch: VisualIdentityPatch): VisualIdentity;
+  remove(subjectKind: VisualSubjectKind, subjectId: number): boolean;
+}
+/** The story's own time: what instant it is in the story, and how it got there. */
+interface ClockRepository {
+  /** The clock, or nothing before it was started. */
+  get(): ClockState | undefined;
+  /** Start the clock. @throws {ConflictError} when it is started. */
+  start(mode: ClockMode, now: number): ClockState;
+  /**
+   * Move the story's time forward, and keep why.
+   * @throws {NotFoundError} when the clock is not started.
+   * @throws {InvalidValueError} when the instant is not after the current one.
+   */
+  advance(step: {
+    to: number;
+    turn: number;
+    round: number;
+    kind: Exclude<TimeChangeKind, 'start' | 'resync'>;
+    reason?: string;
+  }): TimeChange;
+  /** Set the clock to an instant in either direction and to a mode, as when it is changed from following the wall clock to being the story's own. @throws {NotFoundError} */
+  resync(mode: ClockMode, now: number, turn: number, reason?: string): TimeChange;
+  log(filter?: TimeChangeFilter): TimeChange[];
+  /** The instant a round began, when it is known: where an event of that round is placed in time. */
+  at(turn: number, round: number): number | undefined;
+}
+/** The recurring days of the characters: windows of the day with what they are doing and where. */
+interface RoutineRepository {
+  /** The windows of a character, in the order they were given: the first that fits the moment is the one that applies. */
+  list(characterId: CharacterId): StoredRoutineWindow[];
+  /** Every window of every character. */
+  all(): StoredRoutineWindow[];
+  /**
+   * Replace a character's windows.
+   * @throws {InvalidValueError} for a window that is empty, has a minute that is not one, a day that is not one, or a place or character that does not exist.
+   */
+  replace(characterId: CharacterId, windows: readonly RoutineWindow[]): StoredRoutineWindow[];
+}
+/** Dated commitments: what characters are due to do, and whether they did. */
+interface EngagementRepository {
+  /** @throws {InvalidValueError} for an empty title, an end before the start, no participants, or a place or character that does not exist. */
+  add(engagement: NewEngagement): Engagement;
+  get(id: EngagementId): Engagement | undefined;
+  /** In order of when they are due. */
+  list(filter?: EngagementFilter): Engagement[];
+  /** @throws {NotFoundError} */
+  update(id: EngagementId, patch: EngagementPatch): Engagement;
+  remove(id: EngagementId): boolean;
+}
+/** What the story keeps track of: the kinds of variable there are, and the value each subject has. */
+interface VariableRepository {
+  /** Add the variables every story has (the feelings of characters), leaving any that exist. */
+  ensureDefaults(): void;
+  /** In the order they were declared. */
+  defs(): VariableDefinition[];
+  def(key: string): VariableDefinition | undefined;
+  /**
+   * Declare a variable, or change one (what is not given takes its default; a built-in one keeps what it is).
+   * @throws {InvalidValueError} for a key, kind, bounds, options, default or words that are not acceptable, or when the story has too many.
+   */
+  define(input: VariableDefinitionInput): VariableDefinition;
+  /** Remove a variable and every value of it. @throws {ConflictError} for a built-in one. */
+  remove(key: string): boolean;
+  /** What one subject has stored for a variable, if anything. */
+  get(variable: string, subject: VariableSubject, subjectId: number): StoredVariable | undefined;
+  /** What it is for the subject: its own value, or the default. */
+  value(variable: string, subject: VariableSubject, subjectId: number): VariableValue;
+  /**
+   * Set a subject's value (and, for a variable with a baseline, its baseline). The first value of a variable with a baseline sets the baseline too, unless one is given.
+   * @throws {NotFoundError} for a variable that is not declared.
+   * @throws {InvalidValueError} for a subject it does not apply to, or a value it cannot have.
+   */
+  set(variable: string, subject: VariableSubject, subjectId: number, change: {
+    value?: VariableValue;
+    baseline?: VariableValue;
+  }, turn: number): StoredVariable;
+  /** Everything stored for one subject. */
+  list(subject: VariableSubject, subjectId: number): StoredVariable[];
+  /** Everything stored for anything, most recently changed first. */
+  all(): StoredVariable[];
+  /** Whether a variable applies to a subject. */
+  applies(def: VariableDefinition, subject: VariableSubject, subjectId: number): boolean;
+}
+/** What a world, or a story, makes happen when its conditions come true, and what that leaves to be told. */
+interface TriggerRepository {
+  /** @throws {ConflictError} for a key that exists. @throws {InvalidValueError} for a definition that is not acceptable, or when the story has too many. */
+  add(definition: TriggerDefinition, origin: Trigger['origin'], turn: number): Trigger;
+  get(id: TriggerId): Trigger | undefined;
+  getByKey(key: string): Trigger | undefined;
+  /** By priority, highest first, then in the order made. */
+  list(filter?: {
+    status?: TriggerStatus;
+  }): Trigger[];
+  /** @throws {NotFoundError} */
+  update(id: TriggerId, patch: {
+    status?: TriggerStatus;
+    fireCount?: number;
+    lastFiredMs?: number;
+    lastResult?: boolean;
+    problem?: string;
+  }): Trigger;
+  addNote(note: NewTriggerNote): TriggerNote;
+  /** Oldest first. */
+  notes(filter?: {
+    status?: TriggerNote['status'];
+    kind?: TriggerNoteKind;
+  }): TriggerNote[];
+  /** @throws {NotFoundError} */
+  resolveNote(id: number, status: 'done' | 'lapsed'): void;
+}
+//#endregion
+//#region src/records/items.d.ts
+/** The name by which models and tools refer to an item: its id in the world, or its number when it was made up in play. */
+declare const itemKey: (item: Pick<Item, "id" | "sourceId">) => string;
+declare const ITEM_ACTIONS: readonly ["take", "drop", "give", "put", "wear", "remove", "open", "close", "lock", "unlock", "reveal"];
+type ItemAction = (typeof ITEM_ACTIONS)[number];
+/** What a character does with an item, by keys. */
+interface ItemChangeSpec {
+  item: string;
+  action: ItemAction;
+  /** For give: the character it goes to. For put: the container it goes into. */
+  to?: string;
+  /** For wear: the slot, when it has to be named. */
+  slot?: string;
+  /** How many, of something that comes in numbers; all of it when left out. */
+  quantity?: number;
+  /** For drop and put: where in the place or container. */
+  position?: string;
+  /** For drop: the feature of the place it is left at. */
+  feature?: string;
+  /** For lock and unlock: the item used. */
+  with?: string;
+  /** For lock and unlock of a way instead of an item: the key of the place the way leads to. */
+  exit?: string;
+  /** For open, lock and unlock: the story breaks it open or shut instead (picked, smashed). */
+  forced?: boolean;
+}
+interface ItemContext {
+  items: ItemRepository;
+  locations: Pick<LocationRepository, 'get' | 'getExit' | 'list' | 'updateExit'>;
+  placements: Pick<PlacementRepository, 'get'>;
+  characters: Pick<CharacterRepository, 'get' | 'list'>;
+}
+/** What changes if the action is done. */
+type ItemPlan = {
+  action: 'move';
+  spec: ItemChangeSpec;
+  item: Item;
+  quantity: number;
+  holder: Holder;
+  summary: string;
+} | {
+  action: 'container';
+  spec: ItemChangeSpec;
+  item: Item;
+  state: 'open' | 'closed' | 'locked';
+  summary: string;
+} | {
+  action: 'exit';
+  spec: ItemChangeSpec;
+  from: LocationId;
+  to: LocationId;
+  state: ExitState;
+  summary: string;
+} | {
+  action: 'reveal';
+  spec: ItemChangeSpec;
+  item: Item;
+  summary: string;
+};
+/** What was done, for the record of the round. */
+interface ItemEffect {
+  item: {
+    key: string;
+    name: string;
+  };
+  action: ItemAction;
+  /** In words: "now carried by Bob", "now in the chest". */
+  summary: string;
+}
+/**
+ * Whether a character can do what the spec says with an item right now, and what it would come to. The
+ * rules are the ones the story would expect, decided in code: it can only act on what it can get at (carried,
+ * or here and in plain sight, in open containers only), it cannot take what someone else holds, a lock needs
+ * the key it fits, a slot holds only so many.
+ * @returns the plan, or every reason it cannot be done.
+ */
+declare function planItemChange(ctx: ItemContext, actorId: CharacterId, spec: ItemChangeSpec): {
+  ok: true;
+  plan: ItemPlan;
+} | {
+  ok: false;
+  problems: string[];
+};
+/** Do what a plan says. Part of a pile is split off, and joins a pile of the same kind where it lands. */
+declare function applyItemPlan(ctx: ItemContext, plan: ItemPlan): ItemEffect;
+/**
+ * Do what a character does with an item.
+ * @throws {InvalidMoveError} naming every reason when it cannot, changing nothing.
+ */
+declare function changeItem(ctx: ItemContext, actorId: CharacterId, spec: ItemChangeSpec): ItemEffect;
+//#endregion
+//#region src/records/variables.d.ts
+interface VariableContext {
+  variables: VariableRepository;
+  characters: Pick<CharacterRepository, 'list'>;
+  items: Pick<ItemRepository, 'list'>;
+  locations: Pick<LocationRepository, 'list'>;
+}
+/** A change to what the story tracks, as the game master and the keeper write it. Exactly one of `to`, `by` and `baseline`. */
+interface VariableChangeSpec {
+  variable: string;
+  /** The key of the character, item or place; `world` for a variable of the whole story. */
+  subject: string;
+  /** The value it becomes. */
+  to?: VariableValue;
+  /** How much a number goes up (or down, when negative); it stops at its bounds. */
+  by?: number;
+  /** For a variable with a baseline: the new baseline (temperament). */
+  baseline?: VariableValue;
+}
+interface VariableEffect {
+  variable: VariableDefinition;
+  subjectName: string;
+  from: VariableValue;
+  to: VariableValue;
+}
+type VariablePlan = {
+  ok: true;
+  effect: VariableEffect;
+  subjectId: number;
+  change: {
+    value?: VariableValue;
+    baseline?: VariableValue;
+  };
+} | {
+  ok: false;
+  problems: string[];
+};
+/** The subject a key names, for a kind of subject. */
+declare function subjectOf(context: VariableContext, kind: VariableSubject, key: string): {
+  id: number;
+  name: string;
+} | undefined;
+/** A value in words: a number by its band when the variable has bands (and the number), yes or no, or the word. */
+declare function describeValue(def: Pick<VariableDefinition, 'kind' | 'bands'>, value: VariableValue): string;
+/** Whether a change can be made, and what it would come to. Nothing is changed. */
+declare function planVariableChange(context: VariableContext, spec: VariableChangeSpec): VariablePlan;
+/**
+ * Change a variable now.
+ * @throws {InvalidEditError} naming every reason it cannot be done.
+ */
+declare function changeVariable(context: VariableContext, spec: VariableChangeSpec, turn: number): VariableEffect;
+/** Who is reading values: the game master and the keeper see everything, a character sees what is public and what is private to it, anyone else only what is public. */
+type VariableAudience = 'story' | 'self' | 'others';
+interface ShownVariable {
+  variable: VariableDefinition;
+  value: VariableValue;
+  baseline?: VariableValue;
+}
+/** At most this many variables are told for one subject. */
+declare const MAX_SHOWN = 8;
+/** The variables of a subject that are worth telling, in the order they were declared: those whose value is not the default, and those always told. */
+declare function shownVariables(context: VariableContext, kind: VariableSubject, subjectId: number, subjectKey: string, audience: VariableAudience): ShownVariable[];
+//#endregion
+//#region src/records/edit-types.d.ts
+/** The name by which models and other plugins refer to a place: its id in the world, or its number when it was made up in play. */
+declare const locationKey: (location: Pick<Location, "id" | "sourceId">) => string;
+/** The name by which models and other plugins refer to a character: its id in the world, or its number when it has none. */
+declare const characterKey: (character: Pick<Character, "id" | "sourceId">) => string;
+/** What an edit of the story's records can touch. */
+interface RecordsTarget {
+  characters: CharacterRepository;
+  characterStates: CharacterStateRepository;
+  events: EventRepository;
+  memories: MemoryRepository;
+  threads: ThreadRepository;
+  locations: LocationRepository;
+  placements: PlacementRepository;
+  relationships: RelationshipRepository;
+  factions: FactionRepository;
+  factionStates: FactionStateRepository;
+  factionMemberships: FactionMembershipRepository;
+  factionRelationships: FactionRelationshipRepository;
+  factionIntents: FactionIntentRepository;
+  knowledge: KnowledgeRepository;
+  consolidation: ConsolidationRepository;
+  items: ItemRepository;
+  slots: SlotRepository;
+  intents: IntentRepository;
+  variables: VariableRepository;
+  routines: RoutineRepository;
+  engagements: EngagementRepository;
+  triggers: TriggerRepository;
+  transaction<T>(fn: () => T): T;
+}
+interface PerceivedBy {
+  character: string;
+  mode: PerceptionMode;
+  /** What the character took in, when it is not exactly the event. */
+  content?: string;
+  gist?: string;
+  accuracy?: Accuracy;
+}
+interface StatePatch extends Pick<CharacterStatePatch, 'publicState' | 'innerState' | 'activity'> {
+  character: string;
+}
+interface NewEvent {
+  /** The key of the place it happened in. */
+  location?: string;
+  /** The keys of the items it is about. */
+  items?: string[];
+  turn: number;
+  round: number;
+  text: string;
+  importance: number;
+  tags?: string[];
+  involves?: string[];
+  perceivedBy?: PerceivedBy[];
+}
+interface EventEdit {
+  id: number;
+  location?: string;
+  text?: string;
+  importance?: number;
+  tags?: string[];
+  involves?: string[];
+  /** Replaces who took the event in. */
+  perceivedBy?: PerceivedBy[];
+}
+/** A character's version of an event, revised: it learned more, or remembers it differently. Works on sealed events too. */
+interface PerceptionEdit {
+  id: number;
+  mode?: PerceptionMode;
+  content?: string;
+  gist?: string;
+  accuracy?: Accuracy;
+}
+/** One more character took in an event, possibly long after: it was told, or worked it out. Works on sealed events too. */
+interface PerceptionAddition extends PerceivedBy {
+  event: number;
+}
+interface NewExit$1 {
+  /** The key of the place it leads to. */
+  to: string;
+  description?: string;
+  /** Also make the way back, with `backDescription`; on by default. */
+  oneWay?: boolean;
+  backDescription?: string;
+  travelSeconds?: number;
+  state?: ExitState;
+  note?: string;
+}
+/** A place made up in play (or arriving with a plugin): a hidden passage, a room the story opens. */
+interface NewPlace {
+  key: string;
+  name: string;
+  description?: string;
+  /** The key of the place it is in. */
+  parent?: string;
+  features?: {
+    key: string;
+    name: string;
+    description?: string;
+  }[];
+  exits?: NewExit$1[];
+  /** Why it was made, for whoever fits it into the world later. */
+  note?: string;
+}
+/** A character the story makes up: someone who arrives, is introduced, or turns out to be needed. Always played by an agent. */
+interface NewCharacterSpec {
+  key: string;
+  name: string;
+  aliases?: string[];
+  age?: string;
+  gender?: string;
+  pronouns?: string;
+  kind?: CharacterKind;
+  tier?: CharacterTier;
+  summary: string;
+  personality?: string;
+  background?: string;
+  appearance?: string;
+  speech?: {
+    style: string;
+    examples?: string[];
+  };
+  state?: {
+    publicState?: string;
+    innerState?: string;
+    activity?: string;
+  };
+  place?: {
+    location: string;
+    position?: string;
+    feature?: string;
+  };
+  /** Why it was made, for whoever fits it into the world later. */
+  note?: string;
+}
+/** A character's profile of another, made or changed; what is not given stays as it was. */
+interface RelationshipSet {
+  from: string;
+  to: string;
+  label?: string;
+  summary?: string;
+  familiarity?: number;
+  trust?: number;
+  affinity?: number;
+  tension?: number;
+}
+interface RelationshipRetraction {
+  from: string;
+  to: string;
+}
+/** A place, item or directed exit a character learns exists. */
+interface KnowledgeSet {
+  character: string;
+  kind: KnowledgeKind;
+  /** The location or item key. */
+  subject?: string;
+  /** For an exit, its directed endpoints. */
+  from?: string;
+  to?: string;
+  observed?: boolean;
+}
+interface FactionStateSet {
+  faction: string;
+  publicState?: string;
+  innerState?: string;
+}
+interface FactionMembershipSet {
+  faction: string;
+  character: string;
+  role?: string;
+  rank?: string;
+  status?: 'active' | 'inactive' | 'former';
+  public?: boolean;
+  commitment?: number;
+  leftTurn?: number;
+}
+interface FactionRelationshipSet extends Omit<RelationshipSet, 'from' | 'to'> {
+  fromKind: 'character' | 'faction';
+  from: string;
+  toKind: 'character' | 'faction';
+  to: string;
+}
+interface NewFactionIntentSpec extends Omit<NewIntentSpec, 'character'> {
+  faction: string;
+}
+type KnowledgeRetraction = Omit<KnowledgeSet, 'observed'>;
+/** A new way between two places that already exist (or are made in the same edit). */
+interface NewExitBetween {
+  from: string;
+  to: string;
+  description?: string;
+  /** Also make the way back, with `backDescription`; on by default. */
+  oneWay?: boolean;
+  backDescription?: string;
+  travelSeconds?: number;
+  state?: ExitState;
+  note?: string;
+}
+/** A thing the story makes up (or that arrives with a plugin): an object that matters, handed over or found. It starts in exactly one of `at`, `heldBy`, `wornBy` or `inside`. */
+interface NewItemSpec {
+  key: string;
+  name: string;
+  description?: string;
+  quantity?: number;
+  unique?: boolean;
+  quality?: string;
+  notable?: boolean;
+  hidden?: boolean;
+  /** The slot it is worn in. */
+  wearable?: string;
+  container?: {
+    state?: ContainerState;
+    openedBy?: string[];
+  };
+  owner?: string;
+  at?: {
+    location: string;
+    position?: string;
+    feature?: string;
+  };
+  heldBy?: string;
+  wornBy?: string;
+  wornPosition?: string;
+  inside?: string;
+  insidePosition?: string;
+  /** Why it was made, for whoever fits it into the world later. */
+  note?: string;
+}
+/** What a character does with an item; the engine decides it, this is for plugins and tools. */
+interface ItemChange extends ItemChangeSpec {
+  character: string;
+}
+interface ItemEditSpec {
+  item: string;
+  description?: string;
+  quality?: string;
+  quantity?: number;
+  notable?: boolean;
+  hidden?: boolean;
+  /** The state of a container, when it is changed by the story rather than by a character's action. */
+  state?: ContainerState;
+  owner?: string;
+  /** Replaces the items that open it (a container or the way named by `exit`). */
+  openedBy?: string[];
+}
+interface PlaceEdit {
+  place: string;
+  name?: string;
+  description?: string;
+  /** Replaces the list of features. */
+  features?: {
+    key: string;
+    name: string;
+    description?: string;
+  }[];
+}
+/** A door is unlocked, a passage collapses: the way between two places changes, both ways unless told otherwise. */
+interface ExitChange {
+  from: string;
+  to: string;
+  state?: ExitState;
+  description?: string;
+  note?: string;
+  travelSeconds?: number;
+  oneWay?: boolean;
+}
+interface CharacterMove {
+  character: string;
+  to: string;
+  position?: string;
+  feature?: string;
+  ignoreExits?: boolean;
+}
+interface NewBelief {
+  character: string;
+  kind: MemoryKind;
+  text: string;
+  about?: string[];
+  importance: number;
+}
+interface BeliefEdit {
+  id: number;
+  text?: string;
+  about?: string[];
+  importance?: number;
+}
+/**
+ * A change to the story's records, applied together or not at all: the unit in which the
+ * record keeper, the model-facing tools and other plugins write what happened.
+ */
+/** A new goal of a character, which the story gave it: a promise made, a task taken on. */
+interface NewIntentSpec {
+  character: string;
+  type: IntentType;
+  name: string;
+  description?: string;
+  horizon: IntentHorizon;
+  priority: number;
+  urgency: number;
+  plan?: string[];
+  constraints?: string[];
+  /** A date and time, in the time zone of the story unless it carries an offset. */
+  deadline?: string;
+}
+interface IntentEditSpec {
+  id: number;
+  status?: IntentStatus;
+  description?: string;
+  horizon?: IntentHorizon;
+  priority?: number;
+  urgency?: number;
+  plan?: string[];
+  openThreads?: string[];
+  deadline?: string;
+}
+/** Something characters have committed to, at a time. */
+interface NewEngagementSpec {
+  title: string;
+  /** When it is due: a date and time, in the time zone of the story unless it carries an offset. */
+  at: string;
+  until?: string;
+  /** The key of the place. */
+  location?: string;
+  participants: string[];
+  note?: string;
+}
+interface EngagementEditSpec {
+  id: number;
+  status?: EngagementStatus;
+  title?: string;
+  at?: string;
+  until?: string;
+  location?: string;
+  participants?: string[];
+  note?: string;
+}
+interface RoutineWindowSpec {
+  /** `mon` to `sun`; every day when left out. */
+  days?: string[];
+  /** `HH:MM`. */
+  from: string;
+  to: string;
+  activity: string;
+  location?: string;
+  feature?: string;
+  position?: string;
+  interruptible?: boolean;
+}
+/** Sets the recurring day of a character, replacing what it had. */
+interface RoutineSet {
+  character: string;
+  windows: RoutineWindowSpec[];
+}
+interface RecordsEdit {
+  /** The turn new beliefs and threads belong to. */
+  turn: number;
+  /** The time zone the dates of the edit are written in; UTC when not given. */
+  timeZone?: string;
+  /** Changes to what the story tracks: a feeling, a debt, a flag. */
+  variableChanges?: VariableChangeSpec[];
+  /** Variables the story declares, only by the agent whose work that is. */
+  variables?: VariableDefinitionInput[];
+  intentsAdded?: NewIntentSpec[];
+  intentEdits?: IntentEditSpec[];
+  engagements?: NewEngagementSpec[];
+  engagementEdits?: EngagementEditSpec[];
+  routines?: RoutineSet[];
+  /** Things the world does when their conditions come true, only by the agent whose work that is. */
+  triggers?: TriggerDefinition[];
+  states?: StatePatch[];
+  events?: NewEvent[];
+  eventEdits?: EventEdit[];
+  eventRetractions?: number[];
+  perceptionEdits?: PerceptionEdit[];
+  perceptionsAdded?: PerceptionAddition[];
+  characters?: NewCharacterSpec[];
+  items?: NewItemSpec[];
+  slots?: Slot[];
+  itemChanges?: ItemChange[];
+  itemEdits?: ItemEditSpec[];
+  places?: NewPlace[];
+  exits?: NewExitBetween[];
+  relationships?: RelationshipSet[];
+  relationshipRetractions?: RelationshipRetraction[];
+  knowledge?: KnowledgeSet[];
+  knowledgeRetractions?: KnowledgeRetraction[];
+  factionStates?: FactionStateSet[];
+  factionMemberships?: FactionMembershipSet[];
+  factionRelationships?: FactionRelationshipSet[];
+  factionIntentsAdded?: NewFactionIntentSpec[];
+  placeEdits?: PlaceEdit[];
+  exitChanges?: ExitChange[];
+  moves?: CharacterMove[];
+  beliefs?: NewBelief[];
+  beliefEdits?: BeliefEdit[];
+  beliefRetractions?: number[];
+  threadsOpened?: string[];
+  threadsResolved?: number[];
+}
+interface EditResult {
+  /** The ids of the events and beliefs the edit added, in order. */
+  eventIds: number[];
+  /** The keys of the characters and places the edit made up. */
+  characterKeys?: string[];
+  placeKeys?: string[];
+  triggerKeys?: string[];
+  itemKeys?: string[];
+  /** The keys of the variables the edit declared. */
+  variableKeys?: string[];
+  beliefIds: number[];
+  /** How many rows were added, changed or removed. */
+  writes: number;
+}
+//#endregion
+//#region src/records/trigger-rules.d.ts
+type Wire = Record<string, unknown>;
+/** Checks that an edit effect is shaped as an edit; it throws {@link InvalidEditError} when not. */
+type EditChecker = (edit: Wire) => void;
+/**
+ * Read a trigger from the JSON a world's files and the world author write (snake_case).
+ * @returns the definition, or every problem with where it is.
+ */
+declare function parseTriggerDefinition(value: unknown, path: string, checkEdit: EditChecker): {
+  definition: TriggerDefinition;
+} | {
+  problems: string[];
+};
+type Reading = Pick<RecordsTarget, 'characters' | 'locations' | 'items' | 'variables' | 'triggers'>;
+/**
+ * What in a trigger names something the story does not have: a character, place, item or variable in a condition, the characters of a cue,
+ * a trigger it waits for. (What an edit effect touches is checked when it is applied.)
+ */
+declare function triggerReferenceProblems(target: Reading, definition: TriggerDefinition, otherKeys?: Iterable<string>): string[];
+interface TriggerClock {
+  now: number;
+  zone: string;
+}
+declare function holds(target: RecordsTarget, condition: TriggerCondition, clock: TriggerClock): boolean;
+/** Whether a condition holds now, judged only from what the story has recorded. */
+declare const conditionHolds: typeof holds;
+/** A number from 0 to 1 that depends only on what it is given: a roll that comes out the same when the story is replayed. */
+declare function seededRoll(seed: string): number;
+/** A character is among those an audience names, now. */
+declare function inAudience(target: Pick<RecordsTarget, 'characters' | 'locations' | 'placements'>, audience: TriggerAudience, characterId: number): boolean;
+/** The characters an audience is now, those who can be asked to act (the player's own character is told by the game master). */
+declare function audienceIds(target: Pick<RecordsTarget, 'characters' | 'locations' | 'placements'>, audience: TriggerAudience): number[];
+interface Announcement {
+  trigger: Trigger;
+  text: string;
+  audience: TriggerAudience;
+  /** When it is to happen, as an instant, when that is known. */
+  at?: number;
+}
+/** What is known of what is coming: triggers that have not fired and announce themselves, from the time they say, soonest first. */
+declare function announcements(target: Pick<RecordsTarget, 'triggers'>, clock: TriggerClock): Announcement[];
+//#endregion
+//#region src/records/triggers.d.ts
+interface FiredTrigger {
+  trigger: Trigger;
+  /** What the game master is to weave in. */
+  beats: string[];
+  /** What characters are to notice. */
+  cues: {
+    characters: string[];
+    text: string;
+  }[];
+  /** The texts of the events an edit effect wrote. */
+  events: string[];
+}
+interface TriggerRun {
+  fired: FiredTrigger[];
+  /** The triggers whose effects could not be applied: they are not tried again. */
+  failed: {
+    trigger: Trigger;
+    problem: string;
+  }[];
+}
+interface TriggerRunOptions extends TriggerClock {
+  turn: number;
+  round: number;
+  /** The most that fire in one run; the rest wait for the next. */
+  maxFires?: number;
+}
+/**
+ * Look at every trigger that can still fire and fire those whose condition has just become true (not those that stay true), by priority.
+ * A trigger that fires once stays fired; one that repeats fires again after its condition went false and true, and its cooldown passed. The
+ * effects of one trigger are applied together or not at all; one that cannot be applied is marked failed and not tried again.
+ */
+declare function runTriggers(target: RecordsTarget, options: TriggerRunOptions): TriggerRun;
+/** Notes nobody took up in this many turns are let go: a beat the game master never wove in, a cue nobody acted on. */
+declare function lapseNotes(target: RecordsTarget, turn: number, kept: {
+  beats: number;
+  cues: number;
+}): TriggerNote[];
+//#endregion
+//#region src/records/movement.d.ts
+interface MoveContext {
+  locations: Pick<LocationRepository, 'get' | 'allExits'>;
+  placements: Pick<PlacementRepository, 'get' | 'place'>;
+}
+interface KnownMoveContext extends MoveContext {
+  knowledge: Pick<KnowledgeRepository, 'knows'>;
+}
+/**
+ * Whether a character can go where a move says, and the way it would take. Moving to where it
+ * already is only changes its position. Otherwise there must be a way over open exits, unless the
+ * move ignores them.
+ * @returns the plan, or the reasons it cannot be done.
+ */
+declare function planMove(context: MoveContext, characterId: number, move: Move): {
+  ok: true;
+  plan: MovePlan;
+} | {
+  ok: false;
+  problems: string[];
+};
+/** Plan only through places and directed ways this character knows; forced movement remains the authoritative planner's job. */
+declare function planKnownMove(context: KnownMoveContext, characterId: number, move: Move): ReturnType<typeof planMove>;
+/**
+ * Move a character: where it stands changes to the destination, at the position or feature given.
+ * @throws {InvalidMoveError} naming every reason when it cannot.
+ */
+declare function moveCharacter(context: MoveContext, characterId: number, move: Move): MovePlan;
+//#endregion
+//#region src/memory/recall.d.ts
+/** How a character remembers. */
+interface MemoryPolicy {
+  /** Whether memories fade with age and unimportance. Off for exact recall. */
+  flaky: boolean;
+  /** The most things a character is reminded of at once. */
+  recall: number;
+  /**
+   * How many times `recall` candidates are retrieved before the best are chosen: the wider net is what a
+   * reranker judges, and it also gives importance and recency something to choose between. At least 1.
+   */
+  overRetrieve?: number;
+}
+declare const DEFAULT_MEMORY_POLICY: MemoryPolicy;
+/** How much of a memory is left: what the character is told of it. */
+type Clarity = 'clear' | 'faded' | 'vague';
+/** One thing a character is reminded of, as it comes back to it. */
+interface Recalled {
+  clarity: Clarity;
+  /** What the character remembers; less of it the fainter the memory. */
+  text: string;
+  /** The turn it comes from. */
+  turn: number;
+  /** When it happened in story time, when the story clock records it. */
+  at?: number;
+  source: {
+    kind: 'perception' | 'memory';
+    id: number;
+  };
+}
+interface RecallQuery {
+  characterId: CharacterId;
+  /** Everyone in the story, so that names in the situation can be told. */
+  characters: readonly Character[];
+  /** What is happening now, which is what reminds the character of things. */
+  situation: string;
+  /** Where the character is. What happened in the same place comes back to it more readily. */
+  locationId?: number;
+  turn: number;
+  policy: MemoryPolicy;
+}
+/** What recall reads: the events a character took in and what it believes. */
+interface RecallSource {
+  events: Pick<EventRepository, 'perceivedBy'>;
+  memories: Pick<MemoryRepository, 'list'>;
+  clock: Pick<ClockRepository, 'get' | 'log'>;
+  /** Optional for lightweight callers; a session supplies it so socially charged people are stronger cues. */
+  relationships?: Pick<RelationshipRepository, 'from'>;
+}
+/** A number from 0 up to 1 that is always the same for the same input: no two memories fade at quite the same rate. */
+declare function jitter(seed: number): number;
+/** What is left of a memory, from 1 down to 0, given its age, how much it matters and how often it was recalled. */
+declare function retention(input: {
+  ageDays: number;
+  importance: number;
+  recalls: number;
+  seed: number;
+  durability?: number;
+  cue?: boolean;
+}): number;
+/** How clear a memory is at a retention, or nothing when it is gone. */
+declare function clarityAt(value: number, importance: number): Clarity | undefined;
+/** Words a text can be matched by: words as they are, and overlapping pairs of characters for scripts written without spaces. */
+declare function tokens(text: string): Set<string>;
+/** The characters a text mentions by name or alias. */
+declare function mentioned(text: string, characters: readonly Character[]): Set<number>;
+interface Candidate {
+  key: string;
+  recalled: Omit<Recalled, 'clarity' | 'text'> & {
+    clear: string;
+    faded: string;
+    vague: string;
+  };
+  relevance: number;
+  importance: number;
+  ageDays: number;
+  recalls: number;
+  seed: number;
+  durability: number;
+}
+declare function overlap(cues: ReadonlySet<string>, text: string, tags: readonly string[]): number;
+/** One thing a character could be reminded of, with the text to match it against the moment. */
+interface RecallCandidate {
+  /** Names the candidate in the `semantic` scores given to {@link recall}: `p:<id>` for something it took in, `m:<id>` for something it believes. */
+  key: string;
+  /** What the character remembers of it in full: what an embedding or a reranker should read. */
+  text: string;
+  turn: number;
+  importance: number;
+}
+/** From a cosine similarity to how much a match counts, from 0 to 1. */
+declare const denseScore: (similarity: number) => number;
+/** What else says how well each candidate matches the moment, by candidate key, each from 0 to 1. */
+interface RecallEvidence {
+  /** From the search of the session's index by words. */
+  lexical?: ReadonlyMap<string, number>;
+  /** From the search of the session's stored vectors by meaning, already mapped by {@link denseScore}. */
+  dense?: ReadonlyMap<string, number>;
+  /** From a reranker that judged the candidates of the pool (see {@link poolCandidates}). */
+  rerank?: ReadonlyMap<string, number>;
+}
+/** Everything the character could be reminded of, for a caller that ranks by meaning (an embedding, a reranker) before asking for the recall. */
+declare function recallCandidates(source: RecallSource, query: Pick<RecallQuery, 'characterId' | 'characters' | 'situation' | 'turn' | 'locationId'>): RecallCandidate[];
+/** Fuse scores from 0 to 1 into one, per key: the weighted average over the searches that ran (those with any score above 0). */
+declare function fuseScores(searches: readonly {
+  weight: number;
+  scores: ReadonlyMap<string, number> | undefined;
+}[]): Map<string, number>;
+interface PoolEntry {
+  candidate: Candidate;
+  /** How well retrieval alone matches the moment, from 0 to 1. */
+  fused: number;
+}
+/** What retrieval over-retrieved for one recall, waiting for a reranker's judgement and the final choice. */
+interface RecallPool {
+  entries: readonly PoolEntry[];
+  query: Pick<RecallQuery, 'policy'>;
+}
+/**
+ * The first stage of reminding a character of what the moment calls to mind: retrieve, by the cues
+ * of the moment (who is named, shared words and tags, where it happened), by the words of the index
+ * and by meaning, fuse the scores of each, and keep more than will be used (`policy.overRetrieve` times
+ * `policy.recall`, the best by fused relevance together with how much each matters and how recent it
+ * is, and not what has faded from memory altogether). A reranker may then judge that pool.
+ */
+declare function recallPool(source: RecallSource, query: RecallQuery, evidence?: Omit<RecallEvidence, 'rerank'>): RecallPool;
+/** What a reranker is asked to judge: every candidate of the pool, with the text it would be recalled by. */
+declare function poolCandidates(pool: RecallPool): RecallCandidate[];
+/**
+ * The last stage: choose the `policy.recall` best of the pool. With a reranker's judgement each
+ * candidate's relevance is mostly that (a candidate it left out counts as 0), and the rest is what
+ * retrieval found; without, it is what retrieval found.
+ */
+declare function finishRecall(pool: RecallPool, rerank?: ReadonlyMap<string, number>): Recalled[];
+/** Remind a character of what the moment calls to mind, in one call: {@link recallPool}, then {@link finishRecall} with the `rerank` evidence if there is any. */
+declare function recall(source: RecallSource, query: RecallQuery, evidence?: RecallEvidence): Recalled[];
+//#endregion
+//#region src/records/wire.d.ts
+/** Read a trigger as a world's files write it. @returns the definition, or every problem with where it is. */
+declare const readTriggerDefinition: (value: unknown, path: string) => ReturnType<typeof parseTriggerDefinition>;
+/**
+ * Read an edit from the JSON models write (snake_case), the one wire format of the
+ * keeper's output and of the write tools.
+ * @throws {InvalidEditError} when it is not shaped as an edit.
+ */
+declare function parseRecordsEdit(value: unknown): RecordsEdit;
+/**
+ * The JSON schema of the wire format, for a model's structured output or a tool's parameters.
+ * With `characters`, a character can only be named by one of those keys.
+ */
+declare function recordsEditSchema(options?: {
+  characters?: readonly string[];
+  changes?: boolean; /** Offer the making of characters, places and ways: only for the agent whose work that is. */
+  authoring?: boolean;
+}): ObjectJsonSchema;
+//#endregion
+//#region src/records/edit.d.ts
+/**
+ * Apply an edit. Every problem is found before anything is written, so a bad edit changes nothing.
+ * Characters made up by the edit are created after its places and before everything else, so that the rest
+ * of the edit (relationships, events, moves) can name them; the whole is still one transaction.
+ * @throws {InvalidEditError} naming each problem.
+ */
+declare function applyRecordsEdit(target: RecordsTarget, edit: RecordsEdit): EditResult;
+//#endregion
+//#region src/records/read.d.ts
+/** Which part of the story's records to read; all of it when left out. */
+interface RecordsScope {
+  rounds?: readonly {
+    turn: number;
+    round: number;
+  }[];
+  /** The time zone times are shown in; UTC when not given. */
+  timeZone?: string;
+  /** Only these parts of the records; the others come back empty. Everything when left out. */
+  only?: readonly (keyof RecordsView)[];
+  /** Of the relationships, only those that changed in this turn or later. */
+  relationshipsSince?: number;
+}
+/** The records as models read them (snake_case, characters by key), the counterpart of the edit's wire format. */
+interface RecordsView {
+  factions: {
+    faction: string;
+    name: string;
+    public_state: string;
+    inner_state: string;
+    values: string[];
+    structure: string;
+    goals: {
+      id: number;
+      name: string;
+      status: string;
+      horizon: string;
+      priority: number;
+      urgency: number;
+      plan: string[];
+    }[];
+    members: {
+      character: string;
+      role: string;
+      rank: string;
+      status: string;
+      public: boolean;
+      commitment: number;
+    }[];
+  }[];
+  faction_relationships: {
+    from_kind: string;
+    from: string;
+    to_kind: string;
+    to: string;
+    label: string;
+    summary: string;
+    familiarity: number;
+    trust: number;
+    affinity: number;
+    tension: number;
+    updated_turn: number;
+  }[];
+  characters: {
+    character: string;
+    name: string;
+    controlled_by: 'the player' | 'an agent';
+    public_state: string;
+    inner_state: string;
+    activity: string;
+    /** The key of the place it is in, and where in it; null while it is nowhere. */
+    location: string | null;
+    position: string;
+    /** What it is after that is still live (active or paused), with the ids an edit refers to. */
+    goals: {
+      id: number;
+      type: string;
+      name: string;
+      status: string;
+      horizon: string;
+      priority: number;
+      urgency: number;
+      deadline: string | null;
+      plan: string[];
+    }[];
+  }[];
+  events: {
+    id: number;
+    turn: number;
+    round: number;
+    text: string;
+    importance: number;
+    tags: string[];
+    involves: string[];
+    /** The key of the place it happened in. */
+    location: string | null;
+    sealed: boolean;
+    perceived_by: {
+      id: number;
+      character: string;
+      mode: string;
+      accuracy: string;
+      content: string;
+      gist: string;
+    }[];
+  }[];
+  beliefs: {
+    id: number;
+    character: string;
+    kind: string;
+    text: string;
+    about: string[];
+    importance: number;
+    turn: number;
+  }[];
+  open_threads: {
+    id: number;
+    text: string;
+    opened_turn: number;
+  }[];
+  /** How characters stand towards each other, most recently changed first (at most 80). */
+  /** Things, notable first (at most 100), each with where it is. */
+  items: {
+    key: string;
+    name: string;
+    quantity: number;
+    quality: string;
+    state: string | null;
+    hidden: boolean;
+    notable: boolean;
+    owner: string | null;
+    holder: string;
+  }[];
+  /** What is tracked: how each kind of variable is declared. */
+  variable_defs: {
+    key: string;
+    name: string;
+    description: string;
+    kind: string;
+    subject: string;
+    only: string[];
+    min: number | null;
+    max: number | null;
+    options: string[];
+    default: string | number | boolean;
+    visibility: string;
+    baseline: boolean;
+  }[];
+  /** What each subject holds that is not the default (at most 200, most recently changed first). */
+  variables: {
+    variable: string;
+    subject: string;
+    about: string;
+    value: string | number | boolean;
+    described: string;
+    baseline: string | number | boolean | null;
+    visibility: string;
+  }[];
+  /** What characters have committed to that is still pending, in the order they are due (at most 40); times in the story's time zone. */
+  engagements: {
+    id: number;
+    title: string;
+    at: string;
+    until: string | null;
+    location: string | null;
+    participants: string[];
+    note: string;
+  }[];
+  relationships: {
+    from: string;
+    to: string;
+    label: string;
+    summary: string;
+    familiarity: number;
+    trust: number;
+    affinity: number;
+    tension: number;
+    updated_turn: number;
+  }[];
+  knowledge: {
+    character: string;
+    kind: string;
+    subject: string;
+    learned_turn: number;
+    last_observed_turn: number | null;
+  }[];
+}
+/** Where an item is, in words. */
+declare function describeHolder(target: Pick<RecordsTarget, 'items' | 'locations' | 'characters'>, id: number, keyOfCharacter?: (id: number) => string): string;
+/** Read the records back from the database, as the edit wrote them. */
+declare function readRecords(target: Omit<RecordsTarget, 'transaction'>, scope?: RecordsScope): RecordsView;
+//#endregion
+//#region src/sqlite/schema.d.ts
+declare const LATEST_VERSION: number;
+//#endregion
+//#region src/store.d.ts
+interface StoreOptions extends OpenOptions {
+  /** Defaults to the driver on Node's built-in SQLite. */
+  driver?: SqlDriver;
+  /** Supplies the time stamped on rows; defaults to the system clock. */
+  clock?: Clock;
+  /** Whether to load the sqlite-vec extension for vector search. On by default; a session works without it when it is missing. */
+  vectors?: boolean;
+}
+/** One session: everything stored about it, reached through repositories. */
+interface SessionStore {
+  readonly metadata: MetadataRepository;
+  readonly characters: CharacterRepository;
+  readonly characterStates: CharacterStateRepository;
+  readonly factions: FactionRepository;
+  readonly factionStates: FactionStateRepository;
+  readonly factionMemberships: FactionMembershipRepository;
+  readonly factionRelationships: FactionRelationshipRepository;
+  readonly factionIntents: FactionIntentRepository;
+  readonly lore: LoreRepository;
+  readonly intents: IntentRepository;
+  readonly events: EventRepository;
+  readonly memories: MemoryRepository;
+  readonly threads: ThreadRepository;
+  readonly summaries: SummaryRepository;
+  readonly pendingCommits: PendingCommitRepository;
+  readonly locations: LocationRepository;
+  readonly placements: PlacementRepository;
+  readonly relationships: RelationshipRepository;
+  readonly knowledge: KnowledgeRepository;
+  readonly consolidation: ConsolidationRepository;
+  readonly slots: SlotRepository;
+  readonly items: ItemRepository;
+  readonly visualIdentities: VisualIdentityRepository;
+  /** The story's own time. */
+  readonly clock: ClockRepository;
+  /** What the story keeps track of: feelings, and whatever the world or the story declares. */
+  readonly variables: VariableRepository;
+  /** The recurring day of each character. */
+  readonly routines: RoutineRepository;
+  /** What characters have committed to, by date. */
+  readonly engagements: EngagementRepository;
+  readonly triggers: TriggerRepository;
+  /** What the session can be searched by: its texts by words, and by meaning once vectors are stored. */
+  readonly recallIndex: RecallIndexRepository;
+  /** Run `fn` atomically across the repositories; see {@link SqlDatabase.transaction}. */
+  transaction<T>(fn: () => T): T;
+  /**
+   * What a character is reminded of at this moment: what it took in and believes, chosen by what
+   * the situation calls to mind and, with flaky memory, by how much of it is left.
+   */
+  recall(query: Omit<RecallQuery, 'characters'>, evidence?: RecallEvidence): Recalled[];
+  /** The first stage of {@link SessionStore.recall}: retrieve by the cues, the words and the meaning of the moment, fuse, and over-retrieve. */
+  recallPool(query: Omit<RecallQuery, 'characters'>, evidence?: Omit<RecallEvidence, 'rerank'>): RecallPool;
+  /** The last stage: choose the best of a pool, by a reranker's judgement when there is one, and count what is recalled. */
+  finishRecall(pool: RecallPool, turn: number, rerank?: ReadonlyMap<string, number>): Recalled[];
+  /**
+   * What a character is reminded of, using the session's index as well as the cues: texts that match the
+   * moment by words, and, when the vector of the moment is given (from the model that made the stored
+   * vectors), texts that match it by meaning.
+   * @throws {InvalidValueError} when the vector has other dimensions than the stored ones.
+   */
+  recallStored(query: Omit<RecallQuery, 'characters'>, options?: {
+    queryVector?: readonly number[];
+  }): Recalled[];
+  /** What the session's index says about each candidate for a moment: by words, and by meaning when the vector of the moment is given. */
+  storedEvidence(query: Omit<RecallQuery, 'characters'>, queryVector?: readonly number[]): Pick<RecallEvidence, 'lexical' | 'dense'>;
+  /**
+   * Look up what happened (not what any character took in) by words and, with a vector, by meaning, best first.
+   * The two searches are merged by reciprocal rank, so what ranks well in either comes first.
+   */
+  searchEvents(search: {
+    text: string;
+    vector?: readonly number[];
+    limit?: number;
+    fromTurn?: number;
+    toTurn?: number;
+    minImportance?: number;
+    locationId?: number;
+    itemId?: number;
+  }): StoryEvent[];
+  /** What a character could be reminded of, to be ranked by meaning before {@link recall}. */
+  recallCandidates(query: Omit<RecallQuery, 'characters' | 'policy'>): RecallCandidate[];
+  /**
+   * Change the story's records (state, events and who took them in, beliefs, threads), together or not at all.
+   * @throws {InvalidEditError} naming every problem; nothing was written then.
+   */
+  /** Whether a character can go there, and the way it would take. */
+  planMove(characterId: CharacterId, move: Move): ReturnType<typeof planMove>;
+  /** Plan over only the places and directed exits this character knows. */
+  planKnownMove(characterId: CharacterId, move: Move): ReturnType<typeof planMove>;
+  /** Move a character: its place changes, at the position or feature given. @throws {InvalidMoveError} naming every reason. */
+  move(characterId: CharacterId, move: Move): MovePlan;
+  /** Apply an edit atomically; with `seal`, the events it adds are final at once (otherwise they stay drafts until sealed). */
+  edit(edit: RecordsEdit, options?: {
+    seal?: boolean;
+  }): EditResult;
+  /** Read the records back in the form models read them. */
+  records(scope?: RecordsScope): RecordsView;
+  /** Fire the triggers whose conditions just came true, each together with its effects or not at all. */
+  runTriggers(options: TriggerRunOptions): TriggerRun;
+  /** Let go of the beats and cues nobody took up in this many turns. */
+  lapseNotes(turn: number, kept: {
+    beats: number;
+    cues: number;
+  }): TriggerNote[];
+  /** Write a consistent copy of the whole database to `path`, which must not exist. */
+  snapshotTo(path: string): void;
+  close(): void;
+}
+/**
+ * Create the database of a new session at `location` (the file must not hold a
+ * session yet, and its folder must exist).
+ * @throws {ConflictError} when the location already holds a session database.
+ */
+declare function createSessionStore(location: string, session: NewSession, options?: StoreOptions): SessionStore;
+/**
+ * Open the database of an existing session, bringing an older schema up to date.
+ * @throws {NotFoundError} when there is no file at `location`.
+ * @throws {SchemaError} when the file is not a session database, or is from a newer version.
+ */
+declare function openSessionStore(location: string, options?: StoreOptions): SessionStore;
+//#endregion
+//#region src/sessions.d.ts
+declare const SESSION_DATABASE_FILE = "session.sqlite";
+/** A new session; its id is generated unless one is given. */
+type SessionInit = Omit<NewSession, 'id'> & {
+  id?: string;
+};
+declare function isSessionId(value: string): boolean;
+/** Folder holding everything about one session. */
+declare function sessionFolder(sessionsDir: string, id: string): string;
+declare function sessionDatabase(sessionsDir: string, id: string): string;
+/**
+ * Create `<sessionsDir>/<id>/session.sqlite` for a new session. Nothing is
+ * left behind when creating the database fails.
+ * @throws {ConflictError} when a session with that id already exists.
+ */
+declare function createSession(sessionsDir: string, init: SessionInit, options?: StoreOptions): SessionStore;
+/** @throws {NotFoundError} when the session does not exist. */
+declare function openSession(sessionsDir: string, id: string, options?: StoreOptions): SessionStore;
+/** Remove a session's folder and everything in it. */
+declare function deleteSession(sessionsDir: string, id: string): void;
+/** The sessions found under a sessions folder, and those that could not be read. */
+interface SessionListing {
+  sessions: SessionMetadata[];
+  problems: {
+    id: string;
+    message: string;
+  }[];
+}
+/**
+ * Read the metadata of every session under `sessionsDir`. Folders that are not
+ * named like a session are ignored; a session that cannot be read is reported
+ * and left out. Order is not defined.
+ * @param reuse - supplies a connection that is already open, so it is not opened twice.
+ */
+declare function listSessions(sessionsDir: string, options?: StoreOptions, reuse?: (id: string) => SessionStore | undefined): SessionListing;
+interface ForkOptions {
+  name: string;
+  /** The snapshots the copy keeps, besides its database; each must exist. */
+  keep: readonly string[];
+}
+//#endregion
+//#region src/memory/ranker.d.ts
+/**
+ * Judges the pool of memories a recall over-retrieved against the situation: a reranker (or an
+ * embedding model compared on the fly) behind one function. It returns how well each candidate
+ * matches the situation, from 0 to 1, by the candidate's key; a candidate left out counts as 0. It
+ * returns nothing when it has no way to judge right now (no reranking service is configured), and the
+ * recall then goes by retrieval alone. The plugin that owns such a capability registers it with
+ * `roleplayState.rankMemories`.
+ */
+type SemanticRanker = (input: {
+  situation: string;
+  candidates: readonly RecallCandidate[];
+  signal?: AbortSignal;
+}) => Promise<ReadonlyMap<string, number> | undefined>;
+//#endregion
+//#region src/tools/index.d.ts
+/** The roleplay session an agent works in, as the plugin that runs the agent knows it. */
+interface AgentLink {
+  session: Pick<Session, 'characters' | 'factions' | 'factionStates' | 'factionMemberships' | 'factionRelationships' | 'factionIntents' | 'lore' | 'events' | 'memories' | 'threads' | 'records' | 'recallRanked' | 'searchEvents' | 'edit' | 'locations' | 'placements' | 'relationships' | 'knowledge' | 'consolidation' | 'planMove' | 'items' | 'slots' | 'variables' | 'intents' | 'routines' | 'engagements' | 'clock'>;
+  /** The time zone the story's times are written and read in; UTC when not given. */
+  timeZone?: string;
+  /** The turn the agent is playing, which is what the age of a memory is counted from. */
+  turn: number;
+  policy: MemoryPolicy;
+  /**
+   * The vector of a text of the moment, from the model that made the session's stored vectors, so that
+   * a search also finds what means the same in other words. `undefined` (or a promise of it) when
+   * there is none, and the search then goes by words alone.
+   */
+  queryVector?: (text: string, signal?: AbortSignal) => Promise<readonly number[] | undefined>;
+}
+/** Finds the session behind an agent, by the id of the agent's own session; `undefined` when it works in none. */
+type AgentResolver = (agentSessionId: string) => AgentLink | undefined;
+/**
+ * The model-facing tools over a roleplay session. Reading tools show what the story has
+ * recorded; writing tools change it and are registered only when the plugin is configured
+ * for them. Both resolve the session from the agent that calls them.
+ */
+declare function createTools(resolve: AgentResolver, options: {
+  write: boolean;
+  /** Limits the characters a call may name to these keys, for an agent that works on one story. */
+  characters?: readonly string[];
+  /** Tools of the agent that makes up characters and places and fits them into the world: it makes them with `edit_world` instead of `edit_records`, and reads what is inconsistent. Never for a global registration. */
+  authoring?: boolean;
+}): ToolDefinition[];
+//#endregion
+//#region src/plugin.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    roleplayState: RoleplayState;
+  }
+}
+interface Config {
+  /** `delete` keeps each session in a single file that can be copied; `wal` allows readers while writing. */
+  journalMode: 'delete' | 'wal';
+  /**
+   * Whether the model-facing tools that change the records are registered too. The reading
+   * tools are always there; leave writing off where another agent is responsible for the records.
+   */
+  writeTools: boolean;
+}
+declare const Config: z<Config>;
+/** A session's repositories. Connections belong to the service, so there is nothing to close. */
+type Session = Omit<SessionStore, 'close' | 'snapshotTo'> & {
+  /**
+   * {@link SessionStore.recall}, with the over-retrieved pool reranked when a ranker is registered with
+   * `roleplayState.rankMemories`. The one call for anything that reminds a character of something.
+   */
+  recallRanked(query: Omit<RecallQuery, 'characters'>, signal?: AbortSignal, options?: {
+    queryVector?: readonly number[];
+  }): Promise<Recalled[]>;
+};
+/**
+ * Roleplay session state for other plugins. It creates and opens sessions
+ * under a sessions folder, shares one connection per session, and closes them
+ * all when the plugin unloads.
+ */
+declare class RoleplayState extends Service {
+  private readonly sessions;
+  private readonly options;
+  private readonly resolvers;
+  private readonly rankers;
+  constructor(ctx: Context, config?: Partial<Config>);
+  /**
+   * Let what characters remember be ranked by meaning, with an embedding model or a reranker
+   * from another plugin. The latest one registered is used, by every recall: the tools, and the
+   * plugins that run characters through `session.recallRanked`. Where it fails, recall carries on
+   * with the cues alone and says so in the log.
+   * @returns what removes it again.
+   */
+  rankMemories(ranker: SemanticRanker): () => void;
+  /**
+   * Tell the tools which roleplay session an agent works in. The plugin that runs agents
+   * calls this with a function from the id of an agent's session to its roleplay session,
+   * the turn it is playing and how its characters remember.
+   * @returns what removes the binding again.
+   */
+  bind(resolver: AgentResolver): () => void;
+  /**
+   * Create a session and open it. Its id is `init.id` or a generated UUID, and is in `metadata.get().id`.
+   * @throws {ConflictError} when a session with that id exists.
+   */
+  createSession(sessionsDir: string, init: SessionInit): Session;
+  /** @throws {NotFoundError} when the session does not exist. */
+  openSession(sessionsDir: string, id: string): Session;
+  /** The metadata of every session under the folder; sessions that cannot be read are reported, not thrown. */
+  listSessions(sessionsDir: string): SessionListing;
+  /** Release a session's connection; opening it again reconnects. */
+  closeSession(sessionsDir: string, id: string): void;
+  /** Keep a consistent copy of a session's database under a name (a lowercase name of letters, digits and hyphens), replacing one of that name. */
+  snapshot(sessionsDir: string, id: string, name: string): void;
+  /** The names of the snapshots a session has. */
+  snapshots(sessionsDir: string, id: string): string[];
+  /** Delete a snapshot, if there is one. */
+  removeSnapshot(sessionsDir: string, id: string, name: string): void;
+  /**
+   * Put the database of a session back as it was in a snapshot. The connection is released first, so anything that
+   * holds the session from before has to ask for it again: nothing may be using it.
+   * @throws {NotFoundError} when there is no such snapshot.
+   */
+  restore(sessionsDir: string, id: string, name: string): void;
+  /**
+   * Make a new session from a snapshot of another, or from its database as it is (nothing may be writing to it): the new one has
+   * a folder of its own with the database, the settings and the snapshots named in `keep`, and its own id and name.
+   * @throws {ConflictError} when the new id exists. @throws {NotFoundError} when a snapshot does not exist.
+   */
+  fork(sessionsDir: string, fromId: string, toId: string, from: {
+    snapshot: string;
+  } | {
+    live: true;
+  }, options: ForkOptions): void;
+  /** Close a session and remove its folder, including everything else kept in it. */
+  deleteSession(sessionsDir: string, id: string): void;
+  private track;
+  private closeAll;
+}
+declare const name = "@dsh-agentic-roleplay/state";
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+//#region src/tools/character.d.ts
+declare function createCharacterTools(link: () => AgentLink, characterId: CharacterId): ToolDefinition[];
+//#endregion
+//#region src/sqlite/variable-repository.d.ts
+/** Why a value is not one the variable can have, or nothing when it is. */
+declare function valueIssue(def: Pick<VariableDefinition, 'key' | 'kind' | 'min' | 'max' | 'integer' | 'options'>, value: unknown): string | undefined;
+//#endregion
+//#region src/records/agenda.d.ts
+/** One occurrence of a routine window: the stretch of time it holds on a particular day. */
+interface Occurrence {
+  window: StoredRoutineWindow;
+  startsAt: number;
+  endsAt: number;
+}
+/** An engagement still pending this long after it was due (or over) is overdue. */
+declare const ENGAGEMENT_GRACE: number;
+/** The window that holds at an instant (the first of the list that does), with the stretch of this occurrence of it. */
+declare function occurrenceAt(windows: readonly StoredRoutineWindow[], now: number, zone: string): Occurrence | undefined;
+/** The window that starts next after an instant, within `horizon`. */
+declare function nextOccurrence(windows: readonly StoredRoutineWindow[], now: number, zone: string, horizon: number): Occurrence | undefined;
+interface RankedGoal {
+  intent: CharacterIntent;
+  /** The deadline as an instant, when it has one that can be read. */
+  deadlineAt?: number;
+  overdue: boolean;
+  score: number;
+}
+/** What a character is after, most pressing first: priority and urgency, and how close or past the deadline is. Goals not active are left out. */
+declare function rankGoals(goals: readonly CharacterIntent[], now: number, zone: string, limit: number): RankedGoal[];
+interface AgendaEngagement {
+  engagement: Engagement;
+  overdue: boolean;
+}
+interface Agenda {
+  /** What the routine has the character doing now. */
+  now?: Occurrence;
+  /** What the routine has it doing next, within the horizon. */
+  next?: Occurrence;
+  /** What it has committed to that is due within the horizon or is overdue, in the order they are due. */
+  engagements: AgendaEngagement[];
+  goals: RankedGoal[];
+}
+interface AgendaOptions {
+  /** How far ahead to look, in milliseconds. */
+  horizon?: number;
+  goals?: number;
+  engagements?: number;
+}
+/** What a character is expected to be doing and to have done at an instant: its routine, its commitments and its goals. */
+declare function agendaAt(source: {
+  routines: Pick<RoutineRepository, 'list'>;
+  engagements: Pick<EngagementRepository, 'list'>;
+  intents: Pick<IntentRepository, 'list'>;
+}, characterId: CharacterId, now: number, zone: string, options?: AgendaOptions): Agenda;
+//#endregion
+//#region src/sqlite/agenda-repositories.d.ts
+/** At most this many windows for one character, so that a day stays something a model can hold. */
+declare const MAX_ROUTINE_WINDOWS = 24;
+//#endregion
+//#region src/records/time.d.ts
+/** Instants are UTC milliseconds; a time zone only decides how they read. */
+declare const SECOND = 1000;
+declare const MINUTE: number;
+declare const HOUR: number;
+declare const DAY: number;
+/** Whether a name is a time zone this runtime knows (an IANA name such as `Europe/London`, or `UTC`). */
+declare function isTimeZone(zone: string): boolean;
+/** The time zone of this computer. */
+declare const systemTimeZone: () => string;
+interface LocalTime {
+  year: number;
+  /** 1 to 12. */
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  /** 0 for Sunday to 6 for Saturday. */
+  weekday: number;
+  minuteOfDay: number;
+}
+/** What the wall clock of a zone reads at an instant. */
+declare function localTime(instant: number, zone: string): LocalTime;
+/** The instant at which the wall clock of a zone reads this; a time that does not exist (the clocks jumped over it) is moved on by the length of the jump. */
+declare function zonedInstant(fields: {
+  year: number;
+  month: number;
+  day: number;
+  hour?: number;
+  minute?: number;
+  second?: number;
+}, zone: string): number;
+/**
+ * An instant from text: an ISO 8601 date and time with an offset or `Z` is taken as written; without one
+ * it is the wall clock of `zone`. A date alone is that day at midnight.
+ * @throws {RangeError} when it is not a date and time.
+ */
+declare function parseInstant(text: string, zone: string): number;
+/** `Tuesday 4 October 1912, 21:40`. */
+declare function describeInstant(instant: number, zone: string): string;
+/** `1912-10-04T21:40:00` as the wall clock of a zone reads, the form a file or a person can write back. */
+declare function localIso(instant: number, zone: string): string;
+declare const DAY_PARTS: readonly ["night", "morning", "afternoon", "evening"];
+type DayPart = (typeof DAY_PARTS)[number];
+/** Night is from 22:00 to 05:00, morning to 12:00, afternoon to 17:00, evening after. */
+declare function dayPart(minuteOfDay: number): DayPart;
+/** In words and rounded to what matters: `45 seconds`, `3 hours 12 minutes`, `2 days 3 hours`. */
+declare function describeDuration(milliseconds: number): string;
+/** The minute of the day for `HH:MM` (24-hour), or nothing when it is not one. */
+declare function parseTimeOfDay(text: string): number | undefined;
+/**
+ * The instant the wall clock of a zone next reads `HH:MM` after `now`; with `daysLater`, that time on the day
+ * that many days after today (it must still be after `now`).
+ * @throws {RangeError} when the time is not `HH:MM` or is not after `now`.
+ */
+declare function nextTimeOfDay(now: number, zone: string, time: string, daysLater?: number): number;
+/** Whether a minute of the day is inside a window; `start` to `end` is half open and wraps past midnight, and equal ends make an empty window. */
+declare function inWindow(minuteOfDay: number, start: number, end: number): boolean;
+/**
+ * What to catch up on after being away: only the newest `maxMs` of the gap, in at most `maxSteps` equal
+ * steps, so that a long absence costs a bounded amount of work.
+ */
+declare function catchUpPlan(cursor: number, now: number, limits?: {
+  maxMs?: number;
+  maxSteps?: number;
+}): {
+  from: number;
+  to: number;
+  skipped: number;
+  steps: {
+    from: number;
+    to: number;
+  }[];
+};
+/** `21:40`: the clock of a zone at an instant. */
+declare function clockTime(instant: number, zone: string): string;
+/** The local calendar day `days` after the one the instant falls on, as year, month and day. */
+declare function addLocalDays(instant: number, zone: string, days: number): {
+  year: number;
+  month: number;
+  day: number;
+  weekday: number;
+};
+//#endregion
+//#region src/records/lint.d.ts
+type LintSeverity = 'error' | 'warning' | 'info';
+interface LintFinding {
+  /** An error leaves the world inconsistent (nobody can get to a place, two characters share a name); a warning is something that should be fitted in; an info is only worth knowing. */
+  severity: LintSeverity;
+  code: string;
+  subject: {
+    kind: 'character' | 'location' | 'exit' | 'relationship' | 'item';
+    key: string;
+  };
+  message: string;
+}
+type LintTarget = Pick<RecordsTarget, 'characters' | 'locations' | 'placements' | 'relationships' | 'consolidation' | 'items'>;
+/**
+ * What is inconsistent or unfinished in the world's graph of places and characters. Things made up in
+ * play and not fitted in yet are held to a stricter standard than what the world was written with: a
+ * place that no one can reach or leave is an error for them, and a warning for the rest.
+ */
+declare function lintWorld(target: LintTarget): LintFinding[];
+//#endregion
+export { ACCURACIES, Accuracy, type Agenda, type AgendaEngagement, type AgendaOptions, type AgentLink, type AgentResolver, type Announcement, type BeliefEdit, CHARACTER_CONTROLS, CHARACTER_KINDS, CHARACTER_ROLES, CHARACTER_TIERS, CLOCK_MODES, COMPARISONS, CONSOLIDATION_KINDS, CONTAINER_STATES, Character, CharacterControl, CharacterDefinition, CharacterFilter, CharacterId, CharacterIntent, CharacterKind, CharacterMemory, CharacterMemoryPatch, type CharacterMove, CharacterPatch, type CharacterRepository, CharacterRole, CharacterSpeech, CharacterStart, CharacterState, CharacterStatePatch, type CharacterStateRepository, CharacterTier, type Clarity, type Clock, ClockMode, ClockState, Comparison, Config, ConflictError, ConsolidationItem, ConsolidationItemId, ConsolidationKind, type ConsolidationRepository, ContainerSpec, ContainerState, CorruptDataError, DAY, DAY_PARTS, DEFAULT_MEMORY_POLICY, DEFAULT_SLOTS, type DayPart, EMOTION_VARIABLES, ENGAGEMENT_GRACE, ENGAGEMENT_STATUSES, EXIT_STATES, type EditChecker, type EditResult, EmbeddingIndexInfo, EmotionStart, EmotionVector, Engagement, EngagementFilter, EngagementId, EngagementPatch, EngagementStatus, EntityKnowledge, type EventEdit, EventId, type EventRepository, Exit, type ExitChange, ExitDefinition, ExitId, ExitOpener, ExitPatch, ExitState, Faction, FactionDefinition, FactionId, FactionIntent, type FactionIntentRepository, FactionMembership, FactionMembershipDefinition, type FactionMembershipRepository, FactionPatch, FactionRelationship, FactionRelationshipDefinition, type FactionRelationshipRepository, type FactionRepository, FactionState, FactionStatePatch, type FactionStateRepository, type FiredTrigger, HOUR, Holder, Holding, IMPORTANCE_MAX, IMPORTANCE_MIN, INTENT_HORIZONS, INTENT_STATUSES, INTENT_TYPES, ITEM_ACTIONS, Intent, IntentFilter, IntentHorizon, IntentId, IntentPatch, type IntentRepository, IntentStatus, IntentType, InvalidEditError, InvalidMoveError, InvalidValueError, Item, type ItemAction, type ItemChange, type ItemChangeSpec, type ItemContext, ItemDefinition, type ItemEditSpec, type ItemEffect, ItemId, ItemPatch, type ItemPlan, type ItemRepository, JsonValue, KNOWLEDGE_KINDS, KnowledgeDefinition, KnowledgeKind, type KnowledgeRepository, type KnownMoveContext, LORE_KINDS, LORE_SUBJECT_KINDS, type LintFinding, type LintSeverity, type LintTarget, type LocalTime, Location, LocationDefinition, LocationFeature, LocationId, LocationPatch, type LocationRepository, Lore, LoreDefinition, LoreId, LoreKind, LorePatch, LoreSubject, LoreSubjectDefinition, LoreSubjectKind, MAX_LOCATION_FEATURES, MAX_ROUTINE_WINDOWS, MAX_SHOWN, MAX_TRIGGERS, MAX_VARIABLES, MEMBERSHIP_STATUSES, MEMORY_KINDS, MINUTE, MembershipPatch, MembershipStatus, MemoryId, MemoryKind, type MemoryPolicy, type MemoryRepository, type MetadataRepository, Move, type MoveContext, MovePlan, type NewBelief, NewCharacter, NewCharacterMemory, type NewCharacterSpec, NewCharacterState, NewEngagement, type NewEvent, NewExit, type NewExitBetween, type NewExit$1 as NewExitEdit, NewFaction, NewFactionState, NewItem, type NewItemSpec, NewLocation, NewLore, NewPerception, type NewPlace, NewPlacement, NewRelationship, NewSession, NewStoryEvent, NewSummary, NewTriggerNote, NotFoundError, type Occurrence, type OpenOptions, PERCEPTION_MODES, PLACEABLE_KINDS, PLOT_NUDGE_MODES, PLOT_STATUSES, PendingCommit, type PendingCommitRepository, PendingEmbedding, type PerceivedBy, PerceivedEvent, Perception, type PerceptionAddition, type PerceptionEdit, PerceptionId, PerceptionMode, PerceptionPatch, type PlaceEdit, PlaceableKind, Placement, type PlacementRepository, PlotDefinition, PlotDevelopment, PlotNudgeMode, PlotProgress, PlotStatus, RECALL_ITEM_KINDS, type RankedGoal, type RecallCandidate, type RecallEvidence, RecallHit, type RecallIndexRepository, RecallItemKind, type RecallPool, type RecallQuery, type RecallSearch, type RecallSource, type Recalled, type RecordsEdit, type RecordsScope, type RecordsTarget, type RecordsView, Relationship, RelationshipDefinition, RelationshipId, RelationshipPatch, type RelationshipRepository, type RelationshipRetraction, type RelationshipSet, RoleplayState, RoutineDefinition, RoutineWindow, type RunResult, LATEST_VERSION as SCHEMA_VERSION, SECOND, SESSION_DATABASE_FILE, SLOT_ID, SUMMARY_LEVELS, SchemaError, type SemanticRanker, type Session, type SessionInit, type SessionListing, SessionMetadata, type SessionStore, type ShownVariable, Slot, type SlotRepository, SocialSubjectKind, type SqlDatabase, type SqlDriver, type SqlValue, StateError, type StatePatch, type StoreOptions, StoredRoutineWindow, StoredVariable, StoryEvent, StoryEventFilter, StoryEventPatch, StoryThread, Summary, SummaryId, SummaryLevel, type SummaryRepository, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, ThreadId, type ThreadRepository, ThreadStatus, TimeChange, TimeChangeFilter, TimeChangeKind, Trigger, TriggerAnnouncement, TriggerAudience, type TriggerClock, TriggerCondition, TriggerDefinition, TriggerEffect, TriggerId, TriggerNote, TriggerNoteKind, type TriggerRun, type TriggerRunOptions, TriggerStatus, VARIABLE_KEY, VARIABLE_KINDS, VARIABLE_SUBJECTS, VARIABLE_VISIBILITIES, VISUAL_SUBJECT_KINDS, type VariableAudience, VariableBand, type VariableChangeSpec, type VariableContext, VariableDefinition, VariableDefinitionInput, type VariableEffect, VariableKind, type VariablePlan, VariableSubject, VariableValue, VariableVisibility, type VectorSearch, type VectorSupport, VisualIdentity, VisualIdentityInput, VisualIdentityPatch, type VisualIdentityRepository, VisualSubjectKind, WEEKDAY_NAMES, WorldReference, addLocalDays, agendaAt, announcements, apply, applyItemPlan, applyRecordsEdit, audienceIds, catchUpPlan, changeItem, changeVariable, characterKey, clarityAt, clockTime, conditionHolds, createCharacterTools, createSession, createSessionStore, createTools, dayPart, deleteSession, denseScore, describeDuration, describeHolder, describeInstant, describeValue, finishRecall, fuseScores, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, occurrenceAt, openSession, openSessionStore, overlap, parseInstant, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, retention, runTriggers, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemTimeZone, tokens, triggerReferenceProblems, valueIssue, zonedInstant };
+//# sourceMappingURL=index.d.ts.map