@almadar/std 1.0.15 → 2.1.0

package/dist/index.js

@@ -10,7 +10,8 @@ var STD_MODULES = [
   "async",
   "nn",
   "tensor",
-  "train"
+  "train",
+  "prob"
 ];
 var STD_OPERATOR_CATEGORIES = [
   "std-math",
@@ -23,7 +24,8 @@ var STD_OPERATOR_CATEGORIES = [
   "std-async",
   "std-nn",
   "std-tensor",
-  "std-train"
+  "std-train",
+  "std-prob"
 ];
 function isStdCategory(category) {
   return STD_OPERATOR_CATEGORIES.includes(category);
@@ -2142,12 +2144,29 @@ var ASYNC_OPERATORS = {
     module: "async",
     category: "std-async",
     minArity: 1,
-    maxArity: 1,
-    description: "Wait for specified milliseconds",
+    maxArity: 2,
+    description: "Wait for specified milliseconds, optionally execute an effect after",
     hasSideEffects: true,
-    returnType: "void",
-    params: [{ name: "ms", type: "number", description: "Milliseconds to wait" }],
-    example: '["async/delay", 2000] // Wait 2 seconds'
+    returnType: "any",
+    params: [
+      { name: "ms", type: "number", description: "Milliseconds to wait" },
+      { name: "effect", type: "expression", description: "Optional effect to execute after delay" }
+    ],
+    example: '["async/delay", 2000, ["emit", "RETRY"]] // Wait 2s then emit'
+  },
+  "async/interval": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: 2,
+    description: "Execute an effect periodically at a fixed interval",
+    hasSideEffects: true,
+    returnType: "string",
+    params: [
+      { name: "ms", type: "number", description: "Interval in milliseconds" },
+      { name: "effect", type: "expression", description: "Effect to execute each interval" }
+    ],
+    example: '["async/interval", 5000, ["emit", "POLL_TICK"]] // Emit every 5s'
   },
   "async/timeout": {
     module: "async",
@@ -3148,6 +3167,229 @@ var TRAIN_OPERATORS = {
   }
 };
 
+// modules/prob.ts
+var PROB_OPERATORS = {
+  // ========================================
+  // Distribution Sampling
+  // ========================================
+  "prob/seed": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 1,
+    maxArity: 1,
+    description: "Set seeded PRNG for deterministic probabilistic sampling",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [{ name: "n", type: "number", description: "Seed value (integer)" }],
+    example: '["prob/seed", 42]'
+  },
+  "prob/flip": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 1,
+    maxArity: 1,
+    description: "Bernoulli trial: returns true with probability p",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "p", type: "number", description: "Probability of true (0 to 1)" }],
+    example: '["prob/flip", 0.5] // => true or false with equal probability'
+  },
+  "prob/gaussian": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Sample from a Gaussian (normal) distribution",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "mu", type: "number", description: "Mean" },
+      { name: "sigma", type: "number", description: "Standard deviation" }
+    ],
+    example: '["prob/gaussian", 0, 1] // => standard normal sample'
+  },
+  "prob/uniform": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Sample from a uniform distribution [lo, hi)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "lo", type: "number", description: "Lower bound (inclusive)" },
+      { name: "hi", type: "number", description: "Upper bound (exclusive)" }
+    ],
+    example: '["prob/uniform", 0, 10] // => number in [0, 10)'
+  },
+  "prob/beta": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Sample from a Beta(alpha, beta) distribution",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "alpha", type: "number", description: "Alpha shape parameter (> 0)" },
+      { name: "beta", type: "number", description: "Beta shape parameter (> 0)" }
+    ],
+    example: '["prob/beta", 2, 5] // => number in [0, 1], mean ~ 0.286'
+  },
+  "prob/categorical": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Weighted random selection from items",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "items", type: "array", description: "Array of items to choose from" },
+      { name: "weights", type: "number[]", description: "Array of weights (same length as items)" }
+    ],
+    example: '["prob/categorical", ["a", "b", "c"], [1, 2, 1]] // => "b" most likely'
+  },
+  "prob/poisson": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 1,
+    maxArity: 1,
+    description: "Sample from a Poisson distribution",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "lambda", type: "number", description: "Rate parameter (> 0)" }],
+    example: '["prob/poisson", 4] // => non-negative integer, mean ~ 4'
+  },
+  // ========================================
+  // Inference
+  // ========================================
+  "prob/condition": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 1,
+    maxArity: 1,
+    description: "Mark current sample as rejected if predicate is false",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [{ name: "predicate", type: "boolean", description: "Condition that must hold" }],
+    example: '["prob/condition", [">", "@entity.x", 0]]'
+  },
+  "prob/sample": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Evaluate an expression n times and collect results",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "n", type: "number", description: "Number of samples" },
+      { name: "expr", type: "SExpr", description: "Expression to evaluate (lazy)" }
+    ],
+    example: '["prob/sample", 1000, ["prob/flip", 0.5]] // => array of booleans'
+  },
+  "prob/posterior": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 4,
+    maxArity: 4,
+    description: "Rejection sampling: returns accepted query values",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "model", type: "SExpr", description: "Model expression (lazy, may call set/condition)" },
+      { name: "evidence", type: "SExpr", description: "Evidence expression (lazy, boolean)" },
+      { name: "query", type: "SExpr", description: "Query expression (lazy, value to collect)" },
+      { name: "n", type: "number", description: "Number of samples to attempt" }
+    ],
+    example: '["prob/posterior", model, evidence, query, 5000]'
+  },
+  "prob/infer": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 4,
+    maxArity: 4,
+    description: "Like posterior but returns {mean, variance, samples, acceptRate}",
+    hasSideEffects: false,
+    returnType: "object",
+    params: [
+      { name: "model", type: "SExpr", description: "Model expression (lazy)" },
+      { name: "evidence", type: "SExpr", description: "Evidence expression (lazy, boolean)" },
+      { name: "query", type: "SExpr", description: "Query expression (lazy)" },
+      { name: "n", type: "number", description: "Number of samples to attempt" }
+    ],
+    example: '["prob/infer", model, evidence, query, 5000]'
+  },
+  // ========================================
+  // Statistics
+  // ========================================
+  "prob/expected-value": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 1,
+    maxArity: 1,
+    description: "Mean of numeric samples",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "samples", type: "number[]", description: "Array of numeric samples" }],
+    example: '["prob/expected-value", [2, 4, 6, 8]] // => 5'
+  },
+  "prob/variance": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 1,
+    maxArity: 1,
+    description: "Population variance of numeric samples",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "samples", type: "number[]", description: "Array of numeric samples" }],
+    example: '["prob/variance", [2, 4, 4, 4, 5, 5, 7, 9]] // => 4'
+  },
+  "prob/histogram": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Bin numeric samples into a histogram",
+    hasSideEffects: false,
+    returnType: "object",
+    params: [
+      { name: "samples", type: "number[]", description: "Array of numeric samples" },
+      { name: "bins", type: "number", description: "Number of bins" }
+    ],
+    example: '["prob/histogram", [1, 2, 3, 4, 5], 2] // => {binEdges, counts}'
+  },
+  "prob/percentile": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get the p-th percentile (0-100) from samples",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "samples", type: "number[]", description: "Array of numeric samples" },
+      { name: "p", type: "number", description: "Percentile (0 to 100)" }
+    ],
+    example: '["prob/percentile", [1, 2, 3, 4, 5], 50] // => 3'
+  },
+  "prob/credible-interval": {
+    module: "prob",
+    category: "std-prob",
+    minArity: 2,
+    maxArity: 2,
+    description: "Compute symmetric credible interval from samples",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "samples", type: "number[]", description: "Array of numeric samples" },
+      { name: "alpha", type: "number", description: "Significance level (e.g., 0.05 for 95% interval)" }
+    ],
+    example: '["prob/credible-interval", samples, 0.05] // => [lo, hi]'
+  }
+};
+
 // registry.ts
 var STD_OPERATORS = {
   ...MATH_OPERATORS,
@@ -3160,7 +3402,8 @@ var STD_OPERATORS = {
   ...ASYNC_OPERATORS,
   ...NN_OPERATORS,
   ...TENSOR_OPERATORS,
-  ...TRAIN_OPERATORS
+  ...TRAIN_OPERATORS,
+  ...PROB_OPERATORS
 };
 var STD_OPERATORS_BY_MODULE = {
   math: MATH_OPERATORS,
@@ -3173,7 +3416,8 @@ var STD_OPERATORS_BY_MODULE = {
   async: ASYNC_OPERATORS,
   nn: NN_OPERATORS,
   tensor: TENSOR_OPERATORS,
-  train: TRAIN_OPERATORS
+  train: TRAIN_OPERATORS,
+  prob: PROB_OPERATORS
 };
 function getStdOperatorMeta(operator) {
   return STD_OPERATORS[operator];
@@ -7696,84 +7940,1022 @@ var GAME_UI_BEHAVIORS = [
   LEVEL_PROGRESS_BEHAVIOR
 ];
 
-// behaviors/registry.ts
-var STANDARD_BEHAVIORS = [
-  ...UI_INTERACTION_BEHAVIORS,
-  ...DATA_MANAGEMENT_BEHAVIORS,
-  ...ASYNC_BEHAVIORS,
-  ...FEEDBACK_BEHAVIORS,
-  ...GAME_CORE_BEHAVIORS,
-  ...GAME_ENTITY_BEHAVIORS,
-  ...GAME_UI_BEHAVIORS
-];
-var BEHAVIOR_REGISTRY = STANDARD_BEHAVIORS.reduce(
-  (acc, behavior) => {
-    acc[behavior.name] = behavior;
-    return acc;
-  },
-  {}
-);
-function getBehavior(name) {
-  return BEHAVIOR_REGISTRY[name];
-}
-function isKnownBehavior(name) {
-  return name in BEHAVIOR_REGISTRY;
-}
-function getAllBehaviorNames() {
-  return Object.keys(BEHAVIOR_REGISTRY);
-}
-function getAllBehaviors() {
-  return STANDARD_BEHAVIORS;
-}
-function getAllBehaviorMetadata() {
-  return STANDARD_BEHAVIORS.map(getBehaviorMetadata);
-}
-function findBehaviorsForUseCase(useCase) {
-  const lowerUseCase = useCase.toLowerCase();
-  return STANDARD_BEHAVIORS.filter(
-    (behavior) => behavior.description?.toLowerCase().includes(lowerUseCase) ?? false
-  );
-}
-function getBehaviorsForEvent(event) {
-  return STANDARD_BEHAVIORS.filter((behavior) => {
-    for (const orbital of behavior.orbitals || []) {
-      for (const trait of orbital.traits || []) {
-        if (typeof trait === "object" && "stateMachine" in trait) {
-          const events = trait.stateMachine?.events || [];
-          if (events.some((e) => e.key === event)) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  });
-}
-function getBehaviorsWithState(state) {
-  return STANDARD_BEHAVIORS.filter((behavior) => {
-    for (const orbital of behavior.orbitals || []) {
-      for (const trait of orbital.traits || []) {
-        if (typeof trait === "object" && "stateMachine" in trait) {
-          const states = trait.stateMachine?.states || [];
-          if (states.some((s) => s.name === state)) {
-            return true;
-          }
+// behaviors/infrastructure.ts
+var CIRCUIT_BREAKER_BEHAVIOR = {
+  name: "std-circuit-breaker",
+  version: "1.0.0",
+  description: "Circuit breaker pattern with automatic recovery",
+  orbitals: [
+    {
+      name: "CircuitBreakerOrbital",
+      entity: {
+        name: "CircuitBreakerState",
+        persistence: "runtime",
+        fields: [
+          { name: "id", type: "string", required: true },
+          { name: "circuitState", type: "string", default: "closed" },
+          { name: "errorCount", type: "number", default: 0 },
+          { name: "errorRate", type: "number", default: 0 },
+          { name: "successCount", type: "number", default: 0 },
+          { name: "totalCount", type: "number", default: 0 },
+          { name: "lastFailure", type: "number", default: null },
+          { name: "lastSuccess", type: "number", default: null },
+          { name: "errorThreshold", type: "number", default: 5 },
+          { name: "errorRateThreshold", type: "number", default: 0.5 },
+          { name: "resetAfterMs", type: "number", default: 6e4 },
+          { name: "halfOpenMaxAttempts", type: "number", default: 3 },
+          { name: "halfOpenAttempts", type: "number", default: 0 }
+        ]
+      },
+      traits: [
+        {
+          name: "CircuitBreaker",
+          linkedEntity: "CircuitBreakerState",
+          category: "lifecycle",
+          emits: [
+            { event: "CIRCUIT_OPENED", scope: "external" },
+            { event: "CIRCUIT_CLOSED", scope: "external" },
+            { event: "CIRCUIT_HALF_OPEN", scope: "external" }
+          ],
+          stateMachine: {
+            states: [
+              { name: "Closed", isInitial: true },
+              { name: "Open" },
+              { name: "HalfOpen" }
+            ],
+            events: [
+              { key: "RECORD_SUCCESS", name: "Record Success" },
+              { key: "RECORD_FAILURE", name: "Record Failure" },
+              { key: "PROBE", name: "Probe" },
+              { key: "RESET", name: "Reset" }
+            ],
+            transitions: [
+              // Closed: record success
+              {
+                from: "Closed",
+                to: "Closed",
+                event: "RECORD_SUCCESS",
+                effects: [
+                  ["set", "@entity.successCount", ["+", "@entity.successCount", 1]],
+                  ["set", "@entity.totalCount", ["+", "@entity.totalCount", 1]],
+                  ["set", "@entity.lastSuccess", ["time/now"]],
+                  ["set", "@entity.errorRate", ["/", "@entity.errorCount", ["math/max", "@entity.totalCount", 1]]]
+                ]
+              },
+              // Closed: record failure, stay closed if under threshold
+              {
+                from: "Closed",
+                to: "Closed",
+                event: "RECORD_FAILURE",
+                guard: ["<", ["+", "@entity.errorCount", 1], "@entity.errorThreshold"],
+                effects: [
+                  ["set", "@entity.errorCount", ["+", "@entity.errorCount", 1]],
+                  ["set", "@entity.totalCount", ["+", "@entity.totalCount", 1]],
+                  ["set", "@entity.lastFailure", ["time/now"]],
+                  ["set", "@entity.errorRate", ["/", ["+", "@entity.errorCount", 1], ["math/max", "@entity.totalCount", 1]]]
+                ]
+              },
+              // Closed -> Open: threshold exceeded
+              {
+                from: "Closed",
+                to: "Open",
+                event: "RECORD_FAILURE",
+                guard: [">=", ["+", "@entity.errorCount", 1], "@entity.errorThreshold"],
+                effects: [
+                  ["set", "@entity.errorCount", ["+", "@entity.errorCount", 1]],
+                  ["set", "@entity.totalCount", ["+", "@entity.totalCount", 1]],
+                  ["set", "@entity.lastFailure", ["time/now"]],
+                  ["set", "@entity.errorRate", ["/", ["+", "@entity.errorCount", 1], ["math/max", "@entity.totalCount", 1]]],
+                  ["emit", "CIRCUIT_OPENED", { errorCount: "@entity.errorCount", errorRate: "@entity.errorRate" }]
+                ]
+              },
+              // Open -> HalfOpen: probe after reset timeout
+              {
+                from: "Open",
+                to: "HalfOpen",
+                event: "PROBE",
+                guard: [">", ["-", ["time/now"], "@entity.lastFailure"], "@entity.resetAfterMs"],
+                effects: [
+                  ["set", "@entity.halfOpenAttempts", 0],
+                  ["emit", "CIRCUIT_HALF_OPEN", {}]
+                ]
+              },
+              // HalfOpen: success -> close
+              {
+                from: "HalfOpen",
+                to: "Closed",
+                event: "RECORD_SUCCESS",
+                effects: [
+                  ["set", "@entity.errorCount", 0],
+                  ["set", "@entity.errorRate", 0],
+                  ["set", "@entity.halfOpenAttempts", 0],
+                  ["set", "@entity.successCount", ["+", "@entity.successCount", 1]],
+                  ["set", "@entity.lastSuccess", ["time/now"]],
+                  ["emit", "CIRCUIT_CLOSED", {}]
+                ]
+              },
+              // HalfOpen: failure -> back to open
+              {
+                from: "HalfOpen",
+                to: "Open",
+                event: "RECORD_FAILURE",
+                effects: [
+                  ["set", "@entity.errorCount", ["+", "@entity.errorCount", 1]],
+                  ["set", "@entity.lastFailure", ["time/now"]],
+                  ["emit", "CIRCUIT_OPENED", { errorCount: "@entity.errorCount" }]
+                ]
+              },
+              // Reset from any state
+              {
+                from: ["Closed", "Open", "HalfOpen"],
+                to: "Closed",
+                event: "RESET",
+                effects: [
+                  ["set", "@entity.errorCount", 0],
+                  ["set", "@entity.successCount", 0],
+                  ["set", "@entity.totalCount", 0],
+                  ["set", "@entity.errorRate", 0],
+                  ["set", "@entity.halfOpenAttempts", 0],
+                  ["set", "@entity.circuitState", "closed"]
+                ]
+              }
+            ]
+          },
+          ticks: [
+            {
+              name: "probe_half_open",
+              interval: "30000",
+              guard: ["=", "@entity.circuitState", "open"],
+              effects: [["emit", "PROBE"]],
+              description: "Periodically probe to transition from Open to HalfOpen"
+            }
+          ]
         }
-      }
-    }
-    return false;
-  });
-}
-function validateBehaviorReference(name) {
-  if (!name.startsWith("std-")) {
-    return `Behavior name must start with 'std-': ${name}`;
-  }
-  if (!isKnownBehavior(name)) {
-    const suggestions = findSimilarBehaviors(name);
-    if (suggestions.length > 0) {
-      return `Unknown behavior '${name}'. Did you mean: ${suggestions.join(", ")}?`;
+      ],
+      pages: []
     }
-    return `Unknown behavior: ${name}`;
+  ]
+};
+var HEALTH_CHECK_BEHAVIOR = {
+  name: "std-health-check",
+  version: "1.0.0",
+  description: "Tick-based health monitoring with degradation detection",
+  orbitals: [
+    {
+      name: "HealthCheckOrbital",
+      entity: {
+        name: "HealthCheckState",
+        persistence: "runtime",
+        fields: [
+          { name: "id", type: "string", required: true },
+          { name: "healthStatus", type: "string", default: "unknown" },
+          { name: "lastCheck", type: "number", default: null },
+          { name: "lastHealthy", type: "number", default: null },
+          { name: "consecutiveFailures", type: "number", default: 0 },
+          { name: "consecutiveSuccesses", type: "number", default: 0 },
+          { name: "checkIntervalMs", type: "number", default: 3e4 },
+          { name: "degradedThreshold", type: "number", default: 2 },
+          { name: "unhealthyThreshold", type: "number", default: 5 },
+          { name: "recoveryThreshold", type: "number", default: 3 },
+          { name: "totalChecks", type: "number", default: 0 },
+          { name: "totalFailures", type: "number", default: 0 }
+        ]
+      },
+      traits: [
+        {
+          name: "HealthCheck",
+          linkedEntity: "HealthCheckState",
+          category: "lifecycle",
+          emits: [
+            { event: "SERVICE_HEALTHY", scope: "external" },
+            { event: "SERVICE_DEGRADED", scope: "external" },
+            { event: "SERVICE_UNHEALTHY", scope: "external" }
+          ],
+          stateMachine: {
+            states: [
+              { name: "Unknown", isInitial: true },
+              { name: "Healthy" },
+              { name: "Degraded" },
+              { name: "Unhealthy" }
+            ],
+            events: [
+              { key: "CHECK_SUCCESS", name: "Check Success" },
+              { key: "CHECK_FAILURE", name: "Check Failure" },
+              { key: "HEALTH_TICK", name: "Health Tick" },
+              { key: "RESET", name: "Reset" }
+            ],
+            transitions: [
+              // Unknown -> Healthy on first success
+              {
+                from: "Unknown",
+                to: "Healthy",
+                event: "CHECK_SUCCESS",
+                effects: [
+                  ["set", "@entity.healthStatus", "healthy"],
+                  ["set", "@entity.consecutiveSuccesses", 1],
+                  ["set", "@entity.consecutiveFailures", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.lastHealthy", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["emit", "SERVICE_HEALTHY", {}]
+                ]
+              },
+              // Unknown -> Degraded on first failure
+              {
+                from: "Unknown",
+                to: "Degraded",
+                event: "CHECK_FAILURE",
+                effects: [
+                  ["set", "@entity.healthStatus", "degraded"],
+                  ["set", "@entity.consecutiveFailures", 1],
+                  ["set", "@entity.consecutiveSuccesses", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["set", "@entity.totalFailures", ["+", "@entity.totalFailures", 1]],
+                  ["emit", "SERVICE_DEGRADED", { consecutiveFailures: 1 }]
+                ]
+              },
+              // Healthy: stay healthy on success
+              {
+                from: "Healthy",
+                to: "Healthy",
+                event: "CHECK_SUCCESS",
+                effects: [
+                  ["set", "@entity.consecutiveSuccesses", ["+", "@entity.consecutiveSuccesses", 1]],
+                  ["set", "@entity.consecutiveFailures", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.lastHealthy", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]]
+                ]
+              },
+              // Healthy -> Degraded on failure
+              {
+                from: "Healthy",
+                to: "Degraded",
+                event: "CHECK_FAILURE",
+                effects: [
+                  ["set", "@entity.healthStatus", "degraded"],
+                  ["set", "@entity.consecutiveFailures", 1],
+                  ["set", "@entity.consecutiveSuccesses", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["set", "@entity.totalFailures", ["+", "@entity.totalFailures", 1]],
+                  ["emit", "SERVICE_DEGRADED", { consecutiveFailures: 1 }]
+                ]
+              },
+              // Degraded: stay degraded on failure (below unhealthy threshold)
+              {
+                from: "Degraded",
+                to: "Degraded",
+                event: "CHECK_FAILURE",
+                guard: ["<", ["+", "@entity.consecutiveFailures", 1], "@entity.unhealthyThreshold"],
+                effects: [
+                  ["set", "@entity.consecutiveFailures", ["+", "@entity.consecutiveFailures", 1]],
+                  ["set", "@entity.consecutiveSuccesses", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["set", "@entity.totalFailures", ["+", "@entity.totalFailures", 1]]
+                ]
+              },
+              // Degraded -> Unhealthy when threshold exceeded
+              {
+                from: "Degraded",
+                to: "Unhealthy",
+                event: "CHECK_FAILURE",
+                guard: [">=", ["+", "@entity.consecutiveFailures", 1], "@entity.unhealthyThreshold"],
+                effects: [
+                  ["set", "@entity.healthStatus", "unhealthy"],
+                  ["set", "@entity.consecutiveFailures", ["+", "@entity.consecutiveFailures", 1]],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["set", "@entity.totalFailures", ["+", "@entity.totalFailures", 1]],
+                  ["emit", "SERVICE_UNHEALTHY", { consecutiveFailures: ["+", "@entity.consecutiveFailures", 1] }]
+                ]
+              },
+              // Degraded -> Healthy on enough successes
+              {
+                from: "Degraded",
+                to: "Healthy",
+                event: "CHECK_SUCCESS",
+                guard: [">=", ["+", "@entity.consecutiveSuccesses", 1], "@entity.recoveryThreshold"],
+                effects: [
+                  ["set", "@entity.healthStatus", "healthy"],
+                  ["set", "@entity.consecutiveSuccesses", ["+", "@entity.consecutiveSuccesses", 1]],
+                  ["set", "@entity.consecutiveFailures", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.lastHealthy", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["emit", "SERVICE_HEALTHY", {}]
+                ]
+              },
+              // Degraded: stay degraded on success (not enough to recover)
+              {
+                from: "Degraded",
+                to: "Degraded",
+                event: "CHECK_SUCCESS",
+                guard: ["<", ["+", "@entity.consecutiveSuccesses", 1], "@entity.recoveryThreshold"],
+                effects: [
+                  ["set", "@entity.consecutiveSuccesses", ["+", "@entity.consecutiveSuccesses", 1]],
+                  ["set", "@entity.consecutiveFailures", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]]
+                ]
+              },
+              // Unhealthy: stay unhealthy on failure
+              {
+                from: "Unhealthy",
+                to: "Unhealthy",
+                event: "CHECK_FAILURE",
+                effects: [
+                  ["set", "@entity.consecutiveFailures", ["+", "@entity.consecutiveFailures", 1]],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["set", "@entity.totalFailures", ["+", "@entity.totalFailures", 1]]
+                ]
+              },
+              // Unhealthy -> Degraded on first success (recovery begins)
+              {
+                from: "Unhealthy",
+                to: "Degraded",
+                event: "CHECK_SUCCESS",
+                effects: [
+                  ["set", "@entity.healthStatus", "degraded"],
+                  ["set", "@entity.consecutiveSuccesses", 1],
+                  ["set", "@entity.consecutiveFailures", 0],
+                  ["set", "@entity.lastCheck", ["time/now"]],
+                  ["set", "@entity.totalChecks", ["+", "@entity.totalChecks", 1]],
+                  ["emit", "SERVICE_DEGRADED", { recovering: true }]
+                ]
+              },
+              // Reset from any state
+              {
+                from: ["Unknown", "Healthy", "Degraded", "Unhealthy"],
+                to: "Unknown",
+                event: "RESET",
+                effects: [
+                  ["set", "@entity.healthStatus", "unknown"],
+                  ["set", "@entity.consecutiveFailures", 0],
+                  ["set", "@entity.consecutiveSuccesses", 0],
+                  ["set", "@entity.totalChecks", 0],
+                  ["set", "@entity.totalFailures", 0]
+                ]
+              }
+            ]
+          },
+          ticks: [
+            {
+              name: "periodic_health_check",
+              interval: "@entity.checkIntervalMs",
+              effects: [["emit", "HEALTH_TICK"]],
+              description: "Periodically trigger health check"
+            }
+          ]
+        }
+      ],
+      pages: []
+    }
+  ]
+};
+var RATE_LIMITER_BEHAVIOR = {
+  name: "std-rate-limiter",
+  version: "1.0.0",
+  description: "Guard-based rate limiting with sliding window reset",
+  orbitals: [
+    {
+      name: "RateLimiterOrbital",
+      entity: {
+        name: "RateLimiterState",
+        persistence: "runtime",
+        fields: [
+          { name: "id", type: "string", required: true },
+          { name: "requestCount", type: "number", default: 0 },
+          { name: "windowStart", type: "number", default: 0 },
+          { name: "rateLimit", type: "number", default: 60 },
+          { name: "windowMs", type: "number", default: 6e4 },
+          { name: "totalRequests", type: "number", default: 0 },
+          { name: "rejectedRequests", type: "number", default: 0 }
+        ]
+      },
+      traits: [
+        {
+          name: "RateLimiter",
+          linkedEntity: "RateLimiterState",
+          category: "lifecycle",
+          emits: [
+            { event: "RATE_LIMIT_EXCEEDED", scope: "external" }
+          ],
+          stateMachine: {
+            states: [
+              { name: "Active", isInitial: true }
+            ],
+            events: [
+              { key: "REQUEST", name: "Record Request" },
+              { key: "REQUEST_REJECTED", name: "Request Rejected" },
+              { key: "WINDOW_RESET", name: "Window Reset" },
+              { key: "RESET", name: "Full Reset" }
+            ],
+            transitions: [
+              // Request allowed
+              {
+                from: "Active",
+                to: "Active",
+                event: "REQUEST",
+                guard: ["<", "@entity.requestCount", "@entity.rateLimit"],
+                effects: [
+                  ["set", "@entity.requestCount", ["+", "@entity.requestCount", 1]],
+                  ["set", "@entity.totalRequests", ["+", "@entity.totalRequests", 1]]
+                ]
+              },
+              // Request rejected — over limit
+              {
+                from: "Active",
+                to: "Active",
+                event: "REQUEST",
+                guard: [">=", "@entity.requestCount", "@entity.rateLimit"],
+                effects: [
+                  ["set", "@entity.rejectedRequests", ["+", "@entity.rejectedRequests", 1]],
+                  ["emit", "RATE_LIMIT_EXCEEDED", {
+                    requestCount: "@entity.requestCount",
+                    rateLimit: "@entity.rateLimit"
+                  }]
+                ]
+              },
+              // Sliding window reset
+              {
+                from: "Active",
+                to: "Active",
+                event: "WINDOW_RESET",
+                effects: [
+                  ["set", "@entity.requestCount", 0],
+                  ["set", "@entity.windowStart", ["time/now"]]
+                ]
+              },
+              // Full counter reset
+              {
+                from: "Active",
+                to: "Active",
+                event: "RESET",
+                effects: [
+                  ["set", "@entity.requestCount", 0],
+                  ["set", "@entity.totalRequests", 0],
+                  ["set", "@entity.rejectedRequests", 0],
+                  ["set", "@entity.windowStart", ["time/now"]]
+                ]
+              }
+            ]
+          },
+          ticks: [
+            {
+              name: "window_reset",
+              interval: "@entity.windowMs",
+              effects: [["emit", "WINDOW_RESET"]],
+              description: "Reset request counter on sliding window expiry"
+            }
+          ]
+        }
+      ],
+      pages: []
+    }
+  ]
+};
+var CACHE_ASIDE_BEHAVIOR = {
+  name: "std-cache-aside",
+  version: "1.0.0",
+  description: "Cache-aside pattern with TTL-based freshness and eviction",
+  orbitals: [
+    {
+      name: "CacheAsideOrbital",
+      entity: {
+        name: "CacheEntry",
+        persistence: "runtime",
+        fields: [
+          { name: "id", type: "string", required: true },
+          { name: "cacheKey", type: "string", default: "" },
+          { name: "cachedValue", type: "object", default: null },
+          { name: "cachedAt", type: "number", default: 0 },
+          { name: "ttlMs", type: "number", default: 3e5 },
+          { name: "cacheHits", type: "number", default: 0 },
+          { name: "cacheMisses", type: "number", default: 0 },
+          { name: "isFresh", type: "boolean", default: false },
+          { name: "lastAccessed", type: "number", default: 0 }
+        ]
+      },
+      traits: [
+        {
+          name: "CacheAside",
+          linkedEntity: "CacheEntry",
+          category: "lifecycle",
+          emits: [
+            { event: "CACHE_HIT", scope: "internal" },
+            { event: "CACHE_MISS", scope: "internal" },
+            { event: "CACHE_EVICTED", scope: "internal" }
+          ],
+          stateMachine: {
+            states: [
+              { name: "Empty", isInitial: true },
+              { name: "Fresh" },
+              { name: "Stale" }
+            ],
+            events: [
+              { key: "LOOKUP", name: "Cache Lookup" },
+              { key: "POPULATE", name: "Populate Cache" },
+              { key: "INVALIDATE", name: "Invalidate" },
+              { key: "EVICT", name: "Evict" },
+              { key: "EVICTION_TICK", name: "Eviction Tick" }
+            ],
+            transitions: [
+              // Empty: lookup is a miss
+              {
+                from: "Empty",
+                to: "Empty",
+                event: "LOOKUP",
+                effects: [
+                  ["set", "@entity.cacheMisses", ["+", "@entity.cacheMisses", 1]],
+                  ["set", "@entity.lastAccessed", ["time/now"]],
+                  ["emit", "CACHE_MISS", { key: "@entity.cacheKey" }]
+                ]
+              },
+              // Empty → Fresh: populate after fetch
+              {
+                from: "Empty",
+                to: "Fresh",
+                event: "POPULATE",
+                effects: [
+                  ["set", "@entity.cachedValue", "@payload.value"],
+                  ["set", "@entity.cacheKey", "@payload.key"],
+                  ["set", "@entity.cachedAt", ["time/now"]],
+                  ["set", "@entity.isFresh", true]
+                ]
+              },
+              // Fresh: lookup is a hit
+              {
+                from: "Fresh",
+                to: "Fresh",
+                event: "LOOKUP",
+                guard: ["<", ["-", ["time/now"], "@entity.cachedAt"], "@entity.ttlMs"],
+                effects: [
+                  ["set", "@entity.cacheHits", ["+", "@entity.cacheHits", 1]],
+                  ["set", "@entity.lastAccessed", ["time/now"]],
+                  ["emit", "CACHE_HIT", { key: "@entity.cacheKey" }]
+                ]
+              },
+              // Fresh → Stale: TTL expired on lookup
+              {
+                from: "Fresh",
+                to: "Stale",
+                event: "LOOKUP",
+                guard: [">=", ["-", ["time/now"], "@entity.cachedAt"], "@entity.ttlMs"],
+                effects: [
+                  ["set", "@entity.isFresh", false],
+                  ["set", "@entity.cacheMisses", ["+", "@entity.cacheMisses", 1]],
+                  ["set", "@entity.lastAccessed", ["time/now"]],
+                  ["emit", "CACHE_MISS", { key: "@entity.cacheKey", reason: "ttl_expired" }]
+                ]
+              },
+              // Stale: lookup is a miss
+              {
+                from: "Stale",
+                to: "Stale",
+                event: "LOOKUP",
+                effects: [
+                  ["set", "@entity.cacheMisses", ["+", "@entity.cacheMisses", 1]],
+                  ["set", "@entity.lastAccessed", ["time/now"]],
+                  ["emit", "CACHE_MISS", { key: "@entity.cacheKey", reason: "stale" }]
+                ]
+              },
+              // Stale → Fresh: re-populate
+              {
+                from: "Stale",
+                to: "Fresh",
+                event: "POPULATE",
+                effects: [
+                  ["set", "@entity.cachedValue", "@payload.value"],
+                  ["set", "@entity.cachedAt", ["time/now"]],
+                  ["set", "@entity.isFresh", true]
+                ]
+              },
+              // Fresh → Fresh: update cache
+              {
+                from: "Fresh",
+                to: "Fresh",
+                event: "POPULATE",
+                effects: [
+                  ["set", "@entity.cachedValue", "@payload.value"],
+                  ["set", "@entity.cachedAt", ["time/now"]]
+                ]
+              },
+              // Invalidate from any cached state
+              {
+                from: ["Fresh", "Stale"],
+                to: "Empty",
+                event: "INVALIDATE",
+                effects: [
+                  ["set", "@entity.cachedValue", null],
+                  ["set", "@entity.isFresh", false],
+                  ["set", "@entity.cachedAt", 0]
+                ]
+              },
+              // Evict (with event)
+              {
+                from: ["Fresh", "Stale"],
+                to: "Empty",
+                event: "EVICT",
+                effects: [
+                  ["set", "@entity.cachedValue", null],
+                  ["set", "@entity.isFresh", false],
+                  ["set", "@entity.cachedAt", 0],
+                  ["emit", "CACHE_EVICTED", { key: "@entity.cacheKey" }]
+                ]
+              },
+              // Eviction tick: evict if stale
+              {
+                from: "Stale",
+                to: "Empty",
+                event: "EVICTION_TICK",
+                effects: [
+                  ["set", "@entity.cachedValue", null],
+                  ["set", "@entity.isFresh", false],
+                  ["set", "@entity.cachedAt", 0],
+                  ["emit", "CACHE_EVICTED", { key: "@entity.cacheKey", reason: "ttl_eviction" }]
+                ]
+              }
+            ]
+          },
+          ticks: [
+            {
+              name: "eviction_sweep",
+              interval: "60000",
+              guard: ["and", ["!=", "@entity.cachedAt", 0], [">=", ["-", ["time/now"], "@entity.cachedAt"], "@entity.ttlMs"]],
+              effects: [["emit", "EVICTION_TICK"]],
+              description: "Periodically evict stale cache entries"
+            }
+          ]
+        }
+      ],
+      pages: []
+    }
+  ]
+};
+var SAGA_BEHAVIOR = {
+  name: "std-saga",
+  version: "1.0.0",
+  description: "Saga pattern with step-by-step execution and reverse compensation on failure",
+  orbitals: [
+    {
+      name: "SagaOrbital",
+      entity: {
+        name: "SagaState",
+        persistence: "runtime",
+        fields: [
+          { name: "id", type: "string", required: true },
+          { name: "sagaName", type: "string", default: "" },
+          { name: "currentStep", type: "number", default: 0 },
+          { name: "totalSteps", type: "number", default: 0 },
+          { name: "sagaStatus", type: "string", default: "idle" },
+          { name: "completedSteps", type: "array", default: [] },
+          { name: "compensatedSteps", type: "array", default: [] },
+          { name: "failedStep", type: "number", default: -1 },
+          { name: "failureReason", type: "string", default: "" },
+          { name: "startedAt", type: "number", default: 0 },
+          { name: "completedAt", type: "number", default: 0 }
+        ]
+      },
+      traits: [
+        {
+          name: "Saga",
+          linkedEntity: "SagaState",
+          category: "lifecycle",
+          emits: [
+            { event: "SAGA_STARTED", scope: "external" },
+            { event: "SAGA_STEP_COMPLETED", scope: "external" },
+            { event: "SAGA_COMPLETED", scope: "external" },
+            { event: "SAGA_COMPENSATING", scope: "external" },
+            { event: "SAGA_COMPENSATION_DONE", scope: "external" },
+            { event: "SAGA_FAILED", scope: "external" }
+          ],
+          stateMachine: {
+            states: [
+              { name: "Idle", isInitial: true },
+              { name: "Running" },
+              { name: "Compensating" },
+              { name: "Completed" },
+              { name: "Failed" }
+            ],
+            events: [
+              { key: "START_SAGA", name: "Start Saga" },
+              { key: "STEP_SUCCESS", name: "Step Success" },
+              { key: "STEP_FAILURE", name: "Step Failure" },
+              { key: "COMPENSATE_SUCCESS", name: "Compensate Success" },
+              { key: "COMPENSATE_FAILURE", name: "Compensate Failure" },
+              { key: "RESET", name: "Reset" }
+            ],
+            transitions: [
+              // Idle → Running: start the saga
+              {
+                from: "Idle",
+                to: "Running",
+                event: "START_SAGA",
+                effects: [
+                  ["set", "@entity.sagaStatus", "running"],
+                  ["set", "@entity.currentStep", 0],
+                  ["set", "@entity.completedSteps", []],
+                  ["set", "@entity.compensatedSteps", []],
+                  ["set", "@entity.failedStep", -1],
+                  ["set", "@entity.failureReason", ""],
+                  ["set", "@entity.startedAt", ["time/now"]],
+                  ["emit", "SAGA_STARTED", { sagaName: "@entity.sagaName" }]
+                ]
+              },
+              // Running: step success, more steps remaining
+              {
+                from: "Running",
+                to: "Running",
+                event: "STEP_SUCCESS",
+                guard: ["<", ["+", "@entity.currentStep", 1], "@entity.totalSteps"],
+                effects: [
+                  ["set", "@entity.currentStep", ["+", "@entity.currentStep", 1]],
+                  ["emit", "SAGA_STEP_COMPLETED", {
+                    step: "@entity.currentStep",
+                    totalSteps: "@entity.totalSteps"
+                  }]
+                ]
+              },
+              // Running → Completed: last step succeeded
+              {
+                from: "Running",
+                to: "Completed",
+                event: "STEP_SUCCESS",
+                guard: [">=", ["+", "@entity.currentStep", 1], "@entity.totalSteps"],
+                effects: [
+                  ["set", "@entity.sagaStatus", "completed"],
+                  ["set", "@entity.completedAt", ["time/now"]],
+                  ["emit", "SAGA_COMPLETED", { sagaName: "@entity.sagaName" }]
+                ]
+              },
+              // Running → Compensating: a step failed
+              {
+                from: "Running",
+                to: "Compensating",
+                event: "STEP_FAILURE",
+                effects: [
+                  ["set", "@entity.sagaStatus", "compensating"],
+                  ["set", "@entity.failedStep", "@entity.currentStep"],
+                  ["emit", "SAGA_COMPENSATING", {
+                    failedStep: "@entity.currentStep",
+                    sagaName: "@entity.sagaName"
+                  }]
+                ]
+              },
+              // Compensating: compensation step succeeded, more to undo
+              {
+                from: "Compensating",
+                to: "Compensating",
+                event: "COMPENSATE_SUCCESS",
+                guard: [">", "@entity.currentStep", 0],
+                effects: [
+                  ["set", "@entity.currentStep", ["-", "@entity.currentStep", 1]]
+                ]
+              },
+              // Compensating → Failed: all compensations done (reached step 0)
+              {
+                from: "Compensating",
+                to: "Failed",
+                event: "COMPENSATE_SUCCESS",
+                guard: ["<=", "@entity.currentStep", 0],
+                effects: [
+                  ["set", "@entity.sagaStatus", "failed"],
+                  ["set", "@entity.completedAt", ["time/now"]],
+                  ["emit", "SAGA_COMPENSATION_DONE", { sagaName: "@entity.sagaName" }]
+                ]
+              },
+              // Compensating → Failed: compensation itself failed
+              {
+                from: "Compensating",
+                to: "Failed",
+                event: "COMPENSATE_FAILURE",
+                effects: [
+                  ["set", "@entity.sagaStatus", "failed"],
+                  ["set", "@entity.completedAt", ["time/now"]],
+                  ["emit", "SAGA_FAILED", {
+                    sagaName: "@entity.sagaName",
+                    reason: "Compensation failed"
+                  }]
+                ]
+              },
+              // Reset from terminal states
+              {
+                from: ["Completed", "Failed"],
+                to: "Idle",
+                event: "RESET",
+                effects: [
+                  ["set", "@entity.sagaStatus", "idle"],
+                  ["set", "@entity.currentStep", 0],
+                  ["set", "@entity.completedSteps", []],
+                  ["set", "@entity.compensatedSteps", []],
+                  ["set", "@entity.failedStep", -1],
+                  ["set", "@entity.failureReason", ""]
+                ]
+              }
+            ]
+          },
+          ticks: []
+        }
+      ],
+      pages: []
+    }
+  ]
+};
+var METRICS_COLLECTOR_BEHAVIOR = {
+  name: "std-metrics-collector",
+  version: "1.0.0",
+  description: "Tick-based metrics aggregation with periodic flush and reporting",
+  orbitals: [
+    {
+      name: "MetricsCollectorOrbital",
+      entity: {
+        name: "MetricsState",
+        persistence: "runtime",
+        fields: [
+          { name: "id", type: "string", required: true },
+          { name: "counters", type: "object", default: {} },
+          { name: "gauges", type: "object", default: {} },
+          { name: "lastFlush", type: "number", default: 0 },
+          { name: "flushIntervalMs", type: "number", default: 6e4 },
+          { name: "totalFlushes", type: "number", default: 0 },
+          { name: "totalRecorded", type: "number", default: 0 }
+        ]
+      },
+      traits: [
+        {
+          name: "MetricsCollector",
+          linkedEntity: "MetricsState",
+          category: "lifecycle",
+          emits: [
+            { event: "METRICS_REPORT", scope: "external" }
+          ],
+          stateMachine: {
+            states: [
+              { name: "Collecting", isInitial: true }
+            ],
+            events: [
+              { key: "RECORD_COUNTER", name: "Record Counter" },
+              { key: "RECORD_GAUGE", name: "Record Gauge" },
+              { key: "FLUSH", name: "Flush Metrics" },
+              { key: "RESET", name: "Reset All" }
+            ],
+            transitions: [
+              // Record a counter increment
+              {
+                from: "Collecting",
+                to: "Collecting",
+                event: "RECORD_COUNTER",
+                effects: [
+                  ["set", "@entity.totalRecorded", ["+", "@entity.totalRecorded", 1]]
+                ]
+              },
+              // Record a gauge value
+              {
+                from: "Collecting",
+                to: "Collecting",
+                event: "RECORD_GAUGE",
+                effects: [
+                  ["set", "@entity.totalRecorded", ["+", "@entity.totalRecorded", 1]]
+                ]
+              },
+              // Flush: emit report and reset counters
+              {
+                from: "Collecting",
+                to: "Collecting",
+                event: "FLUSH",
+                effects: [
+                  ["emit", "METRICS_REPORT", {
+                    counters: "@entity.counters",
+                    gauges: "@entity.gauges",
+                    totalRecorded: "@entity.totalRecorded"
+                  }],
+                  ["set", "@entity.counters", {}],
+                  ["set", "@entity.lastFlush", ["time/now"]],
+                  ["set", "@entity.totalFlushes", ["+", "@entity.totalFlushes", 1]]
+                ]
+              },
+              // Full reset
+              {
+                from: "Collecting",
+                to: "Collecting",
+                event: "RESET",
+                effects: [
+                  ["set", "@entity.counters", {}],
+                  ["set", "@entity.gauges", {}],
+                  ["set", "@entity.totalRecorded", 0],
+                  ["set", "@entity.totalFlushes", 0],
+                  ["set", "@entity.lastFlush", 0]
+                ]
+              }
+            ]
+          },
+          ticks: [
+            {
+              name: "periodic_flush",
+              interval: "@entity.flushIntervalMs",
+              guard: [">", "@entity.totalRecorded", 0],
+              effects: [["emit", "FLUSH"]],
+              description: "Periodically flush accumulated metrics"
+            }
+          ]
+        }
+      ],
+      pages: []
+    }
+  ]
+};
+var INFRASTRUCTURE_BEHAVIORS = [
+  CIRCUIT_BREAKER_BEHAVIOR,
+  HEALTH_CHECK_BEHAVIOR,
+  RATE_LIMITER_BEHAVIOR,
+  CACHE_ASIDE_BEHAVIOR,
+  SAGA_BEHAVIOR,
+  METRICS_COLLECTOR_BEHAVIOR
+];
+
+// behaviors/registry.ts
+var STANDARD_BEHAVIORS = [
+  ...UI_INTERACTION_BEHAVIORS,
+  ...DATA_MANAGEMENT_BEHAVIORS,
+  ...ASYNC_BEHAVIORS,
+  ...FEEDBACK_BEHAVIORS,
+  ...GAME_CORE_BEHAVIORS,
+  ...GAME_ENTITY_BEHAVIORS,
+  ...GAME_UI_BEHAVIORS,
+  ...INFRASTRUCTURE_BEHAVIORS
+];
+var BEHAVIOR_REGISTRY = STANDARD_BEHAVIORS.reduce(
+  (acc, behavior) => {
+    acc[behavior.name] = behavior;
+    return acc;
+  },
+  {}
+);
+function getBehavior(name) {
+  return BEHAVIOR_REGISTRY[name];
+}
+function isKnownBehavior(name) {
+  return name in BEHAVIOR_REGISTRY;
+}
+function getAllBehaviorNames() {
+  return Object.keys(BEHAVIOR_REGISTRY);
+}
+function getAllBehaviors() {
+  return STANDARD_BEHAVIORS;
+}
+function getAllBehaviorMetadata() {
+  return STANDARD_BEHAVIORS.map(getBehaviorMetadata);
+}
+function findBehaviorsForUseCase(useCase) {
+  const lowerUseCase = useCase.toLowerCase();
+  return STANDARD_BEHAVIORS.filter(
+    (behavior) => behavior.description?.toLowerCase().includes(lowerUseCase) ?? false
+  );
+}
+function getBehaviorsForEvent(event) {
+  return STANDARD_BEHAVIORS.filter((behavior) => {
+    for (const orbital of behavior.orbitals || []) {
+      for (const trait of orbital.traits || []) {
+        if (typeof trait === "object" && "stateMachine" in trait) {
+          const events = trait.stateMachine?.events || [];
+          if (events.some((e) => e.key === event)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  });
+}
+function getBehaviorsWithState(state) {
+  return STANDARD_BEHAVIORS.filter((behavior) => {
+    for (const orbital of behavior.orbitals || []) {
+      for (const trait of orbital.traits || []) {
+        if (typeof trait === "object" && "stateMachine" in trait) {
+          const states = trait.stateMachine?.states || [];
+          if (states.some((s) => s.name === state)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  });
+}
+function validateBehaviorReference(name) {
+  if (!name.startsWith("std-")) {
+    return `Behavior name must start with 'std-': ${name}`;
+  }
+  if (!isKnownBehavior(name)) {
+    const suggestions = findSimilarBehaviors(name);
+    if (suggestions.length > 0) {
+      return `Unknown behavior '${name}'. Did you mean: ${suggestions.join(", ")}?`;
+    }
+    return `Unknown behavior: ${name}`;
   }
   return null;
 }
@@ -7905,6 +9087,12 @@ var MODULE_DESCRIPTIONS = {
     displayName: "Training Operations",
     description: "Training loops, loss functions, and optimization for neural networks.",
     icon: "\u{1F3AF}"
+  },
+  prob: {
+    name: "Probabilistic",
+    displayName: "Probabilistic Programming",
+    description: "Distribution sampling, Bayesian inference via rejection sampling, and statistical summaries.",
+    icon: "\u{1F3B2}"
   }
 };
 var BEHAVIOR_GROUPINGS = {