EN Engine Public API

Public API

Français · Type: reference · Audience: author, contributor · Context: engine repository, created project · Status: ready · Applies from: 4.4.0

The public API · contract: stable · verified by CI (support matrix of 4.4.0, 2026-10-23): Node 22 and 24 on Ubuntu · automated checks: jobs check, external-consumer; CI plan node24, freshInstall; 2 test files · people's passes: none · known limits: none listed on this page

What a game, a host page and a game's own tests may import from the engine: five entry modules and the quest-n-click command. Their names are the contract; everything else under src/engine is internal. The Signatures part at the end is generated from the sources.

The contract

Since 4.0 a game, a host page and a game's tests use the entry modules and the quest-n-click command. Their names are the contract: tests/api-surface.json lists them, tests/api-surface.test.ts fails when one changes without the documentation, and start.stability.md says how a change is made (announced in the CHANGELOG, then removed at the next major version). Everything else under src/engine is internal and may change in any release; the @engine/* alias still reaches it, without that promise.

• In a created project the entries are quest-n-click/content, quest-n-click/player, quest-n-click/minigames, quest-n-click/testing and, since 4.1.1, quest-n-click/reality (the package's exports).
• In the engine repository the same names resolve to src/engine/api/.
• The old names web-scumm/content and the others (before 4.2.5, decision D47) resolved through 4.2.x and are removed in 4.3.0: quest-n-click migrate renames them.
• The save envelope's web-scumm-save and the other format strings of the files are format identifiers from web-scumm, kept so existing saves and files still load.

Each exported name carries one stability tag on its declaration: @public (a name a game or a host calls or reads) or @extension (a contract a game or a host implements, such as a Presenter, a save store or a minigame: a member added to it is a breaking change too). The Signatures tables show it, and list every export: the tables below group the main names by what they are for, and leave some out (the IR and fingerprint helpers such as compileIR, fingerprintGame and the Ir* types, ObjectiveDef, the minigame transcripts, WorldSignalV2).

quest-n-click/content: writing a game

Name	What
defineGame	declares the game (GameDef); with schemaVersion: 3, compiled and frozen
defineRoom	declares a room (RoomDef)
compileGame	the compiled, frozen game a host or a tool runs (defineGame already calls it for schema 3)
GameSource · CompiledGame	a game as written, and as compiled
EMPTY_LAYOUT · FLOOR · NEAR	the layout of a room nobody placed yet, the default floor line, the default "near" distance
GameDef	the whole game: verbs, characters, items, rooms, rules, audio, skin, budgets, migrations, texts
RoomDef	a room: backdrop or stage, props, hotspots, actors, exits, reactions, hints, scripts
Id · Value · Point	an id, a flag's value, a point of the 640 × 400 scene
Cond	a condition ('flag', '!flag', { has }, { flag, eq }, { not }, { all }, { any }…)
Cmd	a command of a reaction or a script (say, set, gain, goto, minigame…)
Who · WalkTarget · ListLine	who speaks, where to walk, a line of a list the engine draws from
Choice · TalkTopic	a dialogue choice, a conversation topic
VerbId · VerbDef	a verb's id, a verb as the interface shows it
Rule · KindRule · EventRule	a written reaction, a reaction by kind, a listener on an emitted event
Action	a player action: verb, a, b
CharacterDef · SpriteSet · MouthSet	a character, its poses, its mouths
ItemDef	an inventory item
PropDef · PropAnim · ActorDef · HotspotDef · ExitDef	what a room holds (each may name the defaultVerb of a double tap, 4.0)
HintDef · ScriptDef	a room's hints, a script of the world
StageDef · StageLayer · LightDef · EmitterDef · TransitionKind	the staged room (layers, lights, particles, transitions)
MapDef · MapRegion · PlaceDef	the travel map
GameRules	rules shared by every room
AudioDef · ScoreDef · ScoreState	music, sounds, voices; a score's stems and which sound when
EndingDef	the sealed ending
RealityDef · SignalDef · RealityState · ExternalEntry	signals from the world outside through a Reality Bridge (4.1.1, bridge.signals-manifest.md): what a game declares, what a save keeps of the link, a signal as a session entry
RevealDef	deprecated (4.0): the old name of EndingDef; removed in 5.0
SkinDef · UiTexts	the interface's images and sounds, its texts
Migration	one step of save migration (renames, drops)
Layout	a room's geometry, written by the placement editor
GameState · Session · SessionEntry	the state a save holds, a replayable session and its inputs (Session.seed, 4.1.14: the run's seed when a host chose it)
SpeedrunManifest · SpeedrunCategory · SpeedrunSplit · SpeedrunTrigger · SemanticTrigger	(4.1.14, create.speedrun.md) GameDef.speedrun: categories (timing, start and finish triggers, saves, pauses, hints, reload, Reality policy, fingerprint components, inputs, seed), splits on semantic events, the rules' version
CustomCommand · CustomCommands · CustomContext	a game's own commands ({ custom }), the escape hatch, and what they receive
VariationManifest · VariationMode · VariationDimension · VariationConstraint · AnchorDef · AnchorRef · CoupledPair · RemixText · parseManifest · variantFlag · REMIX_ALGORITHM_VERSION	(4.1.15, ADR 0018) what may vary between two games of one (GameDef.remix, RoomDef.anchors, create.remix.md), its schema, the reserved flag a dimension writes, the generator's version
compileManifest · CompiledManifest · RemixWorld · catalogue · CATALOGUE_MAX · RemixManifestError	(4.1.15) a manifest compiled against the game (domains, constraints, anchors), a catalogue mode's every world, the build error that lists why a manifest cannot make a world
compileVariant · storyVariant · loadVariant · WorldVariant	(4.1.15) the world a seed makes (GameIR + VariationManifest + seed + algorithmVersion), the story's, a stored one checked and kept as it is
applyVariant · applyStory · ApplyOptions · compileGameManifest · remixWorld	(4.1.15) the game as a world makes it: reserved flags, actors' starts, codes and hints in every text, presentation values
normalizeSeed · encodeSeedCode · isSeed · newSeedCode · STORY_SEED · RemixSeedError	(4.1.15) seed codes WS-XXXX-XXXX (Crockford base32 and a check symbol), the story's seed, an explicit error for a malformed one
generateWheel · checkWheel · wheelProblems · wheelTable · CodeWheel · CodeWheelParams · CodeWheelMode · WheelItem · WheelRecord · CODE_WHEEL_VERSION	(4.1.15, §11.13) the code wheel a seed draws (the copy-protection stream), its single solution, its table, what a played wheel records

quest-n-click/player: starting the game in a page

Name	What
bootGame	starts the game in the page (BootOptions: the game module, the root element, the service worker)
BootOptions · SwModule	its options, the service worker's registration module
Locales · pickLanguage	the translations a game ships, which one a visit gets
openStore · StoreOpener	the save store a page opens (IndexedDB, else localStorage), and how to supply another
SaveStore · SlotStore	the autosave store and the manual slots a host may provide
Presenter	what the engine asks of a front end (a line said, a choice, a walk, a minigame)
AssetManifest	assets.gen.json: the images, their sizes, the audio files
SceneRenderer	the painter contract (the DOM and canvas painters implement it)
SpriteSpec · LayerSpec · OccluderSpec · LightSpec · EmitterSpec · StageSpec	what a painter is given to draw
SceneFrame · Renderer · Intent	(4.1.11) an immutable picture of a room with its precomputed hit polygons, the contract of whatever draws one, and the intentions it answers with: the only thing a renderer sends back (D21)

quest-n-click/minigames: minigames as plugins

Name	What
Minigame	the contract: run(ctx), and what the validator reads (required, textParams, bindings)
MinigameCtx	what a minigame is given: its zone, images, sounds, parameters, labels, an abort signal
minigames	the built-in ones (pipes, stroke, pick, hide, runner, scratch, cables), each loaded when it starts
MINIGAME_CSS	their shared style

A game adds its own in its module's minigames (same contract): that is the plugin format.

How to write one: create.custom-minigame.md.

quest-n-click/testing: a game's own tests

Name	What
Engine	the engine without a page (its members marked @internal are read by the modules of core/ since 4.1.0: not part of the contract). Since 4.1.4: destroy() ends it (loops stopped, waiters released, nothing called back); onError(error, where) hears a script that threw (stopped, scripts[id].off) or a custom command that changed more than it declared; beforeSave(state) shapes what the store writes, onLoad.before/after frame a load; clock is the only time it knows (started, the trace, a session's date)
FakePresenter · MemoryStore	a front end that answers by script, a save store in memory
solve · SolveOptions · SolveResult	the solver: a way to the end, softlocks with prove
parseSave · saveEnvelope · SaveEnvelopeV3	a save's envelope: write it, read it back (migrations applied)
SaveEnvelopeV4 · upgradeEnvelope · SaveWorldMismatch · savedWorld	(4.1.15) the save envelope with its world, the v3 → v4 migration (the story world), the error that names the world a save belongs to, the world a raw save names
worldVerdict · MYSTERY_START_WINDOW_MS · leaderboardKey · REMIX_CATEGORIES · RemixCategoryRules · SpeedrunSeedPolicy · WorldEvidence · seedCommitment · logicalKey	(4.1.15, D26) a run's world checked against its category (Story, Fixed, Random, Mystery, Daily), the leaderboard it goes to, a Mystery commitment, the key a proof certificate is filed under
SemanticEvent · SemanticJournal	(4.1.11) Engine.journal: what happened in the game, in ids, numbered (rooms, items with the player who lost or acquired them, flags, null for a flag removed, a player switch, the ending, loads and saves), emitted by the core alone and the same on a replay
RunClock	(4.1.14, ADR 0016) Engine.runClock: RTA (monotonicNow, never an authority), logicalSteps and logicalTime (bigints, microticks): it observes the core, never writes the state
verifyRun · VerifyContext · SpeedrunVerifyResult · SpeedrunVerdict · isRankable	(4.1.14, ADR 0017) a .wsrun replayed against the approved game: one verdict, a code, a reason, the trust it grants; only valid ranks, inconclusive never does
SpeedrunEnvelope · TrustLevel	(4.1.14) a run's proof (chunks chained from H0, final state hash, final proof, bigints as decimal strings) and how far it is believed (local → replay-valid → server-witnessed → moderator-verified)

quest-n-click/reality: signals from the world outside (4.1.1)

The signed signal and its verification, the client and its HTTP transport, the simulator, the manifest. A game with its own transport implements WorldSignalPort. What a game declares and how a Bridge checks it: bridge.signals-manifest.md.

Name	What
verifySignal · SignalExpectation · VerifyResult · RefusalCode	a signed signal checked before it is read: size, algorithm, key, signature, then game, player, manifest, expiry; a refusal has a code
signSignal · importBridgeKey · BridgeKey · Keyring	signing as a Bridge does (tests, simulators); a Bridge's public key and the set the player trusts
WorldSignalV1 · WorldSignalV1Schema · SignedWorldSignalV1 · MAX_SIGNAL_CHARS	the payload and its schema, the compact JWS that carries it, its size limit
WorldSignalPort	where signals come from: a Bridge's transport, the simulator, a game's own
RealityClient · RealityClientOptions	verify, apply, wait for the durable save, acknowledge
httpPort · HttpPortOptions	the transport to a Bridge: Server-Sent Events read with fetch, or a fetch by cursor
SignalSimulator · Fault · SimulatedDelivery	a Bridge in the browser for the Studio and the tests: delays, duplicates, order, bad signatures, expiry, cuts
realityManifest · manifestHash · RealityManifest	the signals a game declares, as the Bridge checks them, and the hash its configuration keeps
verifyDayToken · verifyCommitment · revealMatches · DayToken · CommitToken · TokenResult	(4.1.15, D26) the daily challenge's signed seed and a Mystery commitment, checked offline with the key of the game's manifest, and a reveal against its commitment

Beside the modules

• Authoring schema: schemaVersion: 3 in defineGame; quest-n-click migrate (in a created project) brings an older game to it.
• Saves: the envelope web-scumm-save schema 3; every save of the 3.x line loads in 4.x (tests/save-v3.test.ts keeps one per release).
• Studio and MCP: the tools of npm run mcp are described by their schemas (studio.mcp-tools.md); their names and their required and optional arguments are in tests/api-surface.json (mcp): a tool removed or a required argument added is an API change like any other.
• Command line: quest-n-click <command> and its options (reference.cli.md).

Signatures

One table per entry, one line per export, read from the sources with the TypeScript compiler (tools/api-doc.ts): the signature (a wider one is cut at 160 characters: the page is a map, the source is the territory), the declared stability, and the first sentence of the declaration's doc comment, in English as the source writes it. To regenerate it, in the engine repository, from its root folder:

# in the engine repository
npm run wiki -- generate engine.api

npm run wiki -- check fails when it is behind the code, or when an export has no description or no stability. npx tsx tools/api-doc.ts (--check to only check) writes it again, as npm run wiki -- generate engine.api does, and tests/api-doc.test.ts checks it.

quest-n-click/content

Name	Signature	Stability	Doc
Action	interface { verb, a, b }	public	A player action: VERB a (with/to b). a can be an inventory item, b is always a target.
ActorDef	interface { defaultVerb, char, interactive, pose, facing, visible, … 1 more }	public	A character standing in a room: which one, its pose and facing, and when it shows.
AnchorDef	interface { at, visible, reachableBy, capacity, phase }	public	A tagged spot of a room where an item can be placed (RoomDef.anchors): the prop or hotspot it stands on (at), when it shows, what it tak
AnchorRef	interface { room, anchor }	public	An anchor named from anywhere: its room and its id in RoomDef.anchors.
ApplyOptions	interface { lang }	public	Options of applyVariant: the language the texts are in.
applyStory	(game: GameDef, o?: ApplyOptions): GameDef	public	The game's story world applied (codes and hints at their story values): what a game without a chosen seed plays.
applyVariant	(game: GameDef, variant: WorldVariant, o?: ApplyOptions): GameDef	public	The game as the world variant makes it: a copy, the reserved flags in start.flags, actors' starting rooms, codes and hints in every text
AudioDef	interface { music, sfx, voices, voicesByLang, scores, maxDecodedMB, … 1 more }	public	The game's music, sounds and voice clips by id, its scores in stems and the transitions between them.
canonicalJson	(v: unknown): string	public	The canonical JSON text of plain data (objects, arrays, strings, numbers, booleans, null, bigints): NFC strings, sorted keys, no -0, big i
catalogue	(c: CompiledManifest, modeId: string): Record<string, unknown>[]	public	Every logical world of a catalogue mode, in a fixed order (the product of its dimensions' domains, the others at their story value, filtered
CATALOGUE_MAX	number	public	The largest catalogue a mode may enumerate (D25): beyond it, the mode is a generator with a published sample.
CharacterDef	interface { name, description, color, height, sprites, portrait, … 11 more }	public	A character: its name, dialogue colour, poses, mouths and portrait, its kinds, and the variants its state selects.
checkWheel	(w: CodeWheel): string[]	public	The wheel's solution, checked the way a player reads it (turn, then read): a solution exists, it is unique (one rotation aligns the pair), a
Choice	interface { id, text, if, once, img, do }	public	One answer the player may pick in a { choice } command: its text, when it is offered, what it runs.
Cmd	type Cmd = union of 56	public	A command. A plain string = the hero says this line. Command lists run in order, each one waiting for the previous one to finish.
CODE_WHEEL_VERSION	number	public	The wheel's layout version: a stored record of another version is replayed as it is, never regenerated.
CodeWheel	interface { version, seed, n, outer, track, inner, … 3 more }	public	A wheel as a seed makes it: the order of each disc, the windows' offsets, the question and its answer.
CodeWheelMode	type CodeWheelMode = 'parody' | 'story' | 'strict' | 'cosmetic' | 'disabled' | 'daily'	public	How the check behaves (§11.13): parody (the default) lets the player through after a few funny refusals.
CodeWheelParams	interface { actors, symbols, answers, mode, tries, seed }	public	What an author writes in { minigame: 'code-wheel', params }.
CodeWheelTranscript	interface { v, wheel, answers, end }	public	What a minigame records so its result can be computed again (4.1.17, D31, ADR 0020): the code wheel's answers, by their place in the list it
CompiledGame	type CompiledGame = Readonly<GameDef>	public	A game as compileGame returns it: normalised and, for schema 3, frozen.
CompiledManifest	interface { manifest, hash, dims, order, anchors, modes }	public	A manifest compiled once: its hash, its dimensions with their domains, its modes.
compileGame	(source: GameSource): CompiledGame	public	Compiles authoring data once into the single normalised representation consumed by the engine and tools. The source is never mutated; genera
compileGameManifest	(game: GameDef): CompiledManifest	public	The game's manifest compiled (an empty one for a game without remix). Throws RemixManifestError.
compileIR	(game: CompiledGame, o: CompileIROptions): GameIR	public	The IR of a compiled game (ADR 0013): pure and deterministic. Rules without an id (v2 content) are named by their position, as the puzzle gr
CompileIROptions	interface { extensions, engine, sources }	public	Options of compileIR: the extensions, the engine's version, and the sources for the provenance.
compileManifest	(manifest: VariationManifest, world: RemixWorld): CompiledManifest	public	Compiles a manifest against the game's world: every reason it cannot produce a world is collected and thrown together (RemixManifestError)
compileVariant	(world: RemixWorld | CompiledManifest, manifest: VariationManifest, seed: string, algorithmVersion?: number, modeId?: string): WorldVariant	public	The world of a seed: GameIR + VariationManifest + seed + algorithmVersion → WorldVariant (ADR 0018). story (the seed or the mode) gives
completionGoal	(game: GameDef): Cond[]	public	The solver's 100% goal (npm run solve -- --goal=100%): the done of every objective that is not optional, all holding at once in one stat
Cond	type Cond = union of 13	public	A condition.
CoupledPair	interface { hint, answer }	public	One coupled pair: the hint the player reads and the answer the content accepts, chosen together or not at all.
CustomCommand	interface { effects, pure, run }	extension	A command a game defines in code: its effects on the state as plain commands, and its browser-only run.
CustomCommands	type CustomCommands = Record<string, CustomCommand>	extension	A game's custom commands by name, as games/<id>/index.ts exports them.
CustomContext	interface { game, state, room, args, ui, scene, … 1 more }	extension	What a custom command's run receives: the game, its state, the room, the arguments, the presenter and the scene element.
defineGame	(game: GameDef): GameDef	public	Declares the full game.
defineRoom	(room: RoomDef): RoomDef	public	Declares a room. Does nothing but type it: autocomplete guides the writing.
EmitterDef	interface { id, kind, image, color, rate, visible }	public	A particle source of the staged room (dust, rain, snow, sparks, smoke, leaves) and its rate.
EMPTY_LAYOUT	Layout	public	Empty layout, when the room hasn't been placed in the editor yet.
encodeSeedCode	(v: number): string	public	A 35-bit value (0 ≤ v < 2^35) as its WS-XXXX-XXXX code.
EndingDef	interface { file, password, guess, scratch, card }	public	Sealed ending (ending module): encrypted content, decrypted at the end of the game and shown on a card.
EventRule	interface { id, on, if, once, do }	public	A listener: when on is emitted ({ emit }) and the condition holds, do runs. once: only the first time.
ExitDef	interface { defaultVerb, name, to, entry, if, locked, … 6 more }	public	A way out of the room, declared rather than written as a hotspot plus a rule. The engine turns it into exactly that (core/define.ts `normali
ExtensionHashes	interface { trusted, commands, minigames, plugins }	public	What compileIR is told of the trusted code: its hash (hashSources over the extension files, given by the build or a tool; '' when unknow
ExternalEntry	interface { id, sequence, signal, source, receivedAt, playerId, … 2 more }	public	What a session keeps of a signal from outside (4.1.1): its id and sequence on the Bridge, the signal, the source and when it arrived. Never
FLOOR	number	public	Default floor bottom (logical y), when the layout doesn't give floor.
GameDef	interface { schemaVersion, id, title, lang, saveVersion, renderer, … 37 more }	public	The whole game as written: verbs, characters, items, rooms, rules, audio, skin, budgets, migrations and texts.
GameIR	interface { schema, engine, gameId, world, rooms, entities, … 7 more }	public	The intermediate representation of a game (schema 1): its logic as plain data, the provenance of its ids, the trusted extensions by name, an
GameRules	interface { fallbacks, kinds, on }	public	The rules shared by every room: fallback responses per verb, reactions by kind, rules valid everywhere.
GameSource	type GameSource = GameDef	public	A game as its sources write it: a GameDef before compilation.
GameState	interface { v, room, inventory, flags, props, actors, … 15 more }	public	The state of a game in progress, serialised as-is in a save: room, inventory, flags, props, actors, counters, scripts.
generateWheel	(p: CodeWheelParams, seed: string, id?: string): CodeWheel	public	The wheel of a seed (the copy-protection stream of <seed>|code-wheel|<id>). Throws on parameters wheelProblems refuses.
HintDef	interface { id, until, lines }	public	A hint the hint item gives while its until condition is false, as lines said in order.
HotspotDef	interface { defaultVerb, name, kind, visible, exit, onTap }	public	A named zone of the room the player can act on; its geometry lives in the layout.
Id	type Id = string	public	An identifier in the content (a room, an item, a flag, a character, a prop…): a plain string the game chooses.
IrEntity	interface { key, kind, id, room, name, kinds, … 12 more }	public	A thing of the game: a prop, an actor or a hotspot of a room, an item, a character.
IrExtensions	interface { trusted, commands, minigames, plugins }	public	The trusted code a game names (ADR 0002): custom commands with their declared effects, minigames, plugins.
IrObjective	interface { id, title, done, optional, parent }	public	An objective (ADR 0014): its title, the condition that completes it, whether 100% needs it, its parent.
IrRealityPolicies	type IrRealityPolicies = Omit<RealityDef, 'bridge'>	public	What the game declares of the world outside, its Bridge's address left out (deployment, not logic).
IrRoom	interface { id, name, hero, look, hints, exits, … 3 more }	public	A room as logic: its name, looks, hints, exits and the conditions of its walk links; its entities by key.
IrRule	type IrRule = union of 5	public	A reaction of the game: a written rule, a topic, a listener, a reaction by kind or a verb's fallback lines.
IrScript	interface { id, scope, trigger, while, loop, do, … 1 more }	public	A sequence of commands that runs without a player's action: a world script, a room's arrival, the intro.
IrSource	interface { file, line }	public	Where an id is written: a file relative to the working directory, and its line (from 1).
IrVariantSlot	interface { mode, id, manifest, variant }	public	A world variant of the story (4.1.15 "Remix", ADR 0018): filled when the game was compiled from an instance (applyVariant): id is the va
IrWorld	interface { schemaVersion, saveVersion, hero, players, hintItem, hintVoice, … 8 more }	public	The game's world: its hero and players, verbs, start, map, checkpoints, invariants, saves.
isSeed	(input: string): boolean	public	Whether a string is a well-formed seed (a code with its check symbol, or story).
ItemDef	interface { name, icon, look, kind }	public	An inventory item: its name, its icon, its look lines and its kinds.
KindRule	interface { id, verb, kind, target, item, say }	public	Reaction by "kind": applies to anything with this kind (e.g. person, cat), before fallback responses. target targets a specific id (
Layout	interface { width, floor, walk, scale, entries, hotspots, … 8 more }	public	A room's geometry, written by the placement editor: walk areas, entries, and where every hotspot, prop, actor, layer and light stands.
LightDef	interface { id, kind, color, intensity, blend, visible }	public	A light of the staged room: a radial pool at its layout position, or an ambient colour over the whole room.
ListLine	type ListLine = string | { id: Id; text: string; }	public	One line of a list the engine draws from (a look list, a hint, the fallback answers): a plain string, keyed by its position in translations,
loadVariant	(c: CompiledManifest, input: unknown): { variant: WorldVariant; stale: boolean; }	public	A stored variant (a save's, a session's, a speedrun's) checked and kept as it is: its hash must match its content; it is never regenerated,
logicView	(ir: GameIR): Omit<GameIR, "engine" | "provenance">	public	The part of the IR the fingerprint's logic hashes: everything but the engine's version, the provenance (a line added above a rule moves no
MapDef	interface { regions, start, places, music, vehicles }	public	The travel map: its regions, its places and the region shown first.
MapRegion	interface { name, image, parent, frame }	public	A region of the travel map: its image, its parent region and its frame on it.
Migration	interface { from, renameFlag, renameItem, renameRoom, renameProp, renameActor, … 12 more }	public	One step of save migration: from version from to from + 1. Keys are old ids, values new ones.
MinigameOutcome	interface { result, transcript }	public	A minigame's result and, when it can prove it, its transcript (4.1.17).
MinigameResult	type MinigameResult = 'won' | 'passed' | 'skipped' | 'failed' | 'disabled'	public	How a minigame that says so ended (4.1.16): won, let through (passed, a parody's mercy), skipped, lost (failed, the story goes on with i
MinigameTranscript	type MinigameTranscript = CodeWheelTranscript	public	A minigame's transcript (4.1.17: the code wheel's only).
MouthSet	interface { closed, open, blink, smile }	public	Mouth images for a pose: the body doesn't move while speaking, only the mouth changes. closed replaces the idle pose's image (t1), open
NEAR	number	public	Distance (logical units) beyond which a saved approach point is considered stale and recomputed.
newSeedCode	(): string	public	A fresh code from WebCrypto (the Remix button). No WebCrypto: an error, never a guessable draw.
normalizeSeed	(input: string): string	public	The canonical form of a typed code (ws-abcd-efgh, WSABCDEFGH, with I/L/O read as digits), or a RemixSeedError that says what is
ObjectiveDef	interface { title, done, optional, parent }	public	An objective of the game (4.1.12, ADR 0014): its title in the quest journal, the condition that completes it, whether 100% needs it, and the
parseManifest	(input: unknown): VariationManifest	public	A manifest checked against its schema (a malformed one is an error naming the path).
PlaceDef	interface { name, room, region, pos, portrait, joins, … 2 more }	public	A place on the travel map: the room it opens, its region and position, its vehicle and its news marker.
Point	type Point = [number, number]	public	Logical coordinates of a backdrop: 640 × 400, origin top-left.
PropAnim	interface { frames, fps, loop, at }	public	A prop animation: images in order at fps (default 8); at = commands run when a frame is reached (index).
PropDef	interface { defaultVerb, img, states, anims, initial, name, … 2 more }	public	A prop in the scenery, with states (e.g. amp off/on). Its position comes from the layout.
provenanceOf	(ir: GameIR, sources: Readonly<Record<string, string>>): Record<string, IrSource>	public	Where each id of the IR is written in the sources (path → text), read from their object-literal keys (core/source-keys.ts: strings and comme
RealityDef	interface { signals, bridge, connectors }	public	The game's link to the world outside: the signals it declares and the Reality Bridge it pairs with.
RealityState	interface { playerId, cursor, applied }	public	What a save keeps of the link (GameState.reality): no token, no email, no payload.
REMIX_ALGORITHM_VERSION	number	public	The generator's version: bumped when a single assignment of a given seed would change (ADR 0018).
RemixManifestError	class RemixManifestError	public	A manifest that cannot produce a world: a build error, with every reason.
RemixSeedError	class RemixSeedError	public	A seed refused: malformed, a wrong check symbol, an unknown algorithm version.
RemixText	type RemixText = string | Readonly<Record<string, string>>	public	A text in the game's language, or one per language ({ en, fr }): what a coupled hint shows.
remixWorld	(game: GameDef): RemixWorld	public	What the compiler reads of a game definition: its rooms' anchors and every rule with an id.
RemixWorld	interface { rooms, rules }	public	What the compiler reads of the game: its rooms' anchors and its rules (a GameIR is one).
RevealDef	type RevealDef = EndingDef	public (deprecated)	The old name of EndingDef.
RoomDef	interface { id, name, decor, description, furniture, music, … 15 more }	public	A room: its backdrop or stage, props, actors, hotspots, exits, look lines, reactions, topics, hints and scripts.
Rule	interface { id, verb, a, b, if, do, … 1 more }	public	A written reaction: "when VERB is done on A (with/to B), if CONDITION, then …". a and b accept a list: the rule works with any of them.
ScoreDef	interface { stems, bpm, beatsPerBar, loop, states, quantize, … 4 more }	public	A score in stems: its files, its tempo and loop, and which stems sound in each game state.
ScoreState	interface { if, stems }	public	Which stems sound in a given state: the first entry whose condition holds wins (if absent: always).
ScriptDef	interface { id, while, loop, do, stepIds }	public	A script of the world: it runs on its own, without a player action, one command at a time, in the gaps between the player's actions (never d
SemanticTrigger	interface { event, room, item, flag, value, objective, … 3 more }	public	A semantic trigger: the first event of this kind (and these fields, when given) in the run's journal. A room entered, an item acquired or lo
Session	interface { v, start, base, log, at, seed, … 1 more }	public	A player's inputs since the game started or a save was loaded, with the state they started from: enough to replay them.
SessionEntry	type SessionEntry = union of 9	public	One input of a session (Engine.session). The answers given while it ran (picks, maps, rnd) are what makes it replayable; ran lists
SignalDef	interface { id, source, availability, replay, once, fallback }	public	A signal the game may receive from the world outside: its id, source, availability, replay mode and fallback.
SkinDef	interface { icons, sounds, fonts, heights, callPoses, pixelArt }	public	UI skin: everything the engine shows or plays without the content referencing it. Image ids come from the manifest; sounds are ids from `aud
SpeedrunCategory	interface { id, name, timing, start, finish, allowSaves, … 8 more }	public	A speedrun category: what counts as a run, how it is timed, what it may do. timing names the time it is ranked on: rta (the wall clock,
SpeedrunManifest	interface { categories, splits, rulesVersion }	public	The game's speedrun manifest (GameDef.speedrun): categories, splits, and the version of the rules (a change never silently requalifies an
SpeedrunSplit	interface { id, name, at, parent }	public	A split: a semantic trigger, a name, and the split it is a step of.
SpeedrunTrigger	type SpeedrunTrigger = SemanticTrigger	public	A category's start or finish: a semantic trigger.
SpeedrunWorldPolicy	interface { policy, mode, fixedSeed, codeWheel }	public	Which world a category's runs are played in (4.1.16, D29, ADR 0019): story (no logical variation), fixed (the published fixedSeed), `r
SpriteSet	type SpriteSet = Record<string, Id[]>	public	A set of images for a character: pose → list of images (looped).
StageDef	interface { layers, lights, emitters, transition, links }	public	What a room shows beyond its backdrop: layers, lights, particles, its transition and the logic of its walk links.
StageLayer	interface { id, image, role, visible }	public	A picture of the room: backdrop behind everything, scenery among the characters (depth from its layout z), foreground in front of th
STORY_SEED	string	public	The seed of the author's world: no variation, every dimension at its story value.
storyVariant	(manifest: VariationManifest | undefined, world: RemixWorld): WorldVariant	public	The story world of a game: every dimension at its story value (an empty manifest gives an empty assignment).
TalkTopic	interface { id, topic, if, do }	public	A conversation topic offered when talking to an actor: its line, when it is offered, what it runs.
TransitionKind	type TransitionKind = 'cut' | 'fade' | 'wipe'	public	How a room appears when entered: a cut, a fade or a wipe.
UiTexts	interface { walkTo, newGame, continue, confirmErase, yes, no, … 84 more }	public	Every text the interface shows (menus, confirmations, settings), so a game speaks its own language.
Value	type Value = boolean | number | string	public	What a flag holds: a boolean, a number or a string.
variantFlag	(dimension: string, group?: string): string	public	The reserved flag a logical dimension writes (remix.<id>; a puzzle order writes remix.<id>.<group>).
VariationConstraint	type VariationConstraint = union of 3	public	A constraint between dimensions: exclusive (no two of them take the same value), requires (a and b are <dimension>=<value>: when `
VariationDimension	type VariationDimension = union of 6	public	A dimension: what varies and its finite domain. Logical dimensions are in the solver's space (each instance is proved); presentation ones
VariationManifest	interface { schema, algorithm, modes, dimensions, constraints, daily }	public	What a game lets vary (GameDef.remix), schema 1, algorithm web-scumm-remix-1. daily names the Bridge key a daily challenge is signed w
VariationMode	interface { id, strategy, dimensions, mask }	public	A mode of play: which dimensions vary (the others keep their story value) and the strategy that backs it (D25): catalogue (every instance
VerbDef	interface { id, label, color, join, key }	public	A verb as the interface shows it: its id, its label, its colour and the joining word of a two-term sentence.
VerbId	type VerbId = string	public	Verb id, free-form: the game's own verbs declare them. Four ids have meaning to the engine: look ("Look" text for rooms and items), `tal
WalkTarget	type WalkTarget = Id | Point	public	Target of a move: a hotspot, an actor or a prop in the room (its approach point), or a point.
WheelItem	interface { id, label, img }	public	One item of a disc: its id, its name (said to a screen reader, printed), its image (a sprite, a portrait).
wheelProblems	(p: Partial<CodeWheelParams>): string[]	public	Everything wrong with a wheel's parameters (the validator's check); empty when it can be built.
WheelRecord	interface { seed, version, wheel, mode, rotations, answers, … 2 more }	public	What a played wheel records for a replay and a speedrun (§11.13).
wheelTable	(w: CodeWheel): { actor: string; symbol: string; answer: string; }[]	public	The full table the wheel encodes: for each actor and symbol, the answer (the accessible list, the booklet).
Who	type Who = Id	public	Who speaks or acts. 'hero' always designates the hero, whatever their id.
WorldVariant	interface { seed, algorithm, algorithmVersion, manifestHash, mode, assignments, … 1 more }	public	One world instance: the seed it came from, the algorithm and its version, the manifest's hash, the mode, one value per dimension, and the ha

quest-n-click/player

Name	Signature	Stability	Doc
AssetManifest	interface { images, audio, videos }	public	Catalogue of images and sounds prepared by npm run assets.
bootGame	(o: BootOptions): Promise<App>	public	Boots the game in the page and returns the App (after the title screen is shown, or the dev tools started).
BootOptions	interface { game, layouts, manifest, minigames, commands, locales, … 9 more }	public	What bootGame starts the game with: the game, its layouts and manifest, minigames, commands, locales, root, store, service worker, and the
EmitterSpec	interface { id, kind, url, color, rate, area, … 1 more }	extension	A particle source, resolved for the painter: its kind, image, colour, rate and area.
Intent	type Intent = union of 5	extension	What a renderer sends the engine's side: the only thing it may (D21). A tap on a target with the verb the player chose (act, with item w
LayerSpec	interface { id, url, role, x, y, w, … 6 more }	extension	A stage layer, resolved: its image, its box in the room (logical units, before parallax), its depth and look.
LightSpec	interface { id, kind, color, intensity, blend, at, … 2 more }	extension	A light, resolved for the painter: its kind, colour, intensity and blend, and for a radial one its centre and radius.
Locales	type Locales = Record<string, Record<string, string>>	public	The translations a game ships, by language then by text path (locales/<lang>.json).
OccluderSpec	interface { id, z, polygon, mask, layer, feather, … 1 more }	extension	What hides a character deeper than z: the backdrop's pixels (or a layer's) inside a polygon, a mask image or a layer's alpha.
openStore	(game: GameDef, open?: StoreOpener): Promise<{ store?: SaveStore; attach: (app: App) => void; }>	public	Opens the verified store and keeps its early errors and warnings until an App can show them. Without IndexedDB the App's verified localStora
pickLanguage	(_written: GameDef, locales: Locales | undefined, o?: { query?: string | null; stored?: string | null; navigatorLang?: string; }): string | undefined	public	?lang=, then the player's saved choice, then the browser's language when the game ships it.
Presenter	interface { enterRoom, say, walk, face, pose, anim, … 21 more }	extension	What the core asks the display for. The DOM renderer implements it for the browser, FakePresenter implements it for node (tests, solver). Al
Renderer	interface { mount, render, onIntent, unmount }	extension	A renderer: mounted in an element, given frames, it tells its intentions. The DOM and Canvas painters are wrapped as one (dom/frame-renderer
SaveStore	interface { load, save, clear, whenIdle }	extension	The autosave store a host provides: load, save, clear, and when the latest write is durable.
SceneFrame	interface { hash, room, camera, layers, actors, hotspots, … 2 more }	extension	A room as it is to be drawn: immutable, in logical units. hash digests the rest: a renderer skips a frame equal to the last one.
SceneRenderer	interface { el, reset, sprite, camera, resize, stage, … 1 more }	extension	The painter contract: a surface, sprites and a stage to draw, a camera to follow; the DOM and canvas painters implement it.
SlotStore	interface { listSlots, getSlot, putSlot, clearSlot }	extension	Manual save slots (GameDef.saves.slots), durable and verified like the autosave. Numbered from 1.
SpriteSpec	interface { id, url, fx, fy, w, h, … 9 more }	extension	One thing drawn in the scene, in logical units. fx, fy: its feet (bottom centre), the pivot of rotations.
StageSpec	interface { backdrop, layers, occluders, lights, emitters, reduceMotion }	extension	Everything a room shows besides its sprites (RoomDef.stage, normalized by stageOf, conditions evaluated by the model).
StoreOpener	type StoreOpener = (game: GameDef, fail: (e: Error) => void, warn: (m: string) => void) => Promise<SaveStore>	extension	How a host supplies the save store openStore opens, in place of the verified IndexedDB one.
SwModule	interface { registerSW }	extension	registerSW of virtual:pwa-register (vite-plugin-pwa), injected so the engine never imports a virtual module.

quest-n-click/minigames

Name	Signature	Stability	Doc
Minigame	interface { run, required, textParams, bindings }	extension	A minigame: run(ctx) until it is won or skipped, and what the validator reads of its params.
MINIGAME_CSS	string	public	The shared styles of the minigames, injected once by the host.
MinigameCtx	interface { root, u, img, size, sfx, instruct, … 5 more }	extension	What the host hands a minigame: its zone, the unit scale, images and sounds, parameters, labels and an abort signal.
minigames	Record<string, Minigame>	public	Minigames provided by the engine. A game can add others with the same interface. What tools read (required, textParams, bindings) is h

quest-n-click/testing

Name	Signature	Stability	Doc
categoryWorld	(cat: Pick<SpeedrunCategory, "seed" | "world">): { world: SpeedrunWorldPolicy; deprecated: boolean; }	public	The world of a category (4.1.16, D29): its world, else what a 4.1.15 seed meant (daily, mystery: that mode's worlds), else the story
Engine	class Engine	public	The engine without a page: it runs a game against a Presenter and a SaveStore, in the browser, in node tests and in the solver.
FakePresenter	class FakePresenter	public	Silent presenter for node: everything finishes immediately, and everything is logged to log.
fingerprint	(ir: GameIR, o: { presentation: unknown; engine: string; }): Promise<GameFingerprint>	public	The fingerprint of a game from its IR, its presentation (presentationOf) and its engine's version.
fingerprintGame	(game: GameDef, o: { manifest?: unknown; extensions: ExtensionHashes; engine: string; }): Promise<GameFingerprint>	public	A game's fingerprint from its sources as written (before a translation): compiled, its IR made, its presentation read with the manifest. Wha
GameFingerprint	interface { logic, trustedExtensions, presentation, engine }	public	A game's fingerprint: SHA-256 in hex of its logic, its trusted extensions, its presentation and its engine (an empty trustedExtensions whe
hashSources	(files: Readonly<Record<string, string>>): Promise<string>	public	SHA-256 of a set of source files (path → text) through their canonical text: the trusted extensions' hash.
isRankable	(v: SpeedrunVerdict): boolean	public	Whether a verdict may be ranked on a leaderboard.
leaderboardKey	(categoryId: string, rules: RemixCategoryRules | SpeedrunWorldPolicy, v: WorldVariant): string	public	The leaderboard a run goes to: its category, and for a Fixed or a Daily its seed (a Daily's seed names its day). Random and Mystery rank eve
logicalKey	(c: CompiledManifest, v: WorldVariant): string	public	A key for proofs: two variants with the same logical world share a proof certificate.
MemoryStore	class MemoryStore	public	A save store in memory, for the tests and the solver: nothing survives the process.
MYSTERY_START_WINDOW_MS	number	public	How long a Mystery run may start after its seed was first revealed (D26, after the second reading): the client must build the world to play
parseSave	(game: GameDef, input: unknown, opts?: ParseSaveOptions): GameState	public	Parses an envelope (or a legacy raw state). Structural corruption and references needed to resume (the current room and active player) are r
presentationOf	(game: CompiledGame | GameDef, manifest?: unknown): unknown	public	What the fingerprint's presentation hashes: the asset manifest, and every field core/ir-fields.ts classes as presentation (whole) or both
REMIX_CATEGORIES	Readonly<Record<string, RemixCategoryRules>>	public	The five categories a Remix game offers by default.
RemixCategoryRules	interface { seed, mode, fixedSeed, codeWheel }	public	What a speedrun category says of the world, as 4.1.15 wrote it (seed for the policy). Kept for the frozen surface (D28); `SpeedrunWorldPol
RunClock	interface { monotonicNow, logicalSteps, logicalTime }	public	A run's three clocks: monotonicNow the host's monotonic milliseconds (RTA: never reproducible, never an authority), logicalSteps one per
runSeedPolicy	(cat: Pick<SpeedrunCategory, "seed">): "fixed" | "random"	public	The run's generator (D29): fixed only when the category says so; anything else is a fresh seed per run.
savedWorld	(input: unknown): WorldVariant | undefined	public	The world a raw save names (a v4 envelope, a slot record holding one), or undefined (v3, a raw state).
saveEnvelope	(game: GameDef, state: GameState, now?: number): SaveEnvelopeV4	public	Wraps a state in the save envelope a store writes (v4: format, schema, game id and save version, date, and the world the game is played in).
SaveEnvelopeV3	interface { format, schema, gameId, gameSaveVersion, savedAt, state }	public	A save as written until 4.1.14: the state with the format, the schema, the game's id and save version and the date.
SaveEnvelopeV4	interface { format, schema, gameId, gameSaveVersion, savedAt, state, … 1 more }	public	A save as written since 4.1.15 (ADR 0018): the v3 envelope and the WorldVariant the game was played in, so that a load rebuilds the same w
SaveWorldMismatch	class SaveWorldMismatch	public	A save made in another world than the game it is loaded into (another seed, another mode): the caller rebuilds the game with `applyVariant(g
seedCommitment	(seed: string, nonce: string): string	public	The commitment to a Mystery seed (D26): SHA-256 of the seed and a nonce, published (signed) before the start.
SemanticEvent	type SemanticEvent = union of 8	public	One thing that happened in the game, numbered (seq, from 1, contiguous). An item handed between players (transfer) is lost by one and ac
SemanticJournal	interface { seq, subscribe, since }	public	What a host reads of the journal (Engine.journal): the last sequence number, a subscription, the events after a sequence (within the windo
sha256Hex	(text: string): Promise<string>	public	SHA-256 of a text's UTF-8 bytes, in hex, with WebCrypto.
shortFingerprint	(f: GameFingerprint): string	public	The short form the pause menu shows: the first eight hex digits of each component (???????? for an unknown one).
solve	(gameIn: GameDef, layouts: Record<string, Layout>, opts?: SolveOptions): Promise<SolveResult>	public	Searches the game for a way to its ending (witness), or explores every reachable state for softlocks (prove).
SolveOptions	interface { reality, maxStates, mode, start, goal, commands, … 21 more }	public	What a search is told: its mode, where it starts and stops, the custom commands, the world's signals and its budgets.
SolveResult	interface { status, exit, headline, mode, reality, finished, … 20 more }	public	The verdict of a search: its status, exit code and headline, the path found, the softlocks and the search's statistics.
SpeedrunEnvelope	type SpeedrunEnvelope = SpeedrunEnvelopeV1 | SpeedrunEnvelopeV2	public	A .wsrun file: the proof of one speedrun (schema 1 read, schema 2 written).
SpeedrunEnvelopeV1	interface { schema, seed, format, gameId, fingerprint, engineVersion, … 14 more }	public	A .wsrun file of 4.1.14 and 4.1.15 (schema 1): its seed is the run's, its world the story world.
SpeedrunEnvelopeV2	interface { schema, runSeed, variant, worldEvidence, format, gameId, … 16 more }	public	A .wsrun file since 4.1.16 (schema 2, ADR 0019): the run's generator seed and the exact world it was played in, with what that world rests
SpeedrunSeedPolicy	type SpeedrunSeedPolicy = SpeedrunWorldPolicy['policy']	public	How a category picks its world.
SpeedrunVerdict	type SpeedrunVerdict = union of 8	public	A verifier's verdict (ADR 0017). Only valid ranks; inconclusive is never valid.
SpeedrunVerifyResult	interface { verdict, code, reason, trust, world, recomputed }	public	What a verifier answers: the verdict, a stable code, one sentence, and the trust it grants.
SpeedrunWorldEvidence	type SpeedrunWorldEvidence = { kind: 'daily'; token: string; } | { kind: 'mystery'; commitmentToken: string; revealToken: string; startedAt: number; }	public	What a Daily or a Mystery world rests on (4.1.16, ADR 0019): the Bridge's signed tokens, as received. A Daily run carries the day's token; a
TrustLevel	type TrustLevel = 'local' | 'replay-valid' | 'server-witnessed' | 'moderator-verified'	public	How far a run is believed (ADR 0017): raised only by someone other than the player's client.
upgradeEnvelope	(game: GameDef, env: SaveEnvelopeV3 | SaveEnvelopeV4): SaveEnvelopeV4	public	A v3 envelope as a v4 one (the save migration of 4.1.15): every save made before Remix was played in the story world, so it receives the gam
VerifyContext	interface { game, layouts, commands, fingerprint, engineVersion, keyring, … 3 more }	public	The approved game a run is checked against: its content, layouts, fingerprint, engine, the Bridge's keys.
verifyRun	(input: unknown, ctx: VerifyContext): Promise<SpeedrunVerifyResult>	public	Verifies a run (.wsrun text or object) against the approved game: never throws, every failure is a verdict.
WorldEvidence	interface { dailySeed, commitment, reveal, revealedAt, runStartedAt }	public	What a run's world must match, given the category and what the Bridge published (the day's seed, a commitment).
worldVerdict	(rules: RemixCategoryRules | SpeedrunWorldPolicy, v: WorldVariant, e?: WorldEvidence): string[]	public	Whether a run's world is the one its category allows: empty when it is, else the reasons (a verifier refuses the run with them). The world i

quest-n-click/reality

Name	Signature	Stability	Doc
BridgeKey	interface { kid, key, notBefore, notAfter, tenantId, environment, … 1 more }	public	One verification key of the Bridge: its id, the key, and when it may sign (epoch ms; rotation overlaps).
CommitToken	type CommitToken = { format, v, id, gameId, mode, commitment, … 1 more }	public	What a Mystery commitment says.
DayToken	type DayToken = { format, v, gameId, date, seed, mode, … 3 more }	public	What a day token says.
Fault	interface { delayMs, duplicate, badSignature, expired }	public	What the simulator does wrong on purpose with one delivery: a delay, a duplicate, a bad signature, an expiry.
httpPort	(o: HttpPortOptions): WorldSignalPort	public	The transport to a Bridge, as a WorldSignalPort: Server-Sent Events read with fetch, or a fetch by cursor.
HttpPortOptions	interface { url, capability, fetch, retryMs, mode, onStatus, … 3 more }	public	How httpPort reaches a Bridge: its URL, the pairing's capability, the fetch to use, the retry delay and the mode.
importBridgeKey	(kid: string, raw: string, window?: Omit<BridgeKey, "kid" | "key">): Promise<BridgeKey>	public	An Ed25519 public key from its 32 raw bytes in base64url (a manifest's or a Bridge's configuration).
Keyring	type Keyring = BridgeKey[]	public	The Bridge's verification keys the player trusts (several during a rotation).
manifestHash	(m: RealityManifest): Promise<string>	public	The manifest's hash: SHA-256 of its JSON (keys in this fixed order), hex.
MAX_SIGNAL_CHARS	number	public	The largest signed signal accepted, in characters: a signal is an identifier, not a document.
RealityClient	class RealityClient	public	The player's side of the Reality Bridge: reads signed signals from a port, verifies each, hands it to the engine, waits for the durable save
RealityClientOptions	interface { engine, store, port, keyring, refreshKeys, playerId, … 7 more }	public	What a RealityClient is built with: the engine, the store, the port, the keyring, and how it refreshes keys and reports.
realityManifest	(game: GameDef): RealityManifest | null	public	The manifest of a game that declares reality, null otherwise.
RealityManifest	interface { format, schema, gameId, signals, connectors }	public	A game's Reality manifest: the signals it declares, with no secret, as the Bridge checks them.
RefusalCode	type RefusalCode = union of 14	public	Why a signal was refused, as a code (the conformance corpus and the Rust cross-check compare codes) and a sentence.
revealMatches	(c: CommitToken, reveal: { seed: string; nonce: string; }): boolean	public	Whether a reveal (seed, nonce) is the one a verified commitment hid.
SignalEnvironment	type SignalEnvironment = 'prod' | 'staging' | 'dev'	public	Where a Bridge runs, as a signal names it (4.1.10): a signal of one environment is refused by another.
SignalExpectation	interface { gameId, playerId, signals, now, versions, tenantId, … 3 more }	public	What a signal must match besides its signature.
SignalSimulator	class SignalSimulator	public	A Bridge in the browser, for the Studio and the tests: signs and delivers a game's signals, with faults on demand.
SignedWorldSignalV1	type SignedWorldSignalV1 = string	public	A signed signal as it travels: the compact JWS string.
signSignal	(payload: WorldSignal, key: CryptoKey, kid: string): Promise<SignedWorldSignalV1>	public	Signs a payload as the Bridge does (the Bridge, the tests, the Studio's simulator).
SimulatedDelivery	interface { sequence, signal, fault, at }	public	One delivery the simulator made: its sequence, its signal, its fault and when.
TokenResult	type TokenResult = { ok: true; token: T; } | { ok: false; reason: string; }	public	A verified token, or why it is refused.
verifyCommitment	(jws: string, key: BridgeKey, gameId: string): Promise<TokenResult<CommitToken>>	public	Checks a Mystery commitment's signature and game.
verifyDayToken	(jws: string, key: BridgeKey, gameId: string, now: number | null): Promise<TokenResult<DayToken>>	public	Checks a day token offline: the signature (the game's daily key), the game, the window (24 hours), a well-formed seed. now in epoch ms; `n
VerifyResult	type VerifyResult = { ok: true; signal: WorldSignal; } | { ok: false; code: RefusalCode; reason: string; }	public	The outcome of verifySignal: the signal it accepted, or the refusal's code and reason.
verifySignal	(jws: unknown, keyring: Keyring, expect: SignalExpectation): Promise<VerifyResult>	public	Checks a signed signal, then what it says. The reason of a refusal is a short sentence (logged, never shown raw).
WorldSignal	type WorldSignal = WorldSignalV1 | WorldSignalV2	public	Either version of the signed payload.
WorldSignalPort	interface { connect, acknowledge, close }	extension	Where signals from the world outside come from (4.1.1, Reality Bridge): the Bridge's transport (Server-Sent Events, a fetch by cursor), or t
WorldSignalV1	type WorldSignalV1 = { schema, format, id, sequence, gameId, playerId, … 8 more }	public	The signed payload, as WorldSignalV1Schema types it.
WorldSignalV1Schema	z.ZodMiniObject<{ schema: z.ZodMiniLiteral<1>; format: z.ZodMiniLiteral<"web-scumm-world-signal">; id: z.ZodMiniString<string>; sequence: z.ZodMiniInt; gameId:	public	The payload the Bridge signs: one accepted fact from outside, as a finite identifier (§4.1).
WorldSignalV2	type WorldSignalV2 = { schema, tenantId, environment, audience, sessionId, keyId, … 13 more }	public	The signed payload of 4.1.10, as WorldSignalV2Schema types it.
WorldSignalV2Schema	z.ZodMiniObject<{ schema: z.ZodMiniLiteral<2>; tenantId: z.ZodMiniString<string>; environment: z.ZodMiniEnum<{ prod: "prod"; staging: "staging"; dev: "dev"; }>;	public	The payload of 4.1.10 (ADR 0010): V1's fields and the context it was signed for, so a signal of one tenant, one environment, one origin, one

---

Edit the source of this page · Report an error