@game-infra/game-state-schemas 0.1.0

package/dist/freeformPayloads.js

@@ -0,0 +1,318 @@
+import { ActivationDTOSchema } from "@game-infra/event-schemas";
+import { array, looseObject, number, object, optional, picklist, string, } 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 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 function neuronKey(kind, id) {
+    return `${kind}${NEURON_KEY_SEPARATOR}${id}`;
+}
+/**
+ * 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 function parseNeuronKey(key) {
+    const at = key.indexOf(NEURON_KEY_SEPARATOR);
+    if (at === -1)
+        return { kind: "domain", id: key };
+    return { kind: key.slice(0, at), id: key.slice(at + 1) };
+}
+/**
+ * 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 const FREEFORM_DOMAINS = [
+    "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 const MemoryDTOSchema = object({
+    id: string(),
+    /** One sentence, written to be read back to a narrator later. */
+    text: string(),
+    /** The {@link neuronKey} connections recall walks. */
+    neuronIds: array(string()),
+    /** The turn index the memory was formed on. */
+    turn: number(),
+    /** Salience, 1 (incidental) to 5 (unforgettable). */
+    weight: number(),
+});
+/**
+ * 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 const ConsolidationDTOSchema = object({
+    /** The memories the summary supersedes. */
+    memoryIds: array(string()),
+    /** The summary that stands for them. */
+    memory: MemoryDTOSchema,
+});
+/**
+ * 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 const CheckModifierDTOSchema = object({
+    label: string(),
+    amount: number(),
+});
+/** How hard an attempt was judged. `trivial` attempts are not rolled at all. */
+export const FREEFORM_COMPLEXITIES = ["trivial", "easy", "moderate", "hard", "formidable"];
+export const FreeformComplexitySchema = picklist(FREEFORM_COMPLEXITIES);
+/** How a rolled check landed. */
+export const FREEFORM_OUTCOMES = [
+    "critical-success",
+    "success",
+    "failure",
+    "critical-failure",
+];
+export const FreeformOutcomeSchema = picklist(FREEFORM_OUTCOMES);
+/**
+ * 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 const ResolvedCheckDTOSchema = object({
+    /** The skill rolled, when one applied. */
+    skillId: optional(string()),
+    /** The stat behind it, when one applied. */
+    statId: optional(string()),
+    complexity: FreeformComplexitySchema,
+    /** The target number the complexity mapped to. */
+    difficulty: number(),
+    /** The die, unmodified. */
+    roll: number(),
+    /** Every bonus and malus that applied, each with its reason. */
+    modifiers: array(CheckModifierDTOSchema),
+    /** `roll` plus every modifier. */
+    total: number(),
+    outcome: FreeformOutcomeSchema,
+});
+/**
+ * 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 const IntroducedEntityDTOSchema = looseObject({
+    id: string(),
+    name: string(),
+});
+/**
+ * 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 const FreeformTurnPayloadSchema = object({
+    index: number(),
+    /** What the player wrote. Empty on the opening turn. */
+    input: string(),
+    /** A few words naming the moment, for the journal listing. */
+    title: string(),
+    /** The narrator's answer — what actually happened. */
+    narration: string(),
+    /** The {@link neuronKey}s the adjudicator judged relevant to this turn. */
+    focus: array(string()),
+    /** The check that was rolled, when the attempt warranted one. */
+    check: optional(ResolvedCheckDTOSchema),
+    /** State changes, in the same vocabulary a story branch's effects use. */
+    effects: array(ActivationDTOSchema),
+    /** Characters first met this turn, persisted with their definitions. */
+    introduced: array(IntroducedEntityDTOSchema),
+    /** The memories this turn formed. */
+    memories: array(MemoryDTOSchema),
+    /** The memory summaries this turn performed. */
+    consolidations: array(ConsolidationDTOSchema),
+    /** The model that resolved the turn, so a re-read can say what produced it. */
+    model: string(),
+});
+/**
+ * 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 const FreeformSessionPayloadSchema = object({
+    title: string(),
+    /** The player's opening intent — what this playthrough is about. May be empty. */
+    premise: string(),
+});
+//# sourceMappingURL=freeformPayloads.js.map

package/dist/freeformPayloads.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @game-infra/game-state-schemas
+ *
+ * The API contract for **play state**: the sessions a player has in progress,
+ * the journal each one is rebuilt from, and the payload shapes freeform mode
+ * puts inside them.
+ *
+ * The line this package draws is the point of it. `@game-infra/story-schemas`
+ * carries what an author writes — one world, read by every player, the same
+ * tomorrow as today. This package carries what a *player* produces — one run,
+ * belonging to them alone, rewritten every turn and deleted when they abandon
+ * it. `game-state-service` implements these contracts; `game-content-service`
+ * implements the design-content ones and holds no session state at all.
+ *
+ * Savegames — slot snapshots — are the same service's other half, but their
+ * contracts predate this package and stay in `@game-infra/api-schemas-core`
+ * (`savegameSaveContract`, `savegameLoadContract`, `savegameListSlotsContract`).
+ *
+ * @example
+ * ```ts
+ * import {
+ *   gameSessionListContract,
+ *   gameJournalAppendContract,
+ *   type FreeformTurnPayload,
+ * } from '@game-infra/game-state-schemas'
+ * import { sendByApiContract } from '@toad-contracts/frontend-http-client'
+ *
+ * const { result } = await sendByApiContract(http, gameSessionListContract, {
+ *   pathParams: { gameId: 'fluid-emerald' },
+ *   queryParams: { scopeId: 'the-ash-reckoning' },
+ * })
+ * ```
+ */
+export { GameJournalAppendRequestSchema, GameJournalAppendResponseSchema, GameJournalEntryRecordSchema, GameJournalListResponseSchema, GameJournalTruncateResponseSchema, GameSessionDeleteResponseSchema, GameSessionListResponseSchema, GameSessionLoadResponseSchema, GameSessionRecordSchema, GameSessionSaveRequestSchema, GameSessionSaveResponseSchema, JOURNAL_TRUNCATIONS, JournalTruncationSchema, ROOT_SESSION_SCOPE, SequenceParamSchema, } from "./sessionState.js";
+export type { GameJournalAppendRequest, GameJournalAppendResponse, GameJournalEntryRecord, GameJournalListResponse, GameJournalTruncateResponse, GameSessionDeleteResponse, GameSessionListResponse, GameSessionLoadResponse, GameSessionRecord, GameSessionSaveRequest, GameSessionSaveResponse, JournalTruncation, } from "./sessionState.js";
+export { CheckModifierDTOSchema, ConsolidationDTOSchema, FREEFORM_COMPLEXITIES, FREEFORM_DOMAINS, FREEFORM_OUTCOMES, FreeformComplexitySchema, FreeformOutcomeSchema, FreeformSessionPayloadSchema, FreeformTurnPayloadSchema, IntroducedEntityDTOSchema, MemoryDTOSchema, NEURON_KEY_SEPARATOR, ResolvedCheckDTOSchema, neuronKey, parseNeuronKey, } from "./freeformPayloads.js";
+export type { CheckModifierDTO, ConsolidationDTO, FreeformComplexity, FreeformOutcome, FreeformSessionPayload, FreeformTurnPayload, IntroducedEntityDTO, MemoryDTO, ResolvedCheckDTO, } from "./freeformPayloads.js";
+export { gameJournalAppendContract, gameJournalListContract, gameJournalTruncateContract, gameSessionDeleteContract, gameSessionListContract, gameSessionLoadContract, gameSessionSaveContract, } from "./contracts.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,SAAS,EACT,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAK/B,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,45 @@
+/**
+ * @game-infra/game-state-schemas
+ *
+ * The API contract for **play state**: the sessions a player has in progress,
+ * the journal each one is rebuilt from, and the payload shapes freeform mode
+ * puts inside them.
+ *
+ * The line this package draws is the point of it. `@game-infra/story-schemas`
+ * carries what an author writes — one world, read by every player, the same
+ * tomorrow as today. This package carries what a *player* produces — one run,
+ * belonging to them alone, rewritten every turn and deleted when they abandon
+ * it. `game-state-service` implements these contracts; `game-content-service`
+ * implements the design-content ones and holds no session state at all.
+ *
+ * Savegames — slot snapshots — are the same service's other half, but their
+ * contracts predate this package and stay in `@game-infra/api-schemas-core`
+ * (`savegameSaveContract`, `savegameLoadContract`, `savegameListSlotsContract`).
+ *
+ * @example
+ * ```ts
+ * import {
+ *   gameSessionListContract,
+ *   gameJournalAppendContract,
+ *   type FreeformTurnPayload,
+ * } from '@game-infra/game-state-schemas'
+ * import { sendByApiContract } from '@toad-contracts/frontend-http-client'
+ *
+ * const { result } = await sendByApiContract(http, gameSessionListContract, {
+ *   pathParams: { gameId: 'fluid-emerald' },
+ *   queryParams: { scopeId: 'the-ash-reckoning' },
+ * })
+ * ```
+ */
+// Sessions and journals: the records the service stores, the requests that
+// write them, and the responses that carry them back.
+export { GameJournalAppendRequestSchema, GameJournalAppendResponseSchema, GameJournalEntryRecordSchema, GameJournalListResponseSchema, GameJournalTruncateResponseSchema, GameSessionDeleteResponseSchema, GameSessionListResponseSchema, GameSessionLoadResponseSchema, GameSessionRecordSchema, GameSessionSaveRequestSchema, GameSessionSaveResponseSchema, JOURNAL_TRUNCATIONS, JournalTruncationSchema, ROOT_SESSION_SCOPE, SequenceParamSchema, } from "./sessionState.js";
+// Freeform mode: the journal of turns a session is replayed from, and the
+// synapse memory graph — memories connected to neurons, consolidated over time
+// — that decides what a narrator is reminded of.
+export { CheckModifierDTOSchema, ConsolidationDTOSchema, FREEFORM_COMPLEXITIES, FREEFORM_DOMAINS, FREEFORM_OUTCOMES, FreeformComplexitySchema, FreeformOutcomeSchema, FreeformSessionPayloadSchema, FreeformTurnPayloadSchema, IntroducedEntityDTOSchema, MemoryDTOSchema, NEURON_KEY_SEPARATOR, ResolvedCheckDTOSchema, neuronKey, parseNeuronKey, } from "./freeformPayloads.js";
+// Typed endpoint contracts (toad-contracts). Each contract carries its own
+// `pathResolver`; wire them into a client via @toad-contracts/frontend-http-client
+// and into a Hono service via @toad-contracts/hono.
+export { gameJournalAppendContract, gameJournalListContract, gameJournalTruncateContract, gameSessionDeleteContract, gameSessionListContract, gameSessionLoadContract, gameSessionSaveContract, } from "./contracts.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,2EAA2E;AAC3E,sDAAsD;AACtD,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAgB3B,0EAA0E;AAC1E,+EAA+E;AAC/E,iDAAiD;AACjD,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,SAAS,EACT,cAAc,GACf,MAAM,uBAAuB,CAAC;AAa/B,2EAA2E;AAC3E,mFAAmF;AACnF,oDAAoD;AACpD,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC"}