@aura3d/scripting 1.4.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura3d/scripting",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "type": "module",
   "exports": {
     ".": {
@@ -9,5 +9,35 @@
     }
   },
   "main": "./dist/index.js",
-  "types": "./dist/index.d.ts"
+  "types": "./dist/index.d.ts",
+  "description": "Behavior attachment, runtime phases, script context data, behavior registries, visual graph validation, graph serialization, and deterministic visual graph execution.",
+  "keywords": [
+    "aura3d",
+    "3d",
+    "browser-3d",
+    "web-3d",
+    "typescript",
+    "scripting",
+    "visual-scripting",
+    "behavior-tree",
+    "runtime-scripting",
+    "node-graph"
+  ],
+  "homepage": "https://aura3d.auraone.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auraoneai/aura3d.git",
+    "directory": "packages/scripting"
+  },
+  "bugs": {
+    "url": "https://github.com/auraoneai/aura3d/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ]
 }

package/src/AdaptiveDifficultyFixtures.ts

@@ -1,324 +0,0 @@
-export type AdaptiveDifficultyMetricType =
-  | "win-rate"
-  | "death-rate"
-  | "completion-time"
-  | "damage-taken"
-  | "damage-dealt"
-  | "accuracy"
-  | "resource-efficiency"
-  | "progression-rate"
-  | "retry-count";
-
-export type AdaptiveDifficultyStrategy = "gradual" | "immediate" | "predictive" | "manual";
-
-export type AdaptiveDifficultyChangeType =
-  | "enemy-health"
-  | "enemy-damage"
-  | "enemy-count"
-  | "resource-drop-rate"
-  | "experience-multiplier"
-  | "timer-multiplier"
-  | "checkpoint-frequency";
-
-export interface AdaptiveDifficultyFixtureOptions {
-  readonly strategy?: AdaptiveDifficultyStrategy;
-  readonly recentDeaths?: number;
-  readonly completionTimeSeconds?: number;
-  readonly accuracy?: number;
-  readonly resourceEfficiency?: number;
-  readonly progressionRate?: number;
-  readonly playerSkill?: number;
-  readonly seed?: number;
-}
-
-export interface AdaptiveDifficultyMetricSummary {
-  readonly type: AdaptiveDifficultyMetricType;
-  readonly count: number;
-  readonly mean: number;
-  readonly median: number;
-  readonly standardDeviation: number;
-  readonly min: number;
-  readonly max: number;
-  readonly recentTrend: "improving" | "stable" | "declining";
-}
-
-export interface AdaptiveDifficultyTriggeredRule {
-  readonly id: string;
-  readonly metric: AdaptiveDifficultyMetricType;
-  readonly strategy: AdaptiveDifficultyStrategy;
-  readonly changeType: AdaptiveDifficultyChangeType;
-  readonly target: number;
-  readonly threshold: number;
-  readonly rawMultiplier: number;
-  readonly appliedMultiplier: number;
-  readonly cooldownSeconds: number;
-  readonly reason: string;
-}
-
-export interface AdaptiveDifficultyAdjustment {
-  readonly enemyHealth: number;
-  readonly enemyDamage: number;
-  readonly enemyCount: number;
-  readonly resourceDropRate: number;
-  readonly experienceMultiplier: number;
-  readonly timerMultiplier: number;
-  readonly checkpointMultiplier: number;
-}
-
-export interface AdaptiveDifficultyFixture {
-  readonly id: "external-parity-old-branch-adaptive-difficulty-fixture";
-  readonly source: "origin-master-ai-balancing-smart-difficulty-adapted";
-  readonly strategy: AdaptiveDifficultyStrategy;
-  readonly metrics: readonly AdaptiveDifficultyMetricSummary[];
-  readonly triggeredRules: readonly AdaptiveDifficultyTriggeredRule[];
-  readonly adjustment: AdaptiveDifficultyAdjustment;
-  readonly appliedChangeCount: number;
-  readonly blockedClaims: readonly string[];
-  readonly hash: string;
-  readonly claimBoundary: string;
-}
-
-type RuleDefinition = {
-  readonly id: string;
-  readonly metric: AdaptiveDifficultyMetricType;
-  readonly changeType: AdaptiveDifficultyChangeType;
-  readonly direction: "above" | "below";
-  readonly threshold: number;
-  readonly multiplier: number;
-  readonly target: number;
-  readonly reason: string;
-};
-
-const rules: readonly RuleDefinition[] = [
-  {
-    id: "death-rate-relief",
-    metric: "death-rate",
-    changeType: "enemy-damage",
-    direction: "above",
-    threshold: 0.34,
-    multiplier: 0.82,
-    target: 0.18,
-    reason: "Recent deaths exceed the bounded comfort threshold, so incoming damage is softened."
-  },
-  {
-    id: "slow-completion-timer",
-    metric: "completion-time",
-    changeType: "timer-multiplier",
-    direction: "above",
-    threshold: 92,
-    multiplier: 1.18,
-    target: 72,
-    reason: "Completion time is above target, so objective timers are relaxed."
-  },
-  {
-    id: "low-accuracy-resource-support",
-    metric: "accuracy",
-    changeType: "resource-drop-rate",
-    direction: "below",
-    threshold: 0.46,
-    multiplier: 1.22,
-    target: 0.58,
-    reason: "Accuracy is below target, so health/ammo resource availability is raised."
-  },
-  {
-    id: "high-skill-enemy-presence",
-    metric: "win-rate",
-    changeType: "enemy-count",
-    direction: "above",
-    threshold: 0.72,
-    multiplier: 1.1,
-    target: 0.58,
-    reason: "Win rate is above target, so bounded encounter density can increase."
-  },
-  {
-    id: "resource-efficiency-reward",
-    metric: "resource-efficiency",
-    changeType: "experience-multiplier",
-    direction: "above",
-    threshold: 0.68,
-    multiplier: 1.08,
-    target: 0.56,
-    reason: "Resource efficiency is above target, so reward pacing is slightly increased."
-  },
-  {
-    id: "retry-checkpoint-support",
-    metric: "retry-count",
-    changeType: "checkpoint-frequency",
-    direction: "above",
-    threshold: 2.4,
-    multiplier: 1.2,
-    target: 1.4,
-    reason: "Retry count is high, so checkpoint spacing is tightened."
-  }
-];
-
-export function sampleAdaptiveDifficultyFixture(options: AdaptiveDifficultyFixtureOptions = {}): AdaptiveDifficultyFixture {
-  const strategy = options.strategy ?? "gradual";
-  const seed = integer(options.seed ?? 0x3d2025, "seed");
-  const playerSkill = clamp01(finite(options.playerSkill ?? 0.42, "playerSkill"));
-  const recentDeaths = clamp(finite(options.recentDeaths ?? 3, "recentDeaths"), 0, 12);
-  const completionTimeSeconds = clamp(finite(options.completionTimeSeconds ?? 108, "completionTimeSeconds"), 15, 420);
-  const accuracy = clamp01(finite(options.accuracy ?? 0.41, "accuracy"));
-  const resourceEfficiency = clamp01(finite(options.resourceEfficiency ?? 0.74, "resourceEfficiency"));
-  const progressionRate = clamp01(finite(options.progressionRate ?? 0.52, "progressionRate"));
-
-  const metricSamples = {
-    "win-rate": sampleSeries(0.34 + playerSkill * 0.44, 0.06, seed, 0),
-    "death-rate": sampleSeries(recentDeaths / 8, 0.09, seed, 11),
-    "completion-time": sampleSeries(completionTimeSeconds, 8.5, seed, 23),
-    "damage-taken": sampleSeries(0.56 + recentDeaths * 0.045, 0.08, seed, 37),
-    "damage-dealt": sampleSeries(0.42 + accuracy * 0.45, 0.06, seed, 41),
-    accuracy: sampleSeries(accuracy, 0.045, seed, 53),
-    "resource-efficiency": sampleSeries(resourceEfficiency, 0.05, seed, 61),
-    "progression-rate": sampleSeries(progressionRate, 0.07, seed, 71),
-    "retry-count": sampleSeries(recentDeaths * 0.75, 0.28, seed, 83)
-  } satisfies Record<AdaptiveDifficultyMetricType, readonly number[]>;
-
-  const metrics = (Object.keys(metricSamples) as AdaptiveDifficultyMetricType[]).map((type) => summarizeMetric(type, metricSamples[type]));
-  const byType = new Map(metrics.map((metric) => [metric.type, metric]));
-  const triggeredRules = rules
-    .filter((rule) => ruleTriggered(byType.get(rule.metric), rule))
-    .map((rule, index) => triggeredRule(rule, strategy, index));
-  const adjustment = applyRules(triggeredRules);
-
-  return {
-    id: "external-parity-old-branch-adaptive-difficulty-fixture",
-    source: "origin-master-ai-balancing-smart-difficulty-adapted",
-    strategy,
-    metrics,
-    triggeredRules,
-    adjustment,
-    appliedChangeCount: triggeredRules.length,
-    blockedClaims: [
-      "production dynamic difficulty adjustment service",
-      "machine-learning or reinforcement-learning personalization",
-      "player-profile telemetry backend",
-      "live economy balancing",
-      "Unity/Unreal AI middleware parity"
-    ],
-    hash: stableHash([
-      strategy,
-      ...metrics.map((metric) => `${metric.type}:${metric.mean}:${metric.recentTrend}`),
-      ...triggeredRules.map((rule) => `${rule.id}:${rule.appliedMultiplier}`),
-      Object.values(adjustment).join(":")
-    ].join("|")),
-    claimBoundary: "Deterministic adaptive-difficulty metric/rule telemetry adapted from old balancing and smart difficulty concepts; this is bounded runtime evidence, not production DDA, ML personalization, telemetry backend, live economy balancing, or Unity/Unreal AI middleware parity."
-  };
-}
-
-function summarizeMetric(type: AdaptiveDifficultyMetricType, values: readonly number[]): AdaptiveDifficultyMetricSummary {
-  const sorted = [...values].sort((left, right) => left - right);
-  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
-  const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length;
-  const firstHalf = values.slice(0, Math.max(1, Math.floor(values.length / 2)));
-  const secondHalf = values.slice(Math.floor(values.length / 2));
-  const firstMean = firstHalf.reduce((sum, value) => sum + value, 0) / firstHalf.length;
-  const secondMean = secondHalf.reduce((sum, value) => sum + value, 0) / secondHalf.length;
-  const trendDelta = secondMean - firstMean;
-  return {
-    type,
-    count: values.length,
-    mean: round(mean),
-    median: round(sorted[Math.floor(sorted.length / 2)] ?? mean),
-    standardDeviation: round(Math.sqrt(variance)),
-    min: round(sorted[0] ?? mean),
-    max: round(sorted[sorted.length - 1] ?? mean),
-    recentTrend: Math.abs(trendDelta) < 0.025 ? "stable" : isLowerBetter(type) ? trendDelta < 0 ? "improving" : "declining" : trendDelta > 0 ? "improving" : "declining"
-  };
-}
-
-function triggeredRule(rule: RuleDefinition, strategy: AdaptiveDifficultyStrategy, index: number): AdaptiveDifficultyTriggeredRule {
-  const smoothing = strategy === "immediate" ? 1 : strategy === "predictive" ? 0.72 : strategy === "manual" ? 0 : 0.55;
-  const appliedMultiplier = strategy === "manual" ? 1 : 1 + (rule.multiplier - 1) * smoothing;
-  return {
-    id: rule.id,
-    metric: rule.metric,
-    strategy,
-    changeType: rule.changeType,
-    target: rule.target,
-    threshold: rule.threshold,
-    rawMultiplier: rule.multiplier,
-    appliedMultiplier: round(appliedMultiplier),
-    cooldownSeconds: 12 + index * 4,
-    reason: rule.reason
-  };
-}
-
-function applyRules(triggeredRules: readonly AdaptiveDifficultyTriggeredRule[]): AdaptiveDifficultyAdjustment {
-  const adjustment: AdaptiveDifficultyAdjustment = {
-    enemyHealth: 1,
-    enemyDamage: 1,
-    enemyCount: 1,
-    resourceDropRate: 1,
-    experienceMultiplier: 1,
-    timerMultiplier: 1,
-    checkpointMultiplier: 1
-  };
-  const mutable = { ...adjustment };
-  for (const rule of triggeredRules) {
-    if (rule.changeType === "enemy-health") mutable.enemyHealth *= rule.appliedMultiplier;
-    else if (rule.changeType === "enemy-damage") mutable.enemyDamage *= rule.appliedMultiplier;
-    else if (rule.changeType === "enemy-count") mutable.enemyCount *= rule.appliedMultiplier;
-    else if (rule.changeType === "resource-drop-rate") mutable.resourceDropRate *= rule.appliedMultiplier;
-    else if (rule.changeType === "experience-multiplier") mutable.experienceMultiplier *= rule.appliedMultiplier;
-    else if (rule.changeType === "timer-multiplier") mutable.timerMultiplier *= rule.appliedMultiplier;
-    else mutable.checkpointMultiplier *= rule.appliedMultiplier;
-  }
-  return {
-    enemyHealth: round(mutable.enemyHealth),
-    enemyDamage: round(mutable.enemyDamage),
-    enemyCount: round(mutable.enemyCount),
-    resourceDropRate: round(mutable.resourceDropRate),
-    experienceMultiplier: round(mutable.experienceMultiplier),
-    timerMultiplier: round(mutable.timerMultiplier),
-    checkpointMultiplier: round(mutable.checkpointMultiplier)
-  };
-}
-
-function ruleTriggered(metric: AdaptiveDifficultyMetricSummary | undefined, rule: RuleDefinition): boolean {
-  if (!metric) return false;
-  return rule.direction === "above" ? metric.mean > rule.threshold : metric.mean < rule.threshold;
-}
-
-function sampleSeries(center: number, amplitude: number, seed: number, salt: number): readonly number[] {
-  return Array.from({ length: 9 }, (_, index) => {
-    const wave = Math.sin((seed + salt + index * 17) * 0.37) * amplitude;
-    const drift = (index - 4) * amplitude * 0.08;
-    return round(Math.max(0, center + wave + drift));
-  });
-}
-
-function isLowerBetter(type: AdaptiveDifficultyMetricType): boolean {
-  return type === "death-rate" || type === "completion-time" || type === "damage-taken" || type === "retry-count";
-}
-
-function stableHash(value: string): string {
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-
-function integer(value: number, label: string): number {
-  if (!Number.isInteger(value)) throw new RangeError(`Adaptive difficulty fixture ${label} must be an integer.`);
-  return value;
-}
-
-function finite(value: number, label: string): number {
-  if (!Number.isFinite(value)) throw new RangeError(`Adaptive difficulty fixture ${label} must be finite.`);
-  return value;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-function clamp01(value: number): number {
-  return clamp(value, 0, 1);
-}
-
-function round(value: number): number {
-  return Number(value.toFixed(4));
-}

package/src/AnalyticsPrivacyFixtures.ts

@@ -1,182 +0,0 @@
-export type AnalyticsConsentCategory = "necessary" | "analytics" | "marketing" | "preferences";
-export type AnalyticsProviderMode = "console" | "batched-local" | "disabled";
-
-export interface AnalyticsPrivacyFixtureOptions {
-  readonly seed?: number;
-  readonly userId?: string;
-  readonly sessionId?: string;
-  readonly frameMs?: number;
-  readonly eventCount?: number;
-  readonly errorCount?: number;
-  readonly analyticsConsent?: boolean;
-  readonly marketingConsent?: boolean;
-}
-
-export interface AnalyticsPrivacyFixture {
-  readonly source: "origin-master-analytics-privacy-adapted";
-  readonly consent: {
-    readonly version: "1.0";
-    readonly explicitRequired: true;
-    readonly categories: Record<AnalyticsConsentCategory, boolean>;
-    readonly grantedCount: number;
-    readonly deniedCount: number;
-    readonly changeEvents: readonly { readonly category: AnalyticsConsentCategory; readonly granted: boolean; readonly previous: boolean }[];
-  };
-  readonly anonymization: {
-    readonly userHash: string;
-    readonly sessionHash: string;
-    readonly emailRedacted: true;
-    readonly tokenRedacted: true;
-    readonly ipAnonymized: string;
-    readonly piiPatternHits: number;
-  };
-  readonly batching: {
-    readonly providerMode: AnalyticsProviderMode;
-    readonly maxBatchSize: number;
-    readonly queuedEvents: number;
-    readonly flushedBatches: number;
-    readonly offlineQueueEnabled: true;
-    readonly blockedWithoutConsent: number;
-  };
-  readonly metrics: {
-    readonly frameMs: number;
-    readonly fps: number;
-    readonly errorCount: number;
-    readonly errorsPerMinute: number;
-    readonly loadEvents: number;
-    readonly customMetricCount: number;
-  };
-  readonly productionReadiness: {
-    readonly consentTelemetry: true;
-    readonly anonymizationTelemetry: true;
-    readonly batchingTelemetry: true;
-    readonly metricsTelemetry: true;
-    readonly providerBoundaryTelemetry: true;
-  };
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-export function sampleAnalyticsPrivacyFixture(options: AnalyticsPrivacyFixtureOptions = {}): AnalyticsPrivacyFixture {
-  const seed = normalizeSeed(options.seed ?? 0xa11a);
-  const userId = normalizeText(options.userId ?? "external-parity-runtime-player", "userId");
-  const sessionId = normalizeText(options.sessionId ?? "runtime-session", "sessionId");
-  const frameMs = positive(options.frameMs ?? 16.7, "frameMs");
-  const eventCount = count(options.eventCount ?? 24, "eventCount");
-  const errorCount = count(options.errorCount ?? 0, "errorCount");
-  const analyticsConsent = options.analyticsConsent ?? true;
-  const marketingConsent = options.marketingConsent ?? false;
-  const categories: Record<AnalyticsConsentCategory, boolean> = {
-    necessary: true,
-    analytics: analyticsConsent,
-    marketing: marketingConsent,
-    preferences: true
-  };
-  const consentValues = Object.values(categories);
-  const blockedWithoutConsent = analyticsConsent ? 0 : eventCount;
-  const queuedEvents = analyticsConsent ? Math.min(eventCount, 50) : 0;
-  const flushedBatches = analyticsConsent ? Math.ceil(queuedEvents / 10) : 0;
-  const fps = Number((1000 / frameMs).toFixed(2));
-  const fixture: Omit<AnalyticsPrivacyFixture, "hash"> = {
-    source: "origin-master-analytics-privacy-adapted",
-    consent: {
-      version: "1.0",
-      explicitRequired: true,
-      categories,
-      grantedCount: consentValues.filter(Boolean).length,
-      deniedCount: consentValues.filter((granted) => !granted).length,
-      changeEvents: [
-        { category: "analytics", granted: analyticsConsent, previous: false },
-        { category: "preferences", granted: true, previous: false }
-      ]
-    },
-    anonymization: {
-      userHash: stableHash(`user:${userId}:analytics`),
-      sessionHash: stableHash(`session:${sessionId}:analytics`),
-      emailRedacted: true,
-      tokenRedacted: true,
-      ipAnonymized: anonymizeIp(`198.51.${Math.floor(seededUnit(seed) * 100)}.${Math.floor(seededUnit(seed ^ 0x1979) * 240)}`),
-      piiPatternHits: 3
-    },
-    batching: {
-      providerMode: analyticsConsent ? "batched-local" : "disabled",
-      maxBatchSize: 50,
-      queuedEvents,
-      flushedBatches,
-      offlineQueueEnabled: true,
-      blockedWithoutConsent
-    },
-    metrics: {
-      frameMs: Number(frameMs.toFixed(3)),
-      fps,
-      errorCount,
-      errorsPerMinute: Number((errorCount / 3).toFixed(3)),
-      loadEvents: 3 + Math.floor(seededUnit(seed ^ 0x441) * 3),
-      customMetricCount: 4
-    },
-    productionReadiness: {
-      consentTelemetry: true,
-      anonymizationTelemetry: true,
-      batchingTelemetry: true,
-      metricsTelemetry: true,
-      providerBoundaryTelemetry: true
-    },
-    blockedClaims: [
-      "GDPR/CCPA compliance certification",
-      "production analytics SaaS integration",
-      "real provider delivery guarantees",
-      "cross-device identity graph",
-      "Unity Analytics parity",
-      "Unreal Insights/Analytics parity"
-    ],
-    claimBoundary: "This fixture ports old analytics, consent, anonymization, batching, and metrics concepts into deterministic local telemetry. It does not send analytics events, certify privacy compliance, integrate a production provider, or claim Unity Analytics or Unreal Insights parity."
-  };
-  return {
-    ...fixture,
-    hash: stableHash(JSON.stringify(fixture))
-  };
-}
-
-function anonymizeIp(ip: string): string {
-  const octets = ip.split(".");
-  return `${octets[0] ?? "0"}.${octets[1] ?? "0"}.${octets[2] ?? "0"}.0`;
-}
-
-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 normalizeText(value: string, name: string): string {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) throw new Error(`${name} must not be empty.`);
-  return trimmed;
-}
-
-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 count(value: number, name: string): number {
-  if (!Number.isInteger(value) || value < 0) throw new Error(`${name} must be a non-negative integer.`);
-  return 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/AnimationNodeCategories.ts

@@ -1,10 +0,0 @@
-export const animationNodeCategories = [
-  "scene",
-  "dialogue",
-  "camera",
-  "audio",
-  "timing",
-  "publishing"
-] as const;
-
-export type AnimationNodeCategory = (typeof animationNodeCategories)[number];

package/src/AnimationVisualNodes.ts

@@ -1,44 +0,0 @@
-import type { VisualNodeDefinition } from "./VisualNodeCatalog";
-
-const flowInput = () => ({ id: "in", direction: "input" as const, type: "flow" as const, optional: true });
-const stringInput = (id: string, optional = false) => ({ id, direction: "input" as const, type: "string" as const, ...(optional ? { optional: true } : {}) });
-const numberInput = (id: string, defaultValue = 0) => ({ id, direction: "input" as const, type: "number" as const, defaultValue });
-const objectInput = (id: string, optional = false) => ({ id, direction: "input" as const, type: "object" as const, ...(optional ? { optional: true } : {}) });
-const commandOutputs = () => [{ id: "out", direction: "output" as const, type: "flow" as const }, { id: "command", direction: "output" as const, type: "object" as const }];
-
-export const animationVisualNodeDefinitions: readonly VisualNodeDefinition[] = [
-  node("setScene", "scene", "Set Scene", "Switch to a named animation scene.", [flowInput(), stringInput("sceneId")]),
-  node("transitionTo", "scene", "Transition To", "Transition to a animation scene with a named transition.", [flowInput(), stringInput("sceneId"), stringInput("transition", true), numberInput("duration", 0.5)]),
-  node("loadSet", "scene", "Load Set", "Load a animation set asset into the episode scene.", [flowInput(), stringInput("setId")]),
-  node("spawnCharacter", "scene", "Spawn Character", "Spawn a character asset at a scene position.", [flowInput(), stringInput("characterId"), objectInput("position", true)]),
-  node("sayLine", "dialogue", "Say Line", "Schedule a dialogue line for a speaker.", [flowInput(), stringInput("speakerId"), stringInput("text"), stringInput("emotion", true)]),
-  node("waitForResponse", "dialogue", "Wait For Response", "Block until a response beat or timeout.", [flowInput(), stringInput("speakerId", true), numberInput("timeout", 1)]),
-  node("setEmotion", "dialogue", "Set Emotion", "Set a character performance emotion.", [flowInput(), stringInput("characterId"), stringInput("emotion")]),
-  node("setGesture", "dialogue", "Set Gesture", "Set a character performance gesture.", [flowInput(), stringInput("characterId"), stringInput("gestureId")]),
-  node("animationCutTo", "camera", "Animation Cut To", "Cut to a named animation camera preset.", [flowInput(), stringInput("presetId"), stringInput("targetId", true)]),
-  node("dollyTo", "camera", "Dolly To", "Dolly the camera to a target framing.", [flowInput(), objectInput("position"), numberInput("duration", 1)]),
-  node("frameCharacter", "camera", "Frame Character", "Frame a character with composition rules.", [flowInput(), stringInput("characterId"), stringInput("composition", true)]),
-  node("shakeCamera", "camera", "Shake Camera", "Add animation camera shake.", [flowInput(), numberInput("intensity", 0.2), numberInput("duration", 0.25)]),
-  node("playMusic", "audio", "Play Music", "Start a music cue.", [flowInput(), stringInput("musicId"), numberInput("volume", 1)]),
-  node("stopMusic", "audio", "Stop Music", "Stop the current music cue.", [flowInput(), stringInput("musicId", true)]),
-  node("playSfx", "audio", "Play SFX", "Play a sound effect cue.", [flowInput(), stringInput("sfxId"), numberInput("volume", 1)]),
-  node("setVolume", "audio", "Set Volume", "Set an audio bus volume.", [flowInput(), stringInput("busId"), numberInput("volume", 1)]),
-  node("waitForBeat", "timing", "Wait For Beat", "Wait for a named story beat.", [flowInput(), stringInput("beatId")]),
-  node("syncToAudio", "timing", "Sync To Audio", "Synchronize downstream actions to an audio timestamp.", [flowInput(), stringInput("audioId"), numberInput("time", 0)]),
-  node("delay", "timing", "Delay", "Delay a animation action by seconds.", [flowInput(), numberInput("duration", 1)]),
-  node("schedule", "timing", "Schedule", "Schedule a animation command at a timeline time.", [flowInput(), numberInput("time", 0), stringInput("label", true)]),
-  node("captureThumbnail", "publishing", "Capture Thumbnail", "Mark a thumbnail capture time.", [flowInput(), numberInput("time", 0), stringInput("path", true)]),
-  node("exportCaption", "publishing", "Export Caption", "Export a caption track in VTT or SRT format.", [flowInput(), stringInput("format", true), stringInput("path", true)]),
-  node("markChapter", "publishing", "Mark Chapter", "Create a video chapter marker.", [flowInput(), stringInput("title"), numberInput("time", 0)])
-];
-
-function node(kind: string, category: VisualNodeDefinition["category"], title: string, description: string, inputs: VisualNodeDefinition["ports"]): VisualNodeDefinition {
-  return {
-    kind,
-    category,
-    title,
-    description,
-    ports: [...inputs, ...commandOutputs()],
-    oldBranchSource: ["packages/scripting/src/AnimationVisualNodes.ts"]
-  };
-}

package/src/Behavior.ts

@@ -1,11 +0,0 @@
-import type { ScriptContext } from "./ScriptContext";
-
-export interface Behavior {
-  enabled?: boolean;
-  onStart?(context: ScriptContext): void | Promise<void>;
-  onFixedUpdate?(context: ScriptContext): void | Promise<void>;
-  onUpdate?(context: ScriptContext): void | Promise<void>;
-  onDestroy?(context: ScriptContext): void | Promise<void>;
-}
-
-export type BehaviorPhase = "start" | "fixed" | "update" | "destroy";

package/src/BehaviorHost.ts

@@ -1,51 +0,0 @@
-import type { Behavior } from "./Behavior";
-import { ScriptContext } from "./ScriptContext";
-
-export interface BehaviorHostOptions {
-  readonly target?: unknown;
-}
-
-export class BehaviorHost {
-  readonly target?: unknown;
-  private readonly behaviors = new Set<Behavior>();
-  private destroyed = false;
-
-  constructor(options: BehaviorHostOptions = {}) {
-    this.target = options.target;
-  }
-
-  get isDestroyed(): boolean {
-    return this.destroyed;
-  }
-
-  attach(behavior: Behavior): void {
-    this.assertAlive();
-    this.behaviors.add(behavior);
-  }
-
-  detach(behavior: Behavior): boolean {
-    return this.behaviors.delete(behavior);
-  }
-
-  list(): readonly Behavior[] {
-    return [...this.behaviors];
-  }
-
-  async destroy(services?: ReadonlyMap<string, unknown>): Promise<void> {
-    if (this.destroyed) {
-      return;
-    }
-    this.destroyed = true;
-    const context = new ScriptContext({ phase: "destroy", target: this.target, services });
-    for (const behavior of [...this.behaviors]) {
-      await behavior.onDestroy?.(context);
-    }
-    this.behaviors.clear();
-  }
-
-  private assertAlive(): void {
-    if (this.destroyed) {
-      throw new Error("Cannot attach behavior to a destroyed host");
-    }
-  }
-}