@dsh-agentic-roleplay/state 0.3.0 → 0.3.2

package/README.md

@@ -133,7 +133,7 @@ characters created during play have none.
 | `locations`, `exits`, `placements` | Places (with features), the ways between them (one direction each, `open` / `locked` / `blocked`, optional travel seconds) and where things stand (a character: place, position, feature; the same table will place items). `session.planMove` / `session.move` move a character over open exits only (`InvalidMoveError` names every reason); the edit wire format can make places, change exits and move characters. |
 | `events` | What objectively happened: turn, round, text, importance (1 to 5), tags. `event_involves` lists the characters an event is about. Events are immutable: a draft until `sealed`, final afterwards (`events.seal()`); updating or removing a sealed one throws `ConflictError`. |
 | `perceptions` | What one character took in of an event, in its own terms: mode (witnessed, heard, told, inferred), content, a gist for when it fades, an accuracy label (never shown to the character), and how often it was recalled. One per character and event. |
-| `memories` | What a character believes or knows beyond single events: kind (belief, relationship, knowledge), text, the characters it is about, importance, the turn it formed in. |
+| `memories`, `memory_evidence` | What a character believes or knows beyond single events: kind, text, subjects, importance, confidence, formation turn, and the perceptions that support or contradict it. |
 | `story_threads` | Things not settled yet: promises, mysteries, goals; open or resolved. |
 | `summaries` | The account of the story for the conversation's head: digests of recent turns and chapters of older ones, each with the turns it covers. |
 | `recall_items`, `recall_fts`, `recall_vocab`, `recall_vec` | The search index: one row per perception, memory and event, indexed by words (FTS5) and, once vectors are stored, by meaning (sqlite-vec, cosine, partitioned by character). `store.recallIndex` lists the texts without a vector (`pending`), stores vectors (`store`, which fixes the model and dimensions of the session's vectors) and searches (`lexical`, `vector`). Vector support is optional: without the extension everything but `vector` works. |

package/lib/index.d.ts

@@ -367,6 +367,11 @@ interface LocationDefinition {
 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[];
+  /**
+   * Other days it applies on or does not (`dec`, `12-24`, `season:winter`, `nth:mon:1`, `holiday:<id>`, a `!` before one for a day it does not apply
+   * on): it applies on a day that is among `days` and that these allow. Every day when empty or left out.
+   */
+  on?: string[];
   /** 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. */
@@ -380,6 +385,7 @@ interface RoutineWindow {
   interruptible: boolean;
 }
 interface StoredRoutineWindow extends RoutineWindow {
+  on: string[];
   id: number;
   characterId: CharacterId;
 }
@@ -387,6 +393,8 @@ interface StoredRoutineWindow extends RoutineWindow {
 interface RoutineDefinition {
   /** Three-letter days (`mon` to `sun`); every day when left out. */
   days: string[];
+  /** Other days it applies on or does not, as for {@link RoutineWindow.on}. */
+  on?: string[];
   /** `HH:MM`. */
   from: string;
   to: string;
@@ -714,6 +722,13 @@ 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];
+/** How sure a character is of what it believes, from least to most. */
+declare const MEMORY_CONFIDENCES: readonly ["doubtful", "likely", "sure"];
+type MemoryConfidence = (typeof MEMORY_CONFIDENCES)[number];
+declare const DEFAULT_CONFIDENCE: MemoryConfidence;
+/** Whether a perception speaks for a belief or against it. */
+declare const EVIDENCE_RELATIONS: readonly ["supports", "contradicts"];
+type EvidenceRelation = (typeof EVIDENCE_RELATIONS)[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. */
@@ -808,17 +823,30 @@ interface CharacterMemory {
   /** The characters it is about. */
   about: CharacterId[];
   importance: number;
+  /** How sure the character is of it. */
+  confidence: MemoryConfidence;
   /** The turn it was formed in. */
   turn: number;
   recalls: number;
   lastRecalledTurn?: number;
   createdAt: string;
 }
-type NewCharacterMemory = Omit<CharacterMemory, 'id' | 'createdAt' | 'recalls' | 'lastRecalledTurn'>;
+type NewCharacterMemory = Omit<CharacterMemory, 'id' | 'createdAt' | 'recalls' | 'lastRecalledTurn' | 'confidence'> & {
+  confidence?: MemoryConfidence;
+};
 interface CharacterMemoryPatch {
   text?: string;
   about?: CharacterId[];
   importance?: number;
+  confidence?: MemoryConfidence;
+}
+/** What a character took in that a belief rests on, or that speaks against it. */
+interface MemoryEvidence {
+  memoryId: MemoryId;
+  perceptionId: PerceptionId;
+  relation: EvidenceRelation;
+  /** The turn the link was made. */
+  turn: number;
 }
 /** Something in the story that is not settled yet: a promise, a mystery, a goal. */
 interface StoryThread {
@@ -1012,7 +1040,7 @@ type Comparison = (typeof COMPARISONS)[number];
  * 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. */
+/** 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 and on the days `on` allows (months, dates, seasons, holidays of the world's calendar). */
 {
   type: 'time';
   from?: string;
@@ -1022,6 +1050,7 @@ type TriggerCondition =
     to: string;
   };
   days?: string[];
+  on?: string[];
 } |
 /** A character is in a place, at a feature of it when given. */
 {
@@ -1170,6 +1199,90 @@ interface NewTriggerNote {
 /** At most this many triggers in a story. */
 declare const MAX_TRIGGERS = 200;
 //#endregion
+//#region ../dsh-roleplay-model/src/dice.d.ts
+type DiceCheckId = number;
+type DiceRollId = number;
+/** What a band of a check makes of an attempt; the same three results a round's outcome has. */
+declare const DICE_RESULTS: readonly ["succeeded", "partial", "failed"];
+type DiceResult = (typeof DICE_RESULTS)[number];
+/** How a roll is read: by its total, or by how many of the dice came up high enough. */
+declare const DICE_READINGS: readonly ["total", "successes"];
+type DiceReading = (typeof DICE_READINGS)[number];
+/**
+ * What the value is compared with: `absolute` reads the value itself, `over` the amount by which it beats the target
+ * (a difficulty to meet or exceed), `under` the amount by which it stays below the target (a skill to roll under).
+ */
+declare const DICE_COMPARISONS: readonly ["absolute", "over", "under"];
+type DiceComparison = (typeof DICE_COMPARISONS)[number];
+/** One range of values and what it means; a range left open at an end runs on for ever. */
+interface DiceBand {
+  min?: number;
+  max?: number;
+  /** What it is called in play ("critical failure", "success at a cost"). */
+  label: string;
+  result: DiceResult;
+  /** A result that is more than the plain one: a critical. */
+  critical?: boolean;
+}
+/** A way of settling an attempt, as a world defines it; the dice and the reading of what they show are the world's, not the model's. */
+interface DiceCheckDefinition {
+  key: string;
+  name: string;
+  /** When the game master uses this check, in the author's words. */
+  use: string;
+  /** Dice notation: `1d20`, `2d6`, `4d6kh3`, `d100`. */
+  dice: string;
+  reading?: DiceReading;
+  /** With the reading `successes`: a die counts when it shows at least this. */
+  hit?: number;
+  compare?: DiceComparison;
+  /** The key of a variable of the acting character that is added to the total. */
+  modifier?: string;
+  bands: DiceBand[];
+}
+interface DiceCheck extends DiceCheckDefinition {
+  id: DiceCheckId;
+}
+/** What the dice and the reading of them gave, once a roll is made. */
+interface DiceReadout {
+  label: string;
+  result: DiceResult;
+  critical: boolean;
+}
+interface NewDiceRoll {
+  turn: number;
+  /** The check that was rolled, none for a plain roll. */
+  check?: string;
+  expression: string;
+  /** Every die rolled, in order. */
+  faces: number[];
+  /** The dice that count, after any are dropped or only the best are kept. */
+  kept: number[];
+  /** What is added to the dice: constants of the expression, the character's modifier, a bonus. */
+  modifier: number;
+  target?: number;
+  /** What the dice and the modifier add up to, or the number of dice that hit. */
+  total: number;
+  /** What the bands were compared with: the total, or its distance from the target. */
+  value: number;
+  readout?: DiceReadout;
+  reason: string;
+  /** The character the roll was for, by key. */
+  character?: string;
+  /** Who asked for it. */
+  by: 'agent' | 'player';
+}
+interface DiceRoll extends NewDiceRoll {
+  id: DiceRollId;
+  at: string;
+}
+/** Rolls and checks are limited so that a story cannot grow without bound. */
+declare const MAX_DICE_CHECKS = 40;
+declare const MAX_DICE_BANDS = 20;
+declare const MAX_DICE_PER_ROLL = 100;
+declare const MAX_DICE_SIDES = 1000;
+declare const MAX_DICE_TERMS = 8;
+//#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"];
@@ -1256,6 +1369,24 @@ interface PlotProgress {
   lastNudgeAt?: number;
 }
 //#endregion
+//#region ../dsh-roleplay-model/src/messages.d.ts
+/** The languages the texts a model reads are written in. English is the source: a text is its own key. */
+declare const LANGUAGES: readonly ["en", "zh"];
+type Language = (typeof LANGUAGES)[number];
+/** The language a setting such as `zh-CN` or `en` stands for; English when it is none that is known. */
+declare function languageOf(code: string | undefined): Language;
+type MessageValues = Readonly<Record<string, string | number>>;
+/** Says a text in the language of the story: `tr('{name} is in {place}.', { name, place })`. */
+type Translate = (text: string, values?: MessageValues) => string;
+/**
+ * The texts the engine builds for a model (briefs, reports, refusals) in a language. The text written in the code is the English one and the key of
+ * the others; a text a language lacks is told in English, and a test keeps that from happening.
+ */
+declare function translator(language: Language): Translate;
+/** The texts with a translation, for the test that every text has one. */
+declare const translated: (language: Exclude<Language, "en">) => readonly string[];
+declare const translation: (language: Exclude<Language, "en">, text: string) => string | undefined;
+//#endregion
 //#region src/clock.d.ts
 type Clock = () => Date;
 declare const systemClock: Clock;
@@ -1482,6 +1613,17 @@ interface MemoryRepository {
   /** Count a memory as recalled in `turn`. */
   touch(ids: readonly MemoryId[], turn: number): void;
   remove(id: MemoryId): boolean;
+  /** Record that a perception of the character's speaks for a belief or against it; one link per pair, the later replaces the earlier. @throws {NotFoundError} */
+  addEvidence(memoryId: MemoryId, perceptionId: PerceptionId, relation: EvidenceRelation, turn: number): void;
+  evidenceOf(memoryId: MemoryId): MemoryEvidence[];
+  /**
+   * What a character's beliefs rest on: for each perception that some belief of the character cites, the beliefs that do (it is folded into them),
+   * and the beliefs something it took in speaks against (disputed).
+   */
+  evidenceIndex(characterId: CharacterId): {
+    folded: Map<PerceptionId, MemoryId[]>;
+    disputed: Set<MemoryId>;
+  };
 }
 interface ThreadRepository {
   open(text: string, turn: number): StoryThread;
@@ -1815,6 +1957,21 @@ interface TriggerRepository {
   /** @throws {NotFoundError} */
   resolveNote(id: number, status: 'done' | 'lapsed'): void;
 }
+interface DiceRepository {
+  /** @throws {ConflictError} for a key that exists. @throws {InvalidValueError} when the story has too many. */
+  define(definition: DiceCheckDefinition): DiceCheck;
+  /** In the order defined. */
+  checks(): DiceCheck[];
+  check(key: string): DiceCheck | undefined;
+  /** @throws {NotFoundError} */
+  removeCheck(key: string): void;
+  record(roll: NewDiceRoll): DiceRoll;
+  /** Oldest first: the rolls of one turn, or the latest ones. */
+  rolls(filter?: {
+    turn?: number;
+    limit?: number;
+  }): DiceRoll[];
+}
 //#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. */
@@ -1999,6 +2156,8 @@ interface RecordsTarget {
   routines: RoutineRepository;
   engagements: EngagementRepository;
   triggers: TriggerRepository;
+  /** What the story keeps about itself; the calendar of its world is read from here. */
+  metadata: Pick<MetadataRepository, 'getValue'>;
   transaction<T>(fn: () => T): T;
 }
 interface PerceivedBy {
@@ -2249,12 +2408,20 @@ interface NewBelief {
   text: string;
   about?: string[];
   importance: number;
+  /** How sure the character is; likely when not said. */
+  confidence?: MemoryConfidence;
+  /** The numbers of perceptions of the character's own that it rests on, and that speak against it. */
+  evidenceFor?: number[];
+  evidenceAgainst?: number[];
 }
 interface BeliefEdit {
   id: number;
   text?: string;
   about?: string[];
   importance?: number;
+  confidence?: MemoryConfidence;
+  evidenceFor?: number[];
+  evidenceAgainst?: number[];
 }
 /**
  * A change to the story's records, applied together or not at all: the unit in which the
@@ -2309,6 +2476,8 @@ interface EngagementEditSpec {
 interface RoutineWindowSpec {
   /** `mon` to `sun`; every day when left out. */
   days?: string[];
+  /** Other days it applies on or not: `dec`, `12-24`, `season:winter`, `nth:mon:1`, `holiday:<id>`, `!` before one for a day it does not apply on. */
+  on?: string[];
   /** `HH:MM`. */
   from: string;
   to: string;
@@ -2397,7 +2566,7 @@ declare function parseTriggerDefinition(value: unknown, path: string, checkEdit:
 } | {
   problems: string[];
 };
-type Reading$1 = Pick<RecordsTarget, 'characters' | 'locations' | 'items' | 'variables' | 'triggers'>;
+type Reading$1 = Pick<RecordsTarget, 'characters' | 'locations' | 'items' | 'variables' | 'triggers' | 'metadata'>;
 /**
  * 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.)
@@ -2544,6 +2713,11 @@ interface MemoryPolicy {
    * included) to 1 (only what adds something new): maximal marginal relevance over the pool. 0 or absent: none.
    */
   diversity?: number;
+  /**
+   * How long what a character took in lasts once a belief rests on it, as a share of how long it would last: below 1 it fades sooner, the
+   * belief having taken over, and it is not told again when that belief is told. 1 or absent: no change.
+   */
+  foldedFade?: number;
 }
 declare const DEFAULT_MEMORY_POLICY: MemoryPolicy;
 /** How much of a memory is left: what the character is told of it. */
@@ -2563,6 +2737,10 @@ interface Recalled {
   };
   /** It did not match the moment itself: it came to mind with something that did ({@link MemoryPolicy.associate}). */
   linked?: true;
+  /** For what the character believes: how sure it is. */
+  confidence?: MemoryConfidence;
+  /** For what the character believes: something it took in since speaks against it. */
+  disputed?: true;
   /** Why it came back, when the query asked to be told ({@link RecallQuery.explain}). */
   why?: RecallWhy;
 }
@@ -2612,7 +2790,7 @@ interface RecallQuery {
 /** What recall reads: the events a character took in and what it believes. */
 interface RecallSource {
   events: Pick<EventRepository, 'perceivedBy'>;
-  memories: Pick<MemoryRepository, 'list'>;
+  memories: Pick<MemoryRepository, 'list'> & Partial<Pick<MemoryRepository, 'evidenceIndex'>>;
   clock: Pick<ClockRepository, 'get' | 'log'>;
   /** Optional for lightweight callers; a session supplies it so socially charged people are stronger cues. */
   relationships?: Pick<RelationshipRepository, 'from'>;
@@ -2655,6 +2833,8 @@ interface Candidate {
   recalls: number;
   seed: number;
   durability: number;
+  /** For something the character took in that beliefs rest on: those beliefs. */
+  covered?: 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. */
@@ -2678,7 +2858,9 @@ interface RecallEvidence {
   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' | 'about'>): RecallCandidate[];
+declare function recallCandidates(source: RecallSource, query: Pick<RecallQuery, 'characterId' | 'characters' | 'situation' | 'turn' | 'locationId' | 'about'> & {
+  policy?: MemoryPolicy;
+}): 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;
@@ -2852,6 +3034,9 @@ interface RecordsView {
     text: string;
     about: string[];
     importance: number;
+    confidence: string;
+    evidence_for: number[];
+    evidence_against: number[];
     turn: number;
   }[];
   open_threads: {
@@ -2977,6 +3162,7 @@ interface SessionStore {
   /** What characters have committed to, by date. */
   readonly engagements: EngagementRepository;
   readonly triggers: TriggerRepository;
+  readonly dice: DiceRepository;
   /** 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}. */
@@ -3122,7 +3308,7 @@ type SemanticRanker = (input: {
 //#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'>;
+  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' | 'dice'>;
   /** 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. */
@@ -3164,6 +3350,11 @@ interface Config {
    * tools are always there; leave writing off where another agent is responsible for the records.
    */
   writeTools: boolean;
+  /**
+   * Whether the dice tools (`roll_dice`, `roll_check`, `list_checks`) are registered for every agent of a roleplay session. Leave off where another plugin
+   * decides which agents may roll, as the roleplay core does with its per-agent tool settings.
+   */
+  diceTools: boolean;
 }
 declare const Config: z<Config>;
 /** A session's repositories. Connections belong to the service, so there is nothing to close. */
@@ -3246,10 +3437,192 @@ declare function apply(ctx: Context, config: Config): void;
 //#region src/tools/character.d.ts
 declare function createCharacterTools(link: () => AgentLink, characterId: CharacterId): ToolDefinition[];
 //#endregion
+//#region src/records/dice.d.ts
+/** A die with this many sides shows a number from 1 to `sides`. The system's own source of randomness is the default. */
+type Roller = (sides: number) => number;
+declare const systemRoller: Roller;
+type KeepMode = 'kh' | 'kl' | 'dh' | 'dl';
+type Term = {
+  sign: 1 | -1;
+  count: number;
+  sides: number;
+  keep?: {
+    mode: KeepMode;
+    n: number;
+  };
+} | {
+  sign: 1 | -1;
+  constant: number;
+};
+interface Notation {
+  /** The expression written the same way whatever the spacing and case. */
+  text: string;
+  terms: Term[];
+}
+/** Reads dice notation: `2d6+1`, `d20`, `4d6kh3`, `d%`, `1d8+1d4-1`. @throws {InvalidValueError} with what is wrong. */
+declare function parseNotation(input: string): Notation;
+/** The lowest and highest total the dice and constants can give. */
+declare function notationRange(notation: Notation): {
+  min: number;
+  max: number;
+};
+interface Rolled {
+  /** Every die, in the order of the terms. */
+  faces: number[];
+  /** The dice that count. */
+  kept: number[];
+  /** The constants of the expression, signed. */
+  constant: number;
+  /** The dice that count with their signs, plus the constants. */
+  total: number;
+}
+declare function rollNotation(notation: Notation, roll?: Roller): Rolled;
+/** What the bands of a check make of a value. @throws {InvalidValueError} when no band holds it. */
+declare function readBands(bands: readonly DiceBand[], value: number): DiceReadout;
+interface CheckRoll {
+  faces: number[];
+  kept: number[];
+  modifier: number;
+  target?: number;
+  total: number;
+  value: number;
+  readout: DiceReadout;
+}
+/**
+ * Rolls a check: the dice, the character's modifier and any bonus added, then the value read against the bands. With the reading
+ * `successes` the total is the number of dice that hit. A check read against a target needs one.
+ * @throws {InvalidValueError} for a target a check needs and is not given, or bands that leave the value unread.
+ */
+declare function rollCheck(check: DiceCheckDefinition, input: {
+  modifier?: number;
+  bonus?: number;
+  target?: number;
+}, roll?: Roller): CheckRoll;
+/** What is wrong with a check as a world defines it; nothing when it is sound. */
+declare function checkProblems(check: DiceCheckDefinition): string[];
+/** A roll of dice with no meaning attached, for what the world has no check for. */
+interface PlainRoll {
+  expression: string;
+  faces: number[];
+  kept: number[];
+  modifier: number;
+  total: number;
+}
+declare function rollPlain(expression: string, roll?: Roller): PlainRoll;
+//#endregion
+//#region src/tools/dice.d.ts
+declare const ROLL_DICE_TOOL = "roll_dice";
+declare const ROLL_CHECK_TOOL = "roll_check";
+declare const LIST_CHECKS_TOOL = "list_checks";
+/** The tools that need the dice and nothing else of the story. */
+type DiceLink = Pick<AgentLink, 'turn'> & {
+  session: Pick<AgentLink['session'], 'dice' | 'characters' | 'variables'>;
+};
+/** How a roll reads to the agent that asked for it: what fell, what it adds up to, and what the world's check makes of it. */
+declare function describeRoll(roll: DiceRoll, check?: DiceCheck): string;
+/**
+ * Tools that roll dice for an agent, so that numbers are not made up. `roll_check` rolls a check the story defines and reads
+ * the result with the check's own bands; `roll_dice` rolls plain notation for what has no check. The roller is the system's
+ * source of randomness unless one is given.
+ */
+declare function createDiceTools(resolve: (agentSessionId: string) => DiceLink | undefined, options?: {
+  roller?: Roller;
+  by?: 'agent' | 'player';
+}): 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/calendar.d.ts
+/**
+ * Which days a thing applies on, beyond the days of the week: whole months, a date every year or once, a stretch of dates, the day of the month,
+ * the first or last Monday of a month, a season, and the holidays a world names. A day is told by tokens (`dec`, `12-24`, `1912-09-21..1912-09-22`,
+ * `dom:1`, `nth:mon:1`, `season:winter`, `holiday:founders-day`, `fri`); a token with `!` before it is a day it does not apply on. A list holds on a
+ * day when it names no day to apply on or one of them is today, and none of the days to leave out is.
+ */
+declare const MONTH_NAMES: readonly ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+declare const SEASONS: readonly ["spring", "summer", "autumn", "winter"];
+type Season = (typeof SEASONS)[number];
+type Hemisphere = 'north' | 'south';
+/** A day by the wall clock of the story: the month is 1 to 12 and the weekday 0 (Sunday) to 6. */
+interface CalendarDay {
+  year: number;
+  month: number;
+  day: number;
+  weekday: number;
+}
+interface Holiday {
+  id: string;
+  name: string;
+  /** The days it falls on, as tokens other than `holiday:`. */
+  on: string[];
+}
+interface Calendar {
+  hemisphere: Hemisphere;
+  holidays: Holiday[];
+}
+declare const NO_CALENDAR: Calendar;
+type Parsed = {
+  kind: 'weekday';
+  weekday: number;
+} | {
+  kind: 'month';
+  month: number;
+} | {
+  kind: 'date';
+  year?: number;
+  month: number;
+  day: number;
+} | {
+  kind: 'span';
+  from: {
+    year?: number;
+    month: number;
+    day: number;
+  };
+  to: {
+    year?: number;
+    month: number;
+    day: number;
+  };
+} | {
+  kind: 'dom';
+  day: number | 'last';
+} | {
+  kind: 'nth';
+  weekday: number;
+  n: number | 'last';
+} | {
+  kind: 'season';
+  season: Season;
+} | {
+  kind: 'holiday';
+  id: string;
+};
+/** What a token says, or why it says nothing. */
+declare function parseDayToken(raw: string): {
+  token: Parsed;
+  negated: boolean;
+} | {
+  problem: string;
+};
+/** What is wrong with a list of day tokens, each with where it is. `holidays` are those the world names, when `holiday:` may be used. */
+declare function dayTokenProblems(tokens: readonly string[], path: string, holidays?: ReadonlySet<string> | 'any'): string[];
+/** The season a day is in, by the months of its hemisphere (winter is December to February in the north, June to August in the south). */
+declare function seasonOf(day: Pick<CalendarDay, 'month'>, hemisphere?: Hemisphere): Season;
+/** Whether a list of day tokens holds on a day; tokens that say nothing sensible count as not matching. An empty list holds on every day. */
+declare function dayMatches(tokens: readonly string[], day: CalendarDay, calendar?: Calendar): boolean;
+/** The holidays that fall on a day. A holiday is told by days that are no holidays themselves, so that none can lead back to itself. */
+declare function holidaysOn(calendar: Calendar, day: CalendarDay): Holiday[];
+/** The calendar a story was started with, from its metadata; none when the world has none. */
+declare function readCalendar(metadata: {
+  getValue(key: string): unknown;
+}): Calendar;
+declare const writeCalendar: (metadata: {
+  setValue(key: string, value: never): void;
+}, calendar: Calendar) => void;
+//#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 {
@@ -3260,9 +3633,9 @@ interface Occurrence {
 /** 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;
+declare function occurrenceAt(windows: readonly StoredRoutineWindow[], now: number, zone: string, calendar?: Calendar): 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;
+declare function nextOccurrence(windows: readonly StoredRoutineWindow[], now: number, zone: string, horizon: number, calendar?: Calendar): Occurrence | undefined;
 interface RankedGoal {
   intent: CharacterIntent;
   /** The deadline as an instant, when it has one that can be read. */
@@ -3296,6 +3669,9 @@ declare function agendaAt(source: {
   routines: Pick<RoutineRepository, 'list'>;
   engagements: Pick<EngagementRepository, 'list'>;
   intents: Pick<IntentRepository, 'list'>;
+  metadata?: {
+    getValue(key: string): unknown;
+  };
 }, characterId: CharacterId, now: number, zone: string, options?: AgendaOptions): Agenda;
 //#endregion
 //#region src/sqlite/agenda-repositories.d.ts
@@ -3341,16 +3717,16 @@ declare function zonedInstant(fields: {
  * @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;
+/** `Tuesday 4 October 1912, 21:40`, or `1912年10月4日 星期二 21:40`. */
+declare function describeInstant(instant: number, zone: string, language?: 'en' | 'zh'): 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;
+/** In words and rounded to what matters: `45 seconds`, `3 hours 12 minutes`, `2 days 3 hours`; or `45秒`, `3小时12分钟`, `2天3小时`. */
+declare function describeDuration(milliseconds: number, language?: 'en' | 'zh'): 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;
 /**
@@ -3461,5 +3837,5 @@ type LintTarget = Pick<RecordsTarget, 'characters' | 'locations' | 'placements'
  */
 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, type Delivery, 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, MIGRATION_BACKUP_FOLDER, 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, type Placeholder, 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 RecallWhy, 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, SELF, 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, TEMPLATE_KINDS, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, type TemplateKind, ThreadId, type ThreadRepository, ThreadStatus, TimeChange, TimeChangeFilter, TimeChangeKind, Trigger, TriggerAnnouncement, TriggerAudience, type TriggerClock, TriggerCondition, TriggerDefinition, TriggerEffect, TriggerId, TriggerNote, TriggerNoteKind, type TriggerRun, type TriggerRunOptions, TriggerStatus, UnwritableError, 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, deliverNotes, denseScore, describeDuration, describeHolder, describeInstant, describeValue, finishRecall, fuseScores, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, judgedStatements, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, migrationBackupPath, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, occurrenceAt, openSession, openSessionStore, overlap, parseInstant, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, placeholdersOf, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, renderWords, retention, runTriggers, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemTimeZone, tokens, triggerReferenceProblems, valueIssue, zonedInstant };
+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, type Calendar, type CalendarDay, Character, CharacterControl, CharacterDefinition, CharacterFilter, CharacterId, CharacterIntent, CharacterKind, CharacterMemory, CharacterMemoryPatch, type CharacterMove, CharacterPatch, type CharacterRepository, CharacterRole, CharacterSpeech, CharacterStart, CharacterState, CharacterStatePatch, type CharacterStateRepository, CharacterTier, type CheckRoll, type Clarity, type Clock, ClockMode, ClockState, Comparison, Config, ConflictError, ConsolidationItem, ConsolidationItemId, ConsolidationKind, type ConsolidationRepository, ContainerSpec, ContainerState, CorruptDataError, DAY, DAY_PARTS, DEFAULT_CONFIDENCE, DEFAULT_MEMORY_POLICY, DEFAULT_SLOTS, DICE_COMPARISONS, DICE_READINGS, DICE_RESULTS, type DayPart, type Delivery, DiceBand, DiceCheck, DiceCheckDefinition, DiceCheckId, DiceComparison, type DiceLink, DiceReading, DiceReadout, DiceResult, DiceRoll, DiceRollId, EMOTION_VARIABLES, ENGAGEMENT_GRACE, ENGAGEMENT_STATUSES, EVIDENCE_RELATIONS, EXIT_STATES, type EditChecker, type EditResult, EmbeddingIndexInfo, EmotionStart, EmotionVector, Engagement, EngagementFilter, EngagementId, EngagementPatch, EngagementStatus, EntityKnowledge, type EventEdit, EventId, type EventRepository, EvidenceRelation, 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, type Hemisphere, Holder, Holding, type Holiday, 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, LANGUAGES, LIST_CHECKS_TOOL, LORE_KINDS, LORE_SUBJECT_KINDS, Language, type LintFinding, type LintSeverity, type LintTarget, type LocalTime, Location, LocationDefinition, LocationFeature, LocationId, LocationPatch, type LocationRepository, Lore, LoreDefinition, LoreId, LoreKind, LorePatch, LoreSubject, LoreSubjectDefinition, LoreSubjectKind, MAX_DICE_BANDS, MAX_DICE_CHECKS, MAX_DICE_PER_ROLL, MAX_DICE_SIDES, MAX_DICE_TERMS, MAX_LOCATION_FEATURES, MAX_ROUTINE_WINDOWS, MAX_SHOWN, MAX_TRIGGERS, MAX_VARIABLES, MEMBERSHIP_STATUSES, MEMORY_CONFIDENCES, MEMORY_KINDS, MIGRATION_BACKUP_FOLDER, MINUTE, MONTH_NAMES, MembershipPatch, MembershipStatus, MemoryConfidence, MemoryEvidence, MemoryId, MemoryKind, type MemoryPolicy, type MemoryRepository, MessageValues, type MetadataRepository, Move, type MoveContext, MovePlan, NO_CALENDAR, type NewBelief, NewCharacter, NewCharacterMemory, type NewCharacterSpec, NewCharacterState, NewDiceRoll, 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 Notation, 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, type Placeholder, Placement, type PlacementRepository, type PlainRoll, PlotDefinition, PlotDevelopment, PlotNudgeMode, PlotProgress, PlotStatus, RECALL_ITEM_KINDS, ROLL_CHECK_TOOL, ROLL_DICE_TOOL, type RankedGoal, type RecallCandidate, type RecallEvidence, RecallHit, type RecallIndexRepository, RecallItemKind, type RecallPool, type RecallQuery, type RecallSearch, type RecallSource, type RecallWhy, type Recalled, type RecordsEdit, type RecordsScope, type RecordsTarget, type RecordsView, Relationship, RelationshipDefinition, RelationshipId, RelationshipPatch, type RelationshipRepository, type RelationshipRetraction, type RelationshipSet, RoleplayState, type Roller, RoutineDefinition, RoutineWindow, type RunResult, LATEST_VERSION as SCHEMA_VERSION, SEASONS, SECOND, SELF, SESSION_DATABASE_FILE, SLOT_ID, SUMMARY_LEVELS, SchemaError, type Season, 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, TEMPLATE_KINDS, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, type TemplateKind, ThreadId, type ThreadRepository, ThreadStatus, TimeChange, TimeChangeFilter, TimeChangeKind, Translate, Trigger, TriggerAnnouncement, TriggerAudience, type TriggerClock, TriggerCondition, TriggerDefinition, TriggerEffect, TriggerId, TriggerNote, TriggerNoteKind, type TriggerRun, type TriggerRunOptions, TriggerStatus, UnwritableError, 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, checkProblems, clarityAt, clockTime, conditionHolds, createCharacterTools, createDiceTools, createSession, createSessionStore, createTools, dayMatches, dayPart, dayTokenProblems, deleteSession, deliverNotes, denseScore, describeDuration, describeHolder, describeInstant, describeRoll, describeValue, finishRecall, fuseScores, holidaysOn, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, judgedStatements, languageOf, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, migrationBackupPath, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, notationRange, occurrenceAt, openSession, openSessionStore, overlap, parseDayToken, parseInstant, parseNotation, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, placeholdersOf, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readBands, readCalendar, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, renderWords, retention, rollCheck, rollNotation, rollPlain, runTriggers, seasonOf, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemRoller, systemTimeZone, tokens, translated, translation, translator, triggerReferenceProblems, valueIssue, writeCalendar, zonedInstant };
 //# sourceMappingURL=index.d.ts.map