@aura3d/scripting 1.3.3 → 1.4.1

package/src/PlayerBehaviorTelemetryFixtures.ts

@@ -1,257 +0,0 @@
-export type PlayerSkillLevel = "beginner" | "novice" | "intermediate" | "advanced" | "expert";
-export type PlayerPlaystyle = "aggressive" | "defensive" | "balanced" | "stealth" | "exploration" | "speedrun" | "completionist";
-export type PlayerEngagementLevel = "casual" | "regular" | "dedicated" | "hardcore";
-export type PlayerEventCategory = "combat" | "movement" | "interaction" | "progression" | "economy" | "social" | "custom";
-export type PlayerEventSeverity = "low" | "medium" | "high" | "critical";
-
-export interface PlayerBehaviorTelemetryOptions {
-  readonly seed?: number;
-  readonly playerId?: string;
-  readonly sessionSeconds?: number;
-  readonly combatEvents?: number;
-  readonly movementEvents?: number;
-  readonly interactionEvents?: number;
-  readonly progressionEvents?: number;
-  readonly successEvents?: number;
-}
-
-export interface PlayerSkillAssessmentTelemetry {
-  readonly area: string;
-  readonly level: number;
-  readonly confidence: number;
-  readonly sampleSize: number;
-}
-
-export interface PlayerBehaviorPatternTelemetry {
-  readonly name: string;
-  readonly frequency: number;
-  readonly confidence: number;
-}
-
-export interface PlayerBehaviorTelemetryFixture {
-  readonly source: "origin-master-player-profile-event-analysis-adapted";
-  readonly playerId: string;
-  readonly profile: {
-    readonly skillLevel: PlayerSkillLevel;
-    readonly playstyle: PlayerPlaystyle;
-    readonly engagement: PlayerEngagementLevel;
-    readonly skills: readonly PlayerSkillAssessmentTelemetry[];
-    readonly preferences: readonly { readonly category: string; readonly value: string; readonly strength: number }[];
-    readonly patterns: readonly PlayerBehaviorPatternTelemetry[];
-    readonly totalPlaytimeMs: number;
-    readonly sessionCount: number;
-  };
-  readonly events: {
-    readonly total: number;
-    readonly byCategory: Record<PlayerEventCategory, number>;
-    readonly bySeverity: Record<PlayerEventSeverity, number>;
-    readonly successRate: number;
-    readonly avgDurationMs: number;
-    readonly eventsPerMinute: number;
-  };
-  readonly sessionAnalysis: {
-    readonly durationMs: number;
-    readonly dominantPlaystyle: PlayerPlaystyle;
-    readonly skillEstimate: PlayerSkillLevel;
-    readonly insights: readonly {
-      readonly type: string;
-      readonly confidence: number;
-      readonly evidence: readonly string[];
-      readonly recommendations: readonly string[];
-    }[];
-  };
-  readonly productionReadiness: {
-    readonly playerProfileTelemetry: true;
-    readonly eventTrackingTelemetry: true;
-    readonly behaviorPatternTelemetry: true;
-    readonly adaptiveSystemInputTelemetry: true;
-  };
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-export function samplePlayerBehaviorTelemetryFixture(options: PlayerBehaviorTelemetryOptions = {}): PlayerBehaviorTelemetryFixture {
-  const seed = normalizeSeed(options.seed ?? 0xb34a);
-  const playerId = normalizePlayerId(options.playerId ?? "external-parity-runtime-player");
-  const sessionSeconds = positive(options.sessionSeconds ?? 180, "sessionSeconds");
-  const combat = count(options.combatEvents ?? 12, "combatEvents");
-  const movement = count(options.movementEvents ?? 18, "movementEvents");
-  const interaction = count(options.interactionEvents ?? 7, "interactionEvents");
-  const progression = count(options.progressionEvents ?? 5, "progressionEvents");
-  const success = count(options.successEvents ?? 24, "successEvents");
-  const total = combat + movement + interaction + progression;
-  const successRate = Number((success / Math.max(1, total)).toFixed(4));
-  const eventsPerMinute = Number((total / Math.max(1, sessionSeconds / 60)).toFixed(3));
-  const combatRatio = combat / Math.max(1, total);
-  const movementRatio = movement / Math.max(1, total);
-  const interactionRatio = interaction / Math.max(1, total);
-  const progressionRatio = progression / Math.max(1, total);
-  const playstyle = detectPlaystyle({ combatRatio, movementRatio, interactionRatio, progressionRatio, successRate, eventsPerMinute });
-  const skillScore = successRate * 0.4 + Math.min(eventsPerMinute / 10, 1) * 0.3 + Math.min(4 / Math.max(1, total), 1) * 0.3;
-  const skillLevel = skillForScore(skillScore);
-  const engagement = sessionSeconds > 900 ? "hardcore" : sessionSeconds > 420 ? "dedicated" : sessionSeconds > 180 ? "regular" : "casual";
-  const skills: readonly PlayerSkillAssessmentTelemetry[] = [
-    skill("combat", clamp01(successRate * 0.7 + combatRatio * 0.3), combat),
-    skill("navigation", clamp01(0.45 + movementRatio * 0.65), movement),
-    skill("objective-routing", clamp01(0.36 + progressionRatio * 1.1), progression),
-    skill("interaction", clamp01(0.42 + interactionRatio * 1.15), interaction)
-  ];
-  const patterns: readonly PlayerBehaviorPatternTelemetry[] = [
-    { name: `${playstyle}-loop`, frequency: Number(Math.max(1, eventsPerMinute).toFixed(3)), confidence: Number((0.62 + successRate * 0.24).toFixed(3)) },
-    { name: "objective-retry", frequency: Number((Math.max(0, total - success) / Math.max(1, sessionSeconds / 60)).toFixed(3)), confidence: Number((0.5 + (1 - successRate) * 0.32).toFixed(3)) }
-  ];
-  const insights = [
-    {
-      type: "playstyle",
-      confidence: patterns[0]?.confidence ?? 0.6,
-      evidence: [`combat=${combat}`, `movement=${movement}`, `progression=${progression}`],
-      recommendations: [playstyle === "aggressive" ? "offer-combat-optional-objective" : "offer-navigation-shortcut"]
-    },
-    {
-      type: "skill-estimate",
-      confidence: Number((0.58 + skillScore * 0.3).toFixed(3)),
-      evidence: [`successRate=${successRate}`, `eventsPerMinute=${eventsPerMinute}`],
-      recommendations: [skillScore > 0.6 ? "raise-optional-challenge" : "keep-assistive-checkpoints"]
-    }
-  ] as const;
-  const core = {
-    playerId,
-    skillLevel,
-    playstyle,
-    engagement,
-    successRate,
-    eventsPerMinute,
-    skills,
-    patterns,
-    insights
-  };
-  return {
-    source: "origin-master-player-profile-event-analysis-adapted",
-    playerId,
-    profile: {
-      skillLevel,
-      playstyle,
-      engagement,
-      skills,
-      preferences: [
-        { category: "difficulty", value: skillScore > 0.6 ? "advanced" : "adaptive", strength: Number((0.62 + seededUnit(seed) * 0.22).toFixed(3)) },
-        { category: "route", value: movementRatio > combatRatio ? "exploration" : "direct", strength: Number((0.56 + seededUnit(seed ^ 0x2735) * 0.2).toFixed(3)) }
-      ],
-      patterns,
-      totalPlaytimeMs: Math.round(sessionSeconds * 1000),
-      sessionCount: 3 + Math.round(seededUnit(seed ^ 0x9e37) * 4)
-    },
-    events: {
-      total,
-      byCategory: {
-        combat,
-        movement,
-        interaction,
-        progression,
-        economy: 0,
-        social: 0,
-        custom: 0
-      },
-      bySeverity: {
-        low: movement,
-        medium: interaction + progression,
-        high: combat,
-        critical: 0
-      },
-      successRate,
-      avgDurationMs: Number((180 + seededUnit(seed ^ 0xf00d) * 140).toFixed(2)),
-      eventsPerMinute
-    },
-    sessionAnalysis: {
-      durationMs: Math.round(sessionSeconds * 1000),
-      dominantPlaystyle: playstyle,
-      skillEstimate: skillLevel,
-      insights
-    },
-    productionReadiness: {
-      playerProfileTelemetry: true,
-      eventTrackingTelemetry: true,
-      behaviorPatternTelemetry: true,
-      adaptiveSystemInputTelemetry: true
-    },
-    blockedClaims: [
-      "production player modeling certification",
-      "privacy/compliance analytics certification",
-      "cloud telemetry pipeline parity",
-      "Unity Analytics/Remote Config parity",
-      "Unreal Insights gameplay telemetry parity"
-    ],
-    claimBoundary: "This fixture ports old smart PlayerProfile/EventTracker/BehaviorAnalyzer concepts into deterministic local runtime telemetry. It does not claim production player modeling, privacy/compliance analytics certification, cloud telemetry pipelines, Unity Analytics, or Unreal Insights parity.",
-    hash: stableHash(JSON.stringify(core))
-  };
-}
-
-function detectPlaystyle(stats: { readonly combatRatio: number; readonly movementRatio: number; readonly interactionRatio: number; readonly progressionRatio: number; readonly successRate: number; readonly eventsPerMinute: number }): PlayerPlaystyle {
-  if (stats.combatRatio > 0.45 && stats.eventsPerMinute > 8) return "aggressive";
-  if (stats.movementRatio > 0.45 && stats.combatRatio < 0.35) return "exploration";
-  if (stats.successRate > 0.7 && stats.combatRatio < 0.4) return "stealth";
-  if (stats.eventsPerMinute > 10 && stats.progressionRatio > 0.2) return "speedrun";
-  if (stats.interactionRatio > 0.35) return "completionist";
-  if (stats.combatRatio > 0.3 && stats.successRate > 0.6) return "defensive";
-  return "balanced";
-}
-
-function skillForScore(score: number): PlayerSkillLevel {
-  if (score < 0.2) return "beginner";
-  if (score < 0.4) return "novice";
-  if (score < 0.6) return "intermediate";
-  if (score < 0.8) return "advanced";
-  return "expert";
-}
-
-function skill(area: string, level: number, sampleSize: number): PlayerSkillAssessmentTelemetry {
-  return {
-    area,
-    level: Number(level.toFixed(4)),
-    confidence: Number(Math.min(1, Math.max(0.1, sampleSize / 40)).toFixed(3)),
-    sampleSize
-  };
-}
-
-function count(value: number, name: string): number {
-  if (!Number.isFinite(value) || value < 0) throw new Error(`${name} must be a non-negative finite number.`);
-  return Math.trunc(value);
-}
-
-function positive(value: number, name: string): number {
-  if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be a positive finite number.`);
-  return value;
-}
-
-function normalizeSeed(seed: number): number {
-  if (!Number.isInteger(seed) || seed < 0) throw new Error("seed must be a non-negative integer.");
-  return seed >>> 0;
-}
-
-function normalizePlayerId(playerId: string): string {
-  const normalized = playerId.trim();
-  if (normalized.length === 0) throw new Error("playerId is required.");
-  return normalized;
-}
-
-function clamp01(value: number): number {
-  return Math.max(0, Math.min(1, value));
-}
-
-function seededUnit(seed: number): number {
-  let value = seed >>> 0;
-  value ^= value << 13;
-  value ^= value >>> 17;
-  value ^= value << 5;
-  return (value >>> 0) / 0xffffffff;
-}
-
-function stableHash(value: string): string {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}

package/src/ProceduralContentAdaptationFixtures.ts

@@ -1,205 +0,0 @@
-import type { PlayerBehaviorTelemetryFixture, PlayerPlaystyle, PlayerSkillLevel } from "./PlayerBehaviorTelemetryFixtures";
-
-export type GeneratedContentType = "level" | "quest" | "enemy_encounter" | "puzzle" | "reward" | "narrative";
-export type GeneratedContentDifficulty = "trivial" | "easy" | "moderate" | "challenging" | "extreme";
-export type AdaptiveAiStrategy = "mirror" | "counter" | "exploit" | "match_skill" | "challenge";
-
-export interface ProceduralContentAdaptationOptions {
-  readonly seed?: number;
-  readonly playerTelemetry: PlayerBehaviorTelemetryFixture;
-  readonly strategy?: AdaptiveAiStrategy;
-}
-
-export interface GeneratedContentTelemetry {
-  readonly id: string;
-  readonly type: GeneratedContentType;
-  readonly difficulty: GeneratedContentDifficulty;
-  readonly estimatedDurationMs: number;
-  readonly tags: readonly string[];
-  readonly parameters: {
-    readonly size?: number;
-    readonly enemyCount?: number;
-    readonly resourceCount?: number;
-    readonly hasSecretAreas?: boolean;
-    readonly hasTimeLimit?: boolean;
-    readonly layout?: "linear" | "branching";
-    readonly objectiveCount?: number;
-    readonly rewardTier?: string;
-  };
-}
-
-export interface ProceduralContentAdaptationFixture {
-  readonly source: "origin-master-content-generator-adaptive-ai-adapted";
-  readonly content: readonly GeneratedContentTelemetry[];
-  readonly adaptiveAi: {
-    readonly strategy: AdaptiveAiStrategy;
-    readonly behaviorMode: "passive" | "balanced" | "aggressive" | "tactical" | "adaptive";
-    readonly aggression: number;
-    readonly defensiveness: number;
-    readonly tacticalAwareness: number;
-    readonly reactionSpeed: number;
-    readonly accuracy: number;
-    readonly abilityUsage: number;
-    readonly coordination: number;
-  };
-  readonly productionReadiness: {
-    readonly contentGenerationTelemetry: true;
-    readonly playstyleCustomizationTelemetry: true;
-    readonly skillScalingTelemetry: true;
-    readonly adaptiveAiParameterTelemetry: true;
-  };
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-export function sampleProceduralContentAdaptationFixture(options: ProceduralContentAdaptationOptions): ProceduralContentAdaptationFixture {
-  const seed = normalizeSeed(options.seed ?? 0xc067);
-  const profile = options.playerTelemetry.profile;
-  const difficulty = difficultyForSkill(profile.skillLevel);
-  const playstyle = profile.playstyle;
-  const content: readonly GeneratedContentTelemetry[] = [
-    generateLevel(seed, difficulty, playstyle),
-    generateEncounter(seed ^ 0x1138, difficulty, playstyle),
-    generateReward(seed ^ 0x9821, difficulty, profile.skillLevel),
-    generateQuest(seed ^ 0xa77a, difficulty, playstyle)
-  ];
-  const adaptiveAi = adaptiveAiFor(options.strategy ?? "counter", playstyle, profile.skillLevel, options.playerTelemetry.events.successRate);
-  const core = { content, adaptiveAi, playerHash: options.playerTelemetry.hash };
-  return {
-    source: "origin-master-content-generator-adaptive-ai-adapted",
-    content,
-    adaptiveAi,
-    productionReadiness: {
-      contentGenerationTelemetry: true,
-      playstyleCustomizationTelemetry: true,
-      skillScalingTelemetry: true,
-      adaptiveAiParameterTelemetry: true
-    },
-    blockedClaims: [
-      "production procedural content generation parity",
-      "runtime-authored quest/narrative generation",
-      "Unity Adaptive Performance/Game Foundation parity",
-      "Unreal PCG Framework/MassAI parity",
-      "LLM-authored live content generation"
-    ],
-    claimBoundary: "This fixture ports old ContentGenerator/AdaptiveAI concepts into deterministic content-plan and adaptive-parameter telemetry. It does not create production PCG levels, generate live narrative, or claim Unity/Unreal PCG or AI-system parity.",
-    hash: stableHash(JSON.stringify(core))
-  };
-}
-
-function generateLevel(seed: number, difficulty: GeneratedContentDifficulty, playstyle: PlayerPlaystyle): GeneratedContentTelemetry {
-  const multiplier = difficultyMultiplier(difficulty);
-  return {
-    id: "content-level-1",
-    type: "level",
-    difficulty,
-    estimatedDurationMs: Math.round(240000 * multiplier),
-    tags: ["procedural", "level", playstyle],
-    parameters: {
-      size: Math.round(90 * multiplier),
-      enemyCount: playstyle === "stealth" ? Math.round(4 * multiplier) : Math.round(7 * multiplier),
-      resourceCount: playstyle === "exploration" || playstyle === "completionist" ? Math.round(10 * multiplier) : Math.round(6 * multiplier),
-      hasSecretAreas: playstyle === "exploration" || playstyle === "completionist",
-      hasTimeLimit: playstyle === "speedrun",
-      layout: seededUnit(seed) > 0.5 ? "branching" : "linear"
-    }
-  };
-}
-
-function generateEncounter(seed: number, difficulty: GeneratedContentDifficulty, playstyle: PlayerPlaystyle): GeneratedContentTelemetry {
-  const multiplier = difficultyMultiplier(difficulty);
-  return {
-    id: "content-encounter-1",
-    type: "enemy_encounter",
-    difficulty,
-    estimatedDurationMs: Math.round(95000 * multiplier),
-    tags: ["combat", "encounter", playstyle === "defensive" ? "cover" : "pressure"],
-    parameters: {
-      enemyCount: Math.max(1, Math.round((playstyle === "aggressive" ? 6 : 4) * multiplier)),
-      resourceCount: Math.max(1, Math.round((1 + seededUnit(seed) * 3) * multiplier)),
-      layout: playstyle === "defensive" ? "branching" : "linear"
-    }
-  };
-}
-
-function generateReward(seed: number, difficulty: GeneratedContentDifficulty, skill: PlayerSkillLevel): GeneratedContentTelemetry {
-  return {
-    id: "content-reward-1",
-    type: "reward",
-    difficulty,
-    estimatedDurationMs: 0,
-    tags: ["reward", "loot", skill],
-    parameters: {
-      rewardTier: skill === "expert" || skill === "advanced" ? "rare" : seededUnit(seed) > 0.55 ? "uncommon" : "standard",
-      resourceCount: Math.round(2 + seededUnit(seed ^ 0x55aa) * 4)
-    }
-  };
-}
-
-function generateQuest(seed: number, difficulty: GeneratedContentDifficulty, playstyle: PlayerPlaystyle): GeneratedContentTelemetry {
-  return {
-    id: "content-quest-1",
-    type: "quest",
-    difficulty,
-    estimatedDurationMs: Math.round(360000 * difficultyMultiplier(difficulty)),
-    tags: ["quest", playstyle === "exploration" ? "optional" : "objective"],
-    parameters: {
-      objectiveCount: Math.round(2 + seededUnit(seed) * 3),
-      hasSecretAreas: playstyle === "completionist" || playstyle === "exploration"
-    }
-  };
-}
-
-function adaptiveAiFor(strategy: AdaptiveAiStrategy, playstyle: PlayerPlaystyle, skill: PlayerSkillLevel, successRate: number): ProceduralContentAdaptationFixture["adaptiveAi"] {
-  const skillScale = skill === "expert" ? 1 : skill === "advanced" ? 0.85 : skill === "intermediate" ? 0.65 : skill === "novice" ? 0.48 : 0.35;
-  const counterAggression = playstyle === "defensive" || playstyle === "stealth" ? 0.72 : playstyle === "aggressive" ? 0.48 : 0.58;
-  return {
-    strategy,
-    behaviorMode: strategy === "counter" || strategy === "challenge" ? "adaptive" : "balanced",
-    aggression: Number(Math.min(1, counterAggression + skillScale * 0.12).toFixed(3)),
-    defensiveness: Number((playstyle === "aggressive" ? 0.72 : 0.48 + skillScale * 0.16).toFixed(3)),
-    tacticalAwareness: Number((0.42 + skillScale * 0.44).toFixed(3)),
-    reactionSpeed: Number((0.82 + skillScale * 0.38).toFixed(3)),
-    accuracy: Number((0.36 + skillScale * 0.36 + successRate * 0.08).toFixed(3)),
-    abilityUsage: Number((0.3 + skillScale * 0.48).toFixed(3)),
-    coordination: Number((0.38 + skillScale * 0.32).toFixed(3))
-  };
-}
-
-function difficultyForSkill(skill: PlayerSkillLevel): GeneratedContentDifficulty {
-  if (skill === "beginner") return "easy";
-  if (skill === "novice" || skill === "intermediate") return "moderate";
-  if (skill === "advanced") return "challenging";
-  return "extreme";
-}
-
-function difficultyMultiplier(difficulty: GeneratedContentDifficulty): number {
-  if (difficulty === "trivial") return 0.6;
-  if (difficulty === "easy") return 0.8;
-  if (difficulty === "moderate") return 1;
-  if (difficulty === "challenging") return 1.28;
-  return 1.55;
-}
-
-function normalizeSeed(seed: number): number {
-  if (!Number.isInteger(seed) || seed < 0) throw new Error("seed must be a non-negative integer.");
-  return seed >>> 0;
-}
-
-function seededUnit(seed: number): number {
-  let value = seed >>> 0;
-  value ^= value << 13;
-  value ^= value >>> 17;
-  value ^= value << 5;
-  return (value >>> 0) / 0xffffffff;
-}
-
-function stableHash(value: string): string {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}

package/src/ScriptContext.ts

@@ -1,34 +0,0 @@
-import type { BehaviorPhase } from "./Behavior";
-
-export interface ScriptContextOptions {
-  readonly phase: BehaviorPhase;
-  readonly deltaSeconds?: number;
-  readonly fixedDeltaSeconds?: number;
-  readonly target?: unknown;
-  readonly services?: ReadonlyMap<string, unknown>;
-}
-
-export class ScriptContext {
-  readonly phase: BehaviorPhase;
-  readonly deltaSeconds: number;
-  readonly fixedDeltaSeconds: number;
-  readonly target?: unknown;
-
-  private readonly services: ReadonlyMap<string, unknown>;
-
-  constructor(options: ScriptContextOptions) {
-    this.phase = options.phase;
-    this.deltaSeconds = options.deltaSeconds ?? 0;
-    this.fixedDeltaSeconds = options.fixedDeltaSeconds ?? 0;
-    this.target = options.target;
-    this.services = options.services ?? new Map();
-  }
-
-  getService<T>(name: string): T {
-    if (!this.services.has(name)) {
-      throw new Error(`Script service is not available in ${this.phase}: ${name}`);
-    }
-
-    return this.services.get(name) as T;
-  }
-}

package/src/StateMachine.ts

@@ -1,138 +0,0 @@
-import { Blackboard, type BlackboardValue } from "./BehaviorTree";
-
-export type StateTransitionCondition = (blackboard: Blackboard) => boolean;
-
-export interface StateTransition {
-  readonly targetState: string;
-  readonly condition: StateTransitionCondition;
-  readonly priority: number;
-  readonly name: string;
-}
-
-export interface StateMachineSnapshot {
-  readonly running: boolean;
-  readonly currentState: string;
-  readonly previousState: string;
-  readonly tickCount: number;
-  readonly transitionCount: number;
-  readonly history: readonly string[];
-  readonly trace: readonly string[];
-}
-
-export class State {
-  readonly transitions: StateTransition[] = [];
-  onEnter?: (blackboard: Blackboard) => void;
-  onUpdate?: (deltaSeconds: number, blackboard: Blackboard) => void;
-  onExit?: (blackboard: Blackboard) => void;
-
-  constructor(readonly id: string, readonly name = id) {}
-
-  addTransition(targetState: string, condition: StateTransitionCondition, priority = 0, name = `${this.id}->${targetState}`): this {
-    this.transitions.push({ targetState, condition, priority, name });
-    this.transitions.sort((left, right) => right.priority - left.priority || left.name.localeCompare(right.name));
-    return this;
-  }
-}
-
-export class StateMachine {
-  private readonly states = new Map<string, State>();
-  private readonly history: string[] = [];
-  private readonly maxHistorySize: number;
-  private current?: State;
-  private previous?: State;
-  private running = false;
-  private tickCounter = 0;
-  private transitionCounter = 0;
-  private lastTrace: string[] = [];
-
-  constructor(readonly blackboard = new Blackboard(), options: { readonly maxHistorySize?: number } = {}) {
-    this.maxHistorySize = options.maxHistorySize ?? 12;
-  }
-
-  addState(state: State): this {
-    if (this.states.has(state.id)) throw new Error(`State already registered: ${state.id}`);
-    this.states.set(state.id, state);
-    return this;
-  }
-
-  getState(id: string): State | undefined {
-    return this.states.get(id);
-  }
-
-  start(stateId: string): StateMachineSnapshot {
-    const state = this.requireState(stateId);
-    this.running = true;
-    this.current = state;
-    this.previous = undefined;
-    this.lastTrace = [`enter:${state.id}`];
-    state.onEnter?.(this.blackboard);
-    return this.snapshot();
-  }
-
-  stop(): StateMachineSnapshot {
-    if (this.current) {
-      this.current.onExit?.(this.blackboard);
-      this.lastTrace = [`exit:${this.current.id}`, "stop"];
-    } else {
-      this.lastTrace = ["stop"];
-    }
-    this.running = false;
-    this.previous = this.current;
-    this.current = undefined;
-    return this.snapshot();
-  }
-
-  update(deltaSeconds: number): StateMachineSnapshot {
-    this.tickCounter += 1;
-    this.lastTrace = [];
-    if (!this.running || !this.current) {
-      this.lastTrace.push("idle");
-      return this.snapshot();
-    }
-
-    this.current.onUpdate?.(Math.max(0, deltaSeconds), this.blackboard);
-    this.lastTrace.push(`update:${this.current.id}`);
-    const transition = this.current.transitions.find((entry) => entry.condition(this.blackboard));
-    if (transition) {
-      this.transitionTo(transition);
-    }
-    return this.snapshot();
-  }
-
-  set(key: string, value: BlackboardValue): void {
-    this.blackboard.set(key, value);
-  }
-
-  snapshot(): StateMachineSnapshot {
-    return {
-      running: this.running,
-      currentState: this.current?.id ?? "none",
-      previousState: this.previous?.id ?? "none",
-      tickCount: this.tickCounter,
-      transitionCount: this.transitionCounter,
-      history: [...this.history],
-      trace: [...this.lastTrace]
-    };
-  }
-
-  private transitionTo(transition: StateTransition): void {
-    if (!this.current) return;
-    const from = this.current;
-    const to = this.requireState(transition.targetState);
-    from.onExit?.(this.blackboard);
-    this.previous = from;
-    this.current = to;
-    this.transitionCounter += 1;
-    this.history.push(`${from.id}->${to.id}`);
-    while (this.history.length > this.maxHistorySize) this.history.shift();
-    this.lastTrace.push(`transition:${transition.name}`);
-    to.onEnter?.(this.blackboard);
-    this.lastTrace.push(`enter:${to.id}`);
-  }
-
-  private requireState(id: string): State {
-    const state = this.states.get(id);
-    if (!state) throw new Error(`State is not registered: ${id}`);
-    return state;
-  }
-}