@game-infra/story-schemas 0.2.0

package/dist/nodePaths.js

@@ -0,0 +1,123 @@
+/**
+ * How a beat is addressed.
+ *
+ * A story beat's identity is the trail of choices taken to reach it — nothing
+ * else. That is what makes "has this branch been travelled before?" a lookup
+ * rather than a search, and it is why both the client minting ids and the
+ * service sweeping subtrees have to agree on the spelling. They agree here.
+ *
+ * Two spellings, one meaning:
+ *
+ * - `nodeId` — `root`, then choice ids joined with `.`. It is the row's
+ *   `contentId`, and it travels as a single URL path segment
+ *   (`/design-content/story-node/:scopeId/:contentId`), which a slash would
+ *   split. The dot is also what `cascade=prefix` sweeps on.
+ * - `path` — the same trail joined with `/`, empty at the opening. This one is
+ *   for reading: it is what a breadcrumb shows.
+ */
+/** The opening beat of every story. */
+export const ROOT_NODE_ID = "root";
+/** Separator between choice ids inside a node id. */
+export const NODE_ID_SEPARATOR = ".";
+/**
+ * The id of the beat reached by taking `choiceIds` in order.
+ *
+ * @example
+ * ```ts
+ * import { storyNodeId } from '@game-infra/story-schemas'
+ *
+ * storyNodeId([]) // 'root'
+ * storyNodeId(['take-the-tunnel', 'follow-the-voice']) // 'root.take-the-tunnel.follow-the-voice'
+ * ```
+ */
+export function storyNodeId(choiceIds) {
+    return [ROOT_NODE_ID, ...choiceIds].join(NODE_ID_SEPARATOR);
+}
+/**
+ * The readable trail for the same beat, empty at the opening.
+ *
+ * @example
+ * ```ts
+ * import { storyNodePath } from '@game-infra/story-schemas'
+ *
+ * storyNodePath(['take-the-tunnel', 'follow-the-voice']) // 'take-the-tunnel/follow-the-voice'
+ * ```
+ */
+export function storyNodePath(choiceIds) {
+    return choiceIds.join("/");
+}
+/**
+ * The choice trail a node id encodes. The inverse of {@link storyNodeId}.
+ *
+ * @example
+ * ```ts
+ * import { storyNodeChoiceIds } from '@game-infra/story-schemas'
+ *
+ * storyNodeChoiceIds('root.take-the-tunnel') // ['take-the-tunnel']
+ * storyNodeChoiceIds('root') // []
+ * ```
+ */
+export function storyNodeChoiceIds(nodeId) {
+    const segments = nodeId.split(NODE_ID_SEPARATOR);
+    return segments[0] === ROOT_NODE_ID ? segments.slice(1) : segments;
+}
+/**
+ * The id of the beat one choice further on.
+ *
+ * @example
+ * ```ts
+ * import { childStoryNodeId } from '@game-infra/story-schemas'
+ *
+ * childStoryNodeId('root', 'take-the-tunnel') // 'root.take-the-tunnel'
+ * ```
+ */
+export function childStoryNodeId(parentNodeId, choiceId) {
+    return `${parentNodeId}${NODE_ID_SEPARATOR}${choiceId}`;
+}
+/**
+ * The id of the beat this one branched from, or `undefined` at the opening.
+ *
+ * @example
+ * ```ts
+ * import { parentStoryNodeId } from '@game-infra/story-schemas'
+ *
+ * parentStoryNodeId('root.take-the-tunnel') // 'root'
+ * parentStoryNodeId('root') // undefined
+ * ```
+ */
+export function parentStoryNodeId(nodeId) {
+    const cut = nodeId.lastIndexOf(NODE_ID_SEPARATOR);
+    return cut === -1 ? undefined : nodeId.slice(0, cut);
+}
+/**
+ * How many choices deep a beat sits. The opening is 0.
+ *
+ * @example
+ * ```ts
+ * import { storyNodeDepth } from '@game-infra/story-schemas'
+ *
+ * storyNodeDepth('root.take-the-tunnel.follow-the-voice') // 2
+ * ```
+ */
+export function storyNodeDepth(nodeId) {
+    return storyNodeChoiceIds(nodeId).length;
+}
+/**
+ * Whether `nodeId` sits at or below `ancestorId`. This is `cascade=prefix`,
+ * expressed for a client that holds the tree in memory.
+ *
+ * The separator is part of the test on purpose: `root.take` is not an ancestor
+ * of `root.taken`, however alike the two ids look.
+ *
+ * @example
+ * ```ts
+ * import { isStoryNodeAtOrBelow } from '@game-infra/story-schemas'
+ *
+ * isStoryNodeAtOrBelow('root.take.left', 'root.take') // true
+ * isStoryNodeAtOrBelow('root.taken', 'root.take') // false
+ * ```
+ */
+export function isStoryNodeAtOrBelow(nodeId, ancestorId) {
+    return nodeId === ancestorId || nodeId.startsWith(`${ancestorId}${NODE_ID_SEPARATOR}`);
+}
+//# sourceMappingURL=nodePaths.js.map

package/dist/nodePaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodePaths.js","sourceRoot":"","sources":["../src/nodePaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,uCAAuC;AACvC,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC;AAEnC,qDAAqD;AACrD,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAErC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CAAC,SAA4B;IACtD,OAAO,CAAC,YAAY,EAAE,GAAG,SAAS,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,SAA4B;IACxD,OAAO,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACjD,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;AACrE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,YAAoB,EAAE,QAAgB;IACrE,OAAO,GAAG,YAAY,GAAG,iBAAiB,GAAG,QAAQ,EAAE,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;IAClD,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAc,EAAE,UAAkB;IACrE,OAAO,MAAM,KAAK,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,UAAU,GAAG,iBAAiB,EAAE,CAAC,CAAC;AACzF,CAAC"}

package/dist/storyPayloads.d.ts

@@ -0,0 +1,226 @@
+import { type InferOutput } from "valibot";
+/**
+ * What goes *inside* a design-content row's `data` for story mode.
+ *
+ * A story beat is an **encounter stage** and a branch is a **choice** — the
+ * same shapes the event editor already uses, not parallel ones. A branching
+ * story and a multi-stage event are the same object seen from two angles: both
+ * are prose with gated, consequential branches out of it. Reusing the DTOs is
+ * what lets an arc be published as an ordinary `event_definitions` row, and
+ * what gives story branches preconditions and consequences for free.
+ *
+ * These schemas are not attached to any endpoint. The service stores `data` as
+ * an opaque string and never parses it — see `designContent.ts` — but two
+ * clients reading the same rows still have to agree, so the shapes live here.
+ *
+ * @example
+ * ```ts
+ * import { StoryBeatPayloadSchema } from '@game-infra/story-schemas'
+ * import { safeParse } from 'valibot'
+ *
+ * const parsed = safeParse(StoryBeatPayloadSchema, JSON.parse(row.data ?? '{}'))
+ * if (parsed.success) console.log(parsed.output.description, parsed.output.choices)
+ * ```
+ */
+/**
+ * A world's own fields; its content lives in rows scoped to it.
+ *
+ * This one has no event-editor counterpart — an event belongs to a game, but a
+ * design world is the thing a game's events are written against.
+ */
+export declare const WorldPayloadSchema: import("valibot").ObjectSchema<{
+    readonly title: import("valibot").StringSchema<undefined>;
+    /** The one-paragraph pitch. */
+    readonly premise: import("valibot").StringSchema<undefined>;
+    readonly setting: import("valibot").StringSchema<undefined>;
+    readonly tone: import("valibot").StringSchema<undefined>;
+    readonly themes: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type WorldPayload = InferOutput<typeof WorldPayloadSchema>;
+/**
+ * A story arc: the header of a multi-stage event, plus the few fields a story
+ * needs that an event does not.
+ *
+ * Every field up to `globalEffects` is an `EventDefinitionDTO` field under its
+ * own name, so assembling an arc and its beats into an event definition is a
+ * copy rather than a translation. `conditionsToTrigger` gates whether the arc
+ * is offered at all; `globalEffects` fires when it concludes.
+ *
+ * @example
+ * ```ts
+ * import type { StoryArcPayload } from '@game-infra/story-schemas'
+ *
+ * const arc: StoryArcPayload = {
+ *   title: 'The Quiet Forge Answers',
+ *   description: 'Something inside the intact sky-forge is calling people by name.',
+ *   rarity: 'rare',
+ *   isRecurring: false,
+ *   isMultiStage: true,
+ *   conditionsToTrigger: [{ type: 'StatAtLeast', params: { statId: 'wits', value: 6 } }],
+ *   globalEffects: [{ type: 'SetFlag', params: { flag: 'forge-answered', value: true } }],
+ *   hook: 'Tallow hears their own voice from behind a sealed door.',
+ *   tags: ['mystery', 'descent'],
+ *   protagonistId: 'tallow',
+ *   openingLocationId: 'quiet-forge',
+ * }
+ * ```
+ */
+export declare const StoryArcPayloadSchema: import("valibot").ObjectSchema<{
+    readonly title: import("valibot").StringSchema<undefined>;
+    readonly description: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>;
+    readonly rarity: import("valibot").StringSchema<undefined>;
+    readonly isRecurring: import("valibot").BooleanSchema<undefined>;
+    readonly isMultiStage: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /** Gates whether this arc is offered. Same shape as an event's trigger conditions. */
+    readonly conditionsToTrigger: import("valibot").OptionalSchema<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>, undefined>;
+    readonly eventParticipantPersonas: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        readonly entityId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly type: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly relationship: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
+        readonly requiredTraits: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+        readonly excludedTraits: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+        readonly haveMet: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    /** Applied when the arc concludes, whichever ending it reached. */
+    readonly globalEffects: import("valibot").OptionalSchema<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>, undefined>;
+    /** The opening image — what the player is looking at when it starts. */
+    readonly hook: import("valibot").StringSchema<undefined>;
+    readonly tags: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** A character id from the world, when the arc has one in mind. */
+    readonly protagonistId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** A location id from the world, when the arc opens somewhere in particular. */
+    readonly openingLocationId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type StoryArcPayload = InferOutput<typeof StoryArcPayloadSchema>;
+/** Whether a beat's narration came from a model or from the player's own words. */
+export declare const STORY_BEAT_ORIGINS: readonly ["generated", "authored"];
+export declare const StoryBeatOriginSchema: import("valibot").PicklistSchema<readonly ["generated", "authored"], undefined>;
+export type StoryBeatOrigin = InferOutput<typeof StoryBeatOriginSchema>;
+/**
+ * One beat of a story: an `EncounterStageDTO`, plus how it came to exist.
+ *
+ * `description` is the narration the player reads and `choices` are the
+ * branches out of it, each a full `ChoiceDefinitionDTO` — so a branch carries
+ * `conditionsToShow`, `conditionsToEnable`, `consumableConditions`, `effects`
+ * and an outcome config exactly as an event's choice does.
+ *
+ * The beat's *address* is not in here — it is the row's `contentId`, the trail
+ * of choices taken to reach it (see `nodePaths.ts`). Keeping the address out of
+ * the payload is what keeps the two from disagreeing. The stage's own `id` is
+ * the event-editor-facing id, used when the arc is published as an event.
+ *
+ * @example
+ * ```ts
+ * import type { StoryBeatPayload } from '@game-infra/story-schemas'
+ *
+ * const beat: StoryBeatPayload = {
+ *   id: 'root',
+ *   title: 'The sealed door',
+ *   description: 'The tunnel breathes out ash as you climb down…',
+ *   choices: {
+ *     'force-the-door': {
+ *       id: 'force-the-door',
+ *       name: 'Force the door',
+ *       effects: [{ type: 'ModifyStat', params: { statId: 'grit', amount: -1 } }],
+ *       conditionsToEnable: [{ type: 'StatAtLeast', params: { statId: 'grit', value: 5 } }],
+ *     },
+ *   },
+ *   model: 'aion',
+ *   origin: 'generated',
+ *   revision: 0,
+ *   notes: [],
+ * }
+ * ```
+ */
+export declare const StoryBeatPayloadSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly title: import("valibot").StringSchema<undefined>;
+    readonly description: import("valibot").StringSchema<undefined>;
+    readonly choices: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly description: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        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>;
+        readonly conditionsToShow: import("valibot").OptionalSchema<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>, undefined>;
+        readonly conditionsToEnable: import("valibot").OptionalSchema<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>, undefined>;
+        readonly consumableConditions: import("valibot").OptionalSchema<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>, undefined>;
+        readonly outcomeConfig: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+            readonly baseDifficulty: import("valibot").NumberSchema<undefined>;
+            readonly statBonuses: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly stat: import("valibot").StringSchema<undefined>;
+                readonly multiplier: import("valibot").NumberSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
+            readonly skillBonuses: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly skillId: import("valibot").StringSchema<undefined>;
+                readonly multiplier: import("valibot").NumberSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
+            readonly onSuccess: 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>;
+            readonly onFailure: 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>;
+        }, undefined>, undefined>;
+        readonly conditionalOutcome: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+            readonly type: import("valibot").LiteralSchema<"conditional", undefined>;
+            readonly branches: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly id: import("valibot").StringSchema<undefined>;
+                readonly conditions: 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>;
+                readonly priority: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                readonly outcome: import("valibot").ObjectSchema<{
+                    readonly description: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    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>;
+                }, undefined>;
+            }, undefined>, undefined>;
+            readonly defaultBranch: import("valibot").ObjectSchema<{
+                readonly description: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                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>;
+            }, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** The model that wrote this beat, so a re-read can say what produced it. */
+    readonly model: import("valibot").StringSchema<undefined>;
+    readonly origin: import("valibot").PicklistSchema<readonly ["generated", "authored"], undefined>;
+    /** 0 for the first draft, then one per regeneration. */
+    readonly revision: import("valibot").NumberSchema<undefined>;
+    /** The author's regeneration notes, oldest first. */
+    readonly notes: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type StoryBeatPayload = InferOutput<typeof StoryBeatPayloadSchema>;
+/**
+ * Re-exported so a story client needs one import, not two, for the shapes it
+ * reads out of a beat.
+ */
+export { ActivationDTOSchema, ChoiceDefinitionDTOSchema, ConsumableConditionDTOSchema, EncounterStageDTOSchema, PreconditionDTOSchema, } from "@game-infra/event-schemas";
+export type { ActivationDTO, ChoiceDefinitionDTO, ConsumableConditionDTO, EncounterStageDTO, PreconditionDTO, } from "@game-infra/event-schemas";
+//# sourceMappingURL=storyPayloads.d.ts.map

package/dist/storyPayloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storyPayloads.d.ts","sourceRoot":"","sources":["../src/storyPayloads.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,KAAK,WAAW,EASjB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;IAE7B,+BAA+B;;;;;aAK/B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB;;;;;;IAMhC,sFAAsF;;;;;;;;;;;;;;IAGtF,mEAAmE;;;;;IAKnE,wEAAwE;;;IAGxE,mEAAmE;;IAEnE,gFAAgF;;aAEhF,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAExE,mFAAmF;AACnF,eAAO,MAAM,kBAAkB,YAAI,WAAW,EAAE,UAAU,CAAU,CAAC;AAErE,eAAO,MAAM,qBAAqB,iFAA+B,CAAC;AAElE,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEjC,6EAA6E;;;IAG7E,wDAAwD;;IAExD,qDAAqD;;aAErD,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE1E;;;GAGG;AACH,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,4BAA4B,EAC5B,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,GAChB,MAAM,2BAA2B,CAAC"}

package/dist/storyPayloads.js

@@ -0,0 +1,142 @@
+import { ActivationDTOSchema, EncounterStageDTOSchema, EventDescriptionSchema, EventRaritySchema, EventParticipantPersonaDTOSchema, PreconditionDTOSchema, } from "@game-infra/event-schemas";
+import { array, boolean, number, object, optional, picklist, record, string, } from "valibot";
+/**
+ * What goes *inside* a design-content row's `data` for story mode.
+ *
+ * A story beat is an **encounter stage** and a branch is a **choice** — the
+ * same shapes the event editor already uses, not parallel ones. A branching
+ * story and a multi-stage event are the same object seen from two angles: both
+ * are prose with gated, consequential branches out of it. Reusing the DTOs is
+ * what lets an arc be published as an ordinary `event_definitions` row, and
+ * what gives story branches preconditions and consequences for free.
+ *
+ * These schemas are not attached to any endpoint. The service stores `data` as
+ * an opaque string and never parses it — see `designContent.ts` — but two
+ * clients reading the same rows still have to agree, so the shapes live here.
+ *
+ * @example
+ * ```ts
+ * import { StoryBeatPayloadSchema } from '@game-infra/story-schemas'
+ * import { safeParse } from 'valibot'
+ *
+ * const parsed = safeParse(StoryBeatPayloadSchema, JSON.parse(row.data ?? '{}'))
+ * if (parsed.success) console.log(parsed.output.description, parsed.output.choices)
+ * ```
+ */
+/**
+ * A world's own fields; its content lives in rows scoped to it.
+ *
+ * This one has no event-editor counterpart — an event belongs to a game, but a
+ * design world is the thing a game's events are written against.
+ */
+export const WorldPayloadSchema = object({
+    title: string(),
+    /** The one-paragraph pitch. */
+    premise: string(),
+    setting: string(),
+    tone: string(),
+    themes: array(string()),
+});
+/**
+ * A story arc: the header of a multi-stage event, plus the few fields a story
+ * needs that an event does not.
+ *
+ * Every field up to `globalEffects` is an `EventDefinitionDTO` field under its
+ * own name, so assembling an arc and its beats into an event definition is a
+ * copy rather than a translation. `conditionsToTrigger` gates whether the arc
+ * is offered at all; `globalEffects` fires when it concludes.
+ *
+ * @example
+ * ```ts
+ * import type { StoryArcPayload } from '@game-infra/story-schemas'
+ *
+ * const arc: StoryArcPayload = {
+ *   title: 'The Quiet Forge Answers',
+ *   description: 'Something inside the intact sky-forge is calling people by name.',
+ *   rarity: 'rare',
+ *   isRecurring: false,
+ *   isMultiStage: true,
+ *   conditionsToTrigger: [{ type: 'StatAtLeast', params: { statId: 'wits', value: 6 } }],
+ *   globalEffects: [{ type: 'SetFlag', params: { flag: 'forge-answered', value: true } }],
+ *   hook: 'Tallow hears their own voice from behind a sealed door.',
+ *   tags: ['mystery', 'descent'],
+ *   protagonistId: 'tallow',
+ *   openingLocationId: 'quiet-forge',
+ * }
+ * ```
+ */
+export const StoryArcPayloadSchema = object({
+    title: string(),
+    description: EventDescriptionSchema,
+    rarity: EventRaritySchema,
+    isRecurring: boolean(),
+    isMultiStage: optional(boolean()),
+    /** Gates whether this arc is offered. Same shape as an event's trigger conditions. */
+    conditionsToTrigger: optional(array(PreconditionDTOSchema)),
+    eventParticipantPersonas: optional(record(string(), EventParticipantPersonaDTOSchema)),
+    /** Applied when the arc concludes, whichever ending it reached. */
+    globalEffects: optional(array(ActivationDTOSchema)),
+    // Story-only fields, ignored when the arc is published as an event.
+    /** The opening image — what the player is looking at when it starts. */
+    hook: string(),
+    tags: array(string()),
+    /** A character id from the world, when the arc has one in mind. */
+    protagonistId: optional(string()),
+    /** A location id from the world, when the arc opens somewhere in particular. */
+    openingLocationId: optional(string()),
+});
+/** Whether a beat's narration came from a model or from the player's own words. */
+export const STORY_BEAT_ORIGINS = ["generated", "authored"];
+export const StoryBeatOriginSchema = picklist(STORY_BEAT_ORIGINS);
+/**
+ * One beat of a story: an `EncounterStageDTO`, plus how it came to exist.
+ *
+ * `description` is the narration the player reads and `choices` are the
+ * branches out of it, each a full `ChoiceDefinitionDTO` — so a branch carries
+ * `conditionsToShow`, `conditionsToEnable`, `consumableConditions`, `effects`
+ * and an outcome config exactly as an event's choice does.
+ *
+ * The beat's *address* is not in here — it is the row's `contentId`, the trail
+ * of choices taken to reach it (see `nodePaths.ts`). Keeping the address out of
+ * the payload is what keeps the two from disagreeing. The stage's own `id` is
+ * the event-editor-facing id, used when the arc is published as an event.
+ *
+ * @example
+ * ```ts
+ * import type { StoryBeatPayload } from '@game-infra/story-schemas'
+ *
+ * const beat: StoryBeatPayload = {
+ *   id: 'root',
+ *   title: 'The sealed door',
+ *   description: 'The tunnel breathes out ash as you climb down…',
+ *   choices: {
+ *     'force-the-door': {
+ *       id: 'force-the-door',
+ *       name: 'Force the door',
+ *       effects: [{ type: 'ModifyStat', params: { statId: 'grit', amount: -1 } }],
+ *       conditionsToEnable: [{ type: 'StatAtLeast', params: { statId: 'grit', value: 5 } }],
+ *     },
+ *   },
+ *   model: 'aion',
+ *   origin: 'generated',
+ *   revision: 0,
+ *   notes: [],
+ * }
+ * ```
+ */
+export const StoryBeatPayloadSchema = object({
+    ...EncounterStageDTOSchema.entries,
+    /** The model that wrote this beat, so a re-read can say what produced it. */
+    model: string(),
+    origin: StoryBeatOriginSchema,
+    /** 0 for the first draft, then one per regeneration. */
+    revision: number(),
+    /** The author's regeneration notes, oldest first. */
+    notes: array(string()),
+});
+/**
+ * Re-exported so a story client needs one import, not two, for the shapes it
+ * reads out of a beat.
+ */
+export { ActivationDTOSchema, ChoiceDefinitionDTOSchema, ConsumableConditionDTOSchema, EncounterStageDTOSchema, PreconditionDTOSchema, } from "@game-infra/event-schemas";
+//# sourceMappingURL=storyPayloads.js.map

package/dist/storyPayloads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storyPayloads.js","sourceRoot":"","sources":["../src/storyPayloads.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,gCAAgC,EAChC,qBAAqB,GACtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,KAAK,EACL,OAAO,EACP,MAAM,EACN,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,GACP,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;IACvC,KAAK,EAAE,MAAM,EAAE;IACf,+BAA+B;IAC/B,OAAO,EAAE,MAAM,EAAE;IACjB,OAAO,EAAE,MAAM,EAAE;IACjB,IAAI,EAAE,MAAM,EAAE;IACd,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;CACxB,CAAC,CAAC;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;IAC1C,KAAK,EAAE,MAAM,EAAE;IACf,WAAW,EAAE,sBAAsB;IACnC,MAAM,EAAE,iBAAiB;IACzB,WAAW,EAAE,OAAO,EAAE;IACtB,YAAY,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC;IACjC,sFAAsF;IACtF,mBAAmB,EAAE,QAAQ,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC3D,wBAAwB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,gCAAgC,CAAC,CAAC;IACtF,mEAAmE;IACnE,aAAa,EAAE,QAAQ,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAEnD,oEAAoE;IAEpE,wEAAwE;IACxE,IAAI,EAAE,MAAM,EAAE;IACd,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;IACrB,mEAAmE;IACnE,aAAa,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC;IACjC,gFAAgF;IAChF,iBAAiB,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC;CACtC,CAAC,CAAC;AAIH,mFAAmF;AACnF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,WAAW,EAAE,UAAU,CAAU,CAAC;AAErE,MAAM,CAAC,MAAM,qBAAqB,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC;AAIlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC;IAC3C,GAAG,uBAAuB,CAAC,OAAO;IAClC,6EAA6E;IAC7E,KAAK,EAAE,MAAM,EAAE;IACf,MAAM,EAAE,qBAAqB;IAC7B,wDAAwD;IACxD,QAAQ,EAAE,MAAM,EAAE;IAClB,qDAAqD;IACrD,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;CACvB,CAAC,CAAC;AAIH;;;GAGG;AACH,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,4BAA4B,EAC5B,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,2BAA2B,CAAC"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@game-infra/story-schemas",
+  "version": "0.2.0",
+  "description": "Story-mode API contract: branching arcs and beats built on the event-editor's encounter-stage and choice DTOs, behind one design-content resource",
+  "homepage": "https://github.com/kibertoad/game-infra/tree/main/packages/schemas/story-schemas#readme",
+  "bugs": {
+    "url": "https://github.com/kibertoad/game-infra/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kibertoad/game-infra.git",
+    "directory": "packages/schemas/story-schemas"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@toad-contracts/core": "0.4.0",
+    "@toad-contracts/valibot": "0.5.0",
+    "@game-infra/api-schemas-core": "0.3.0",
+    "@game-infra/event-schemas": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.2",
+    "rimraf": "^6.1.3",
+    "typescript": "^7.0.2",
+    "valibot": "^1.4.2",
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "valibot": "^1.4.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc --project tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rimraf dist"
+  }
+}