feat(content): add Zod story graph schema and validation

src/content/storySchema.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import type { ActionDef } from './schema';
+
+export const storyOutcomeSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('setFlag'), flag: z.string().min(1) }),
+  z.object({ type: z.literal('clearFlag'), flag: z.string().min(1) }),
+  z.object({ type: z.literal('grantResource'), resourceId: z.string().min(1), amount: z.number().positive() }),
+  z.object({ type: z.literal('consumeResource'), resourceId: z.string().min(1), amount: z.number().positive() }),
+  z.object({ type: z.literal('log'), text: z.string().min(1) }),
+]);
+
+export const choiceRequirementsSchema = z.object({
+  minResources: z.record(z.string(), z.number().nonnegative()).optional(),
+  requireStoryFlags: z.array(z.string().min(1)).optional(),
+  excludeStoryFlags: z.array(z.string().min(1)).optional(),
+});
+
+export const storyChoiceSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  requirements: choiceRequirementsSchema.optional(),
+  outcomes: z.array(storyOutcomeSchema).default([]),
+  targetNodeId: z.string().min(1),
+});
+
+export const storyTriggerSchema = z.object({
+  type: z.enum(['boot', 'actionComplete', 'minResources']),
+  actionId: z.string().min(1).optional(),
+  minResources: z.record(z.string(), z.number().nonnegative()).optional(),
+  targetNodeId: z.string().min(1),
+  once: z.boolean().default(true),
+});
+
+export const storyNodeSchema = z.object({
+  id: z.string().min(1),
+  prose: z.string().min(1),
+  choices: z.array(storyChoiceSchema).optional(),
+  triggers: z.array(storyTriggerSchema).optional(),
+  enterOutcomes: z.array(storyOutcomeSchema).optional(),
+});
+
+export type StoryOutcome = z.infer<typeof storyOutcomeSchema>;
+export type StoryChoice = z.infer<typeof storyChoiceSchema>;
+export type StoryTrigger = z.infer<typeof storyTriggerSchema>;
+export type StoryNode = z.infer<typeof storyNodeSchema>;
+
+export interface StoryContent {
+  storyNodes: StoryNode[];
+  storyNodesById: Record<string, StoryNode>;
+  bootTargetNodeId: string;
+}
+
+function indexStoryNodes(nodes: StoryNode[]): Record<string, StoryNode> {
+  const byId: Record<string, StoryNode> = {};
+  for (const node of nodes) {
+    if (byId[node.id]) throw new Error(`Duplicate story node id "${node.id}"`);
+    byId[node.id] = node;
+  }
+  return byId;
+}
+
+export function buildStoryContent(
+  rawNodes: unknown[],
+  actionsById: Record<string, ActionDef>,
+  resourcesById: Record<string, { id: string }>,
+): StoryContent {
+  const storyNodes = rawNodes.map((n) => storyNodeSchema.parse(n));
+  const storyNodesById = indexStoryNodes(storyNodes);
+
+  let bootTargetNodeId: string | null = null;
+  for (const node of storyNodes) {
+    for (const trigger of node.triggers ?? []) {
+      if (trigger.type === 'boot') {
+        if (bootTargetNodeId !== null) {
+          throw new Error('Story graph must have exactly one boot trigger');
+        }
+        bootTargetNodeId = trigger.targetNodeId;
+      }
+      if (trigger.type === 'actionComplete' && !actionsById[trigger.actionId ?? '']) {
+        throw new Error(`Story trigger references unknown action "${trigger.actionId}"`);
+      }
+      if (trigger.minResources) {
+        for (const resourceId of Object.keys(trigger.minResources)) {
+          if (!resourcesById[resourceId]) {
+            throw new Error(`Story trigger references unknown resource "${resourceId}"`);
+          }
+        }
+      }
+      if (!storyNodesById[trigger.targetNodeId]) {
+        throw new Error(`Story trigger references unknown story node "${trigger.targetNodeId}"`);
+      }
+    }
+    for (const choice of node.choices ?? []) {
+      if (!storyNodesById[choice.targetNodeId]) {
+        throw new Error(`Story choice references unknown story node "${choice.targetNodeId}"`);
+      }
+      for (const outcome of choice.outcomes) {
+        if (outcome.type === 'grantResource' || outcome.type === 'consumeResource') {
+          if (!resourcesById[outcome.resourceId]) {
+            throw new Error(`Story outcome references unknown resource "${outcome.resourceId}"`);
+          }
+        }
+      }
+    }
+    for (const outcome of node.enterOutcomes ?? []) {
+      if (outcome.type === 'grantResource' || outcome.type === 'consumeResource') {
+        if (!resourcesById[outcome.resourceId]) {
+          throw new Error(`Story enterOutcome references unknown resource "${outcome.resourceId}"`);
+        }
+      }
+    }
+  }
+
+  if (bootTargetNodeId === null) {
+    throw new Error('Story graph must have exactly one boot trigger');
+  }
+
+  return { storyNodes, storyNodesById, bootTargetNodeId };
+}