@game-infra/game-state-schemas 0.1.0

package/dist/freeformPayloads.d.ts

@@ -0,0 +1,368 @@
+import { type InferOutput } from "valibot";
+/**
+ * What goes inside a session's `data` and its journal entries' for **freeform
+ * mode**: play that follows the player's own words instead of authored
+ * branches.
+ *
+ * Where story mode stores a tree of beats addressed by the choices taken to
+ * reach them, freeform mode stores a linear journal of **turns**. Each turn
+ * records what the player wrote, what the narrator answered, the skill check
+ * that was rolled (if the attempt warranted one), the state effects that
+ * followed — the same `ActivationDTO` vocabulary a story branch carries — and
+ * the **memories** the turn left behind. Replaying the journal from the start
+ * rebuilds the whole session state, so nothing beyond the journal is stored.
+ *
+ * Memories are organised as a *synapse graph*: every remembered fact connects
+ * to one or more **neurons** — a character, a faction, a location, or a domain
+ * such as war or romance — and recall walks those connections rather than the
+ * whole journal. Old memories are **consolidated**: several small entries
+ * connected to the same neuron collapse into one summary, the way five small
+ * grievances become "many past grievances". A consolidation is recorded on the
+ * turn that performed it, so replay compresses exactly as play did.
+ *
+ * None of this is attached to any endpoint — `game-state-service` stores `data`
+ * as an opaque string, the same way `game-content-service` stores authored
+ * design content — but two clients reading the same session must agree on the
+ * shapes, so they live here.
+ *
+ * They live in *this* package rather than `@game-infra/story-schemas` because a
+ * journal is not design. A world and its cast are authored once and read by
+ * every player; a session's turns belong to one player, change every turn, and
+ * are deleted with the run.
+ */
+/** Separator inside a neuron id, between its kind and the entity it names. */
+export declare const NEURON_KEY_SEPARATOR = ":";
+/**
+ * The id of a neuron: its kind, then the id it wraps.
+ *
+ * Entity neurons wrap a design id (`character:tallow`, `faction:ash-wardens`);
+ * domain neurons wrap a domain name (`domain:war`). Keeping the kind in the id
+ * is what lets a memory's `neuronIds` list mix people and themes freely.
+ *
+ * @example
+ * ```ts
+ * import { neuronKey } from '@game-infra/game-state-schemas'
+ *
+ * neuronKey('character', 'tallow') // 'character:tallow'
+ * neuronKey('domain', 'war') // 'domain:war'
+ * ```
+ */
+export declare function neuronKey(kind: string, id: string): string;
+/**
+ * The kind and wrapped id a neuron key encodes. The inverse of
+ * {@link neuronKey}; a key with no separator reads as a bare domain.
+ *
+ * @example
+ * ```ts
+ * import { parseNeuronKey } from '@game-infra/game-state-schemas'
+ *
+ * parseNeuronKey('character:tallow') // { kind: 'character', id: 'tallow' }
+ * parseNeuronKey('war') // { kind: 'domain', id: 'war' }
+ * ```
+ */
+export declare function parseNeuronKey(key: string): {
+    kind: string;
+    id: string;
+};
+/**
+ * The suggested domain neurons: the recurring subject matters of play that are
+ * nobody in particular. A game may extend the list — a domain neuron is just a
+ * key — but sharing a default set means two clients file "the war got worse"
+ * under the same neuron.
+ *
+ * @example
+ * ```ts
+ * import { FREEFORM_DOMAINS, neuronKey } from '@game-infra/game-state-schemas'
+ *
+ * FREEFORM_DOMAINS.includes('romance') // true
+ * neuronKey('domain', 'romance') // 'domain:romance'
+ * ```
+ */
+export declare const FREEFORM_DOMAINS: readonly ["war", "politics", "economy", "business", "crime", "romance", "faith", "health", "knowledge", "travel"];
+/**
+ * One remembered fact — an engram.
+ *
+ * `neuronIds` are the {@link neuronKey} connections recall walks; `turn` is
+ * when it was formed, which is what lets recent memory outrank old memory; and
+ * `weight` (1–5) is how much it mattered, which is what lets a betrayal outrank
+ * a purchase. A memory produced by consolidation looks like any other — its
+ * sources are named by the {@link ConsolidationDTOSchema} that replaced them.
+ *
+ * @example
+ * ```ts
+ * import type { MemoryDTO } from '@game-infra/game-state-schemas'
+ *
+ * const memory: MemoryDTO = {
+ *   id: 'm4-1',
+ *   text: 'Ilse saw you pocket the ledger and said nothing.',
+ *   neuronIds: ['character:warden-ilse', 'domain:crime'],
+ *   turn: 4,
+ *   weight: 4,
+ * }
+ * ```
+ */
+export declare const MemoryDTOSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    /** One sentence, written to be read back to a narrator later. */
+    readonly text: import("valibot").StringSchema<undefined>;
+    /** The {@link neuronKey} connections recall walks. */
+    readonly neuronIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The turn index the memory was formed on. */
+    readonly turn: import("valibot").NumberSchema<undefined>;
+    /** Salience, 1 (incidental) to 5 (unforgettable). */
+    readonly weight: import("valibot").NumberSchema<undefined>;
+}, undefined>;
+export type MemoryDTO = InferOutput<typeof MemoryDTOSchema>;
+/**
+ * One act of forgetting-by-summary: the memories consolidated away, and the
+ * single summary memory that stands for them from this turn on.
+ *
+ * Recorded on the turn that performed it so replaying the journal compresses
+ * exactly as play did — the superseded ids stop being recalled, the summary
+ * starts.
+ *
+ * @example
+ * ```ts
+ * import type { ConsolidationDTO } from '@game-infra/game-state-schemas'
+ *
+ * const consolidation: ConsolidationDTO = {
+ *   memoryIds: ['m2-1', 'm3-2', 'm5-1'],
+ *   memory: {
+ *     id: 'c9-1',
+ *     text: 'The wardens hold many small grievances against you.',
+ *     neuronIds: ['faction:ash-wardens'],
+ *     turn: 9,
+ *     weight: 4,
+ *   },
+ * }
+ * ```
+ */
+export declare const ConsolidationDTOSchema: import("valibot").ObjectSchema<{
+    /** The memories the summary supersedes. */
+    readonly memoryIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The summary that stands for them. */
+    readonly memory: import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** One sentence, written to be read back to a narrator later. */
+        readonly text: import("valibot").StringSchema<undefined>;
+        /** The {@link neuronKey} connections recall walks. */
+        readonly neuronIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The turn index the memory was formed on. */
+        readonly turn: import("valibot").NumberSchema<undefined>;
+        /** Salience, 1 (incidental) to 5 (unforgettable). */
+        readonly weight: import("valibot").NumberSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export type ConsolidationDTO = InferOutput<typeof ConsolidationDTOSchema>;
+/**
+ * One situational bonus or malus on a check, with the reason it applies —
+ * `{ label: 'the wardens distrust you', amount: -2 }` — so a roll readout can
+ * say why the odds were what they were.
+ */
+export declare const CheckModifierDTOSchema: import("valibot").ObjectSchema<{
+    readonly label: import("valibot").StringSchema<undefined>;
+    readonly amount: import("valibot").NumberSchema<undefined>;
+}, undefined>;
+export type CheckModifierDTO = InferOutput<typeof CheckModifierDTOSchema>;
+/** How hard an attempt was judged. `trivial` attempts are not rolled at all. */
+export declare const FREEFORM_COMPLEXITIES: readonly ["trivial", "easy", "moderate", "hard", "formidable"];
+export declare const FreeformComplexitySchema: import("valibot").PicklistSchema<readonly ["trivial", "easy", "moderate", "hard", "formidable"], undefined>;
+export type FreeformComplexity = InferOutput<typeof FreeformComplexitySchema>;
+/** How a rolled check landed. */
+export declare const FREEFORM_OUTCOMES: readonly ["critical-success", "success", "failure", "critical-failure"];
+export declare const FreeformOutcomeSchema: import("valibot").PicklistSchema<readonly ["critical-success", "success", "failure", "critical-failure"], undefined>;
+export type FreeformOutcome = InferOutput<typeof FreeformOutcomeSchema>;
+/**
+ * A skill check, rolled once and recorded forever.
+ *
+ * The roll happens when the turn is resolved and its result is stored, never
+ * re-rolled: replaying the journal must rebuild the same session, and dice do
+ * not replay. Everything a reader needs to see the roll was fair is here — the
+ * skill and stat it leaned on, the difficulty the complexity mapped to, the
+ * die, every modifier with its reason, and the total that met or missed it.
+ *
+ * @example
+ * ```ts
+ * import type { ResolvedCheckDTO } from '@game-infra/game-state-schemas'
+ *
+ * const check: ResolvedCheckDTO = {
+ *   skillId: 'skulking',
+ *   statId: 'grace',
+ *   complexity: 'hard',
+ *   difficulty: 16,
+ *   roll: 13,
+ *   modifiers: [
+ *     { label: 'Skulking rank', amount: 2 },
+ *     { label: 'moonless night', amount: 1 },
+ *   ],
+ *   total: 16,
+ *   outcome: 'success',
+ * }
+ * ```
+ */
+export declare const ResolvedCheckDTOSchema: import("valibot").ObjectSchema<{
+    /** The skill rolled, when one applied. */
+    readonly skillId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The stat behind it, when one applied. */
+    readonly statId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly complexity: import("valibot").PicklistSchema<readonly ["trivial", "easy", "moderate", "hard", "formidable"], undefined>;
+    /** The target number the complexity mapped to. */
+    readonly difficulty: import("valibot").NumberSchema<undefined>;
+    /** The die, unmodified. */
+    readonly roll: import("valibot").NumberSchema<undefined>;
+    /** Every bonus and malus that applied, each with its reason. */
+    readonly modifiers: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly label: import("valibot").StringSchema<undefined>;
+        readonly amount: import("valibot").NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    /** `roll` plus every modifier. */
+    readonly total: import("valibot").NumberSchema<undefined>;
+    readonly outcome: import("valibot").PicklistSchema<readonly ["critical-success", "success", "failure", "critical-failure"], undefined>;
+}, undefined>;
+export type ResolvedCheckDTO = InferOutput<typeof ResolvedCheckDTOSchema>;
+/**
+ * A character first met during freeform play, persisted so the world remembers
+ * them.
+ *
+ * The definition is whatever design-document character shape the game uses —
+ * this contract guarantees only the id and name and passes the rest through,
+ * the same stance `sessionState.ts` takes on `data`.
+ */
+export declare const IntroducedEntityDTOSchema: import("valibot").LooseObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly name: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export type IntroducedEntityDTO = InferOutput<typeof IntroducedEntityDTOSchema>;
+/**
+ * One turn of freeform play — the payload of one journal entry, stored at the
+ * entry's `sequence`.
+ *
+ * Everything downstream of the player's words is recorded: the neurons the
+ * adjudicator judged relevant (`focus`), the check it rolled (absent when the
+ * attempt was trivial or purely conversational), the effects in the same
+ * `ActivationDTO` vocabulary a story branch carries, the characters the turn
+ * introduced, the memories it formed and the consolidations it performed.
+ * Folding turns in order rebuilds the play state, the cast and the memory
+ * graph; nothing else is stored.
+ *
+ * @example
+ * ```ts
+ * import type { FreeformTurnPayload } from '@game-infra/game-state-schemas'
+ *
+ * const turn: FreeformTurnPayload = {
+ *   index: 4,
+ *   input: 'I slip the ledger under my coat and walk out.',
+ *   title: 'The ledger walks out',
+ *   narration: 'The clasp catches once, then gives…',
+ *   focus: ['character:warden-ilse', 'domain:crime'],
+ *   check: {
+ *     skillId: 'skulking', statId: 'grace', complexity: 'moderate', difficulty: 12,
+ *     roll: 11, modifiers: [{ label: 'Skulking rank', amount: 2 }], total: 13,
+ *     outcome: 'success',
+ *   },
+ *   effects: [{ type: 'GrantItem', params: { itemId: 'ilses-ledger', quantity: 1 } }],
+ *   introduced: [],
+ *   memories: [{
+ *     id: 'm4-1', text: 'You stole the ledger from under Ilse\'s eyes.',
+ *     neuronIds: ['character:warden-ilse', 'domain:crime'], turn: 4, weight: 4,
+ *   }],
+ *   consolidations: [],
+ *   model: 'aion',
+ * }
+ * ```
+ */
+export declare const FreeformTurnPayloadSchema: import("valibot").ObjectSchema<{
+    readonly index: import("valibot").NumberSchema<undefined>;
+    /** What the player wrote. Empty on the opening turn. */
+    readonly input: import("valibot").StringSchema<undefined>;
+    /** A few words naming the moment, for the journal listing. */
+    readonly title: import("valibot").StringSchema<undefined>;
+    /** The narrator's answer — what actually happened. */
+    readonly narration: import("valibot").StringSchema<undefined>;
+    /** The {@link neuronKey}s the adjudicator judged relevant to this turn. */
+    readonly focus: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The check that was rolled, when the attempt warranted one. */
+    readonly check: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        /** The skill rolled, when one applied. */
+        readonly skillId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The stat behind it, when one applied. */
+        readonly statId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly complexity: import("valibot").PicklistSchema<readonly ["trivial", "easy", "moderate", "hard", "formidable"], undefined>;
+        /** The target number the complexity mapped to. */
+        readonly difficulty: import("valibot").NumberSchema<undefined>;
+        /** The die, unmodified. */
+        readonly roll: import("valibot").NumberSchema<undefined>;
+        /** Every bonus and malus that applied, each with its reason. */
+        readonly modifiers: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly label: import("valibot").StringSchema<undefined>;
+            readonly amount: import("valibot").NumberSchema<undefined>;
+        }, undefined>, undefined>;
+        /** `roll` plus every modifier. */
+        readonly total: import("valibot").NumberSchema<undefined>;
+        readonly outcome: import("valibot").PicklistSchema<readonly ["critical-success", "success", "failure", "critical-failure"], undefined>;
+    }, undefined>, undefined>;
+    /** State changes, in the same vocabulary a story branch's effects use. */
+    readonly effects: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly type: import("valibot").StringSchema<undefined>;
+        readonly params: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").UnknownSchema, undefined>;
+    }, undefined>, undefined>;
+    /** Characters first met this turn, persisted with their definitions. */
+    readonly introduced: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>;
+    /** The memories this turn formed. */
+    readonly memories: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** One sentence, written to be read back to a narrator later. */
+        readonly text: import("valibot").StringSchema<undefined>;
+        /** The {@link neuronKey} connections recall walks. */
+        readonly neuronIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The turn index the memory was formed on. */
+        readonly turn: import("valibot").NumberSchema<undefined>;
+        /** Salience, 1 (incidental) to 5 (unforgettable). */
+        readonly weight: import("valibot").NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    /** The memory summaries this turn performed. */
+    readonly consolidations: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        /** The memories the summary supersedes. */
+        readonly memoryIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The summary that stands for them. */
+        readonly memory: import("valibot").ObjectSchema<{
+            readonly id: import("valibot").StringSchema<undefined>;
+            /** One sentence, written to be read back to a narrator later. */
+            readonly text: import("valibot").StringSchema<undefined>;
+            /** The {@link neuronKey} connections recall walks. */
+            readonly neuronIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            /** The turn index the memory was formed on. */
+            readonly turn: import("valibot").NumberSchema<undefined>;
+            /** Salience, 1 (incidental) to 5 (unforgettable). */
+            readonly weight: import("valibot").NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+    /** The model that resolved the turn, so a re-read can say what produced it. */
+    readonly model: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export type FreeformTurnPayload = InferOutput<typeof FreeformTurnPayloadSchema>;
+/**
+ * A freeform session's header payload — what goes inside a
+ * {@link GameSessionRecord}'s `data`. The session is scoped to the world it
+ * plays in; its turns are the journal entries under it.
+ *
+ * @example
+ * ```ts
+ * import type { FreeformSessionPayload } from '@game-infra/game-state-schemas'
+ *
+ * const session: FreeformSessionPayload = {
+ *   title: 'A thief in Cinderhold',
+ *   premise: 'Arrive with nothing and see what the city lets you take.',
+ * }
+ * ```
+ */
+export declare const FreeformSessionPayloadSchema: import("valibot").ObjectSchema<{
+    readonly title: import("valibot").StringSchema<undefined>;
+    /** The player's opening intent — what this playthrough is about. May be empty. */
+    readonly premise: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export type FreeformSessionPayload = InferOutput<typeof FreeformSessionPayloadSchema>;
+//# sourceMappingURL=freeformPayloads.d.ts.map

package/dist/freeformPayloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"freeformPayloads.d.ts","sourceRoot":"","sources":["../src/freeformPayloads.ts"],"names":[],"mappings":"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"}