@holoscript/core 8.0.8 → 8.0.9

package/dist/chunk-ZVFHPMC5.js

@@ -0,0 +1,824 @@
+import { __esm } from './chunk-W4GABFCR.js';
+
+// src/types/effects.ts
+function effectCategory(effect) {
+  return effect.split(":")[0];
+}
+var EFFECTS_BY_CATEGORY, _EffectRow, EffectRow;
+var init_effects = __esm({
+  "src/types/effects.ts"() {
+    EFFECTS_BY_CATEGORY = {
+      io: ["io:read", "io:write", "io:network", "io:timer"],
+      state: ["state:read", "state:write", "state:global", "state:persistent"],
+      exception: ["exception:throw", "exception:catch", "exception:panic"],
+      physics: [
+        "physics:force",
+        "physics:impulse",
+        "physics:collision",
+        "physics:teleport",
+        "physics:gravity",
+        "physics:joint"
+      ],
+      render: [
+        "render:spawn",
+        "render:destroy",
+        "render:material",
+        "render:particle",
+        "render:light",
+        "render:shader",
+        "render:gaussian"
+      ],
+      audio: ["audio:play", "audio:stop", "audio:spatial", "audio:global", "audio:reverb"],
+      inventory: [
+        "inventory:take",
+        "inventory:give",
+        "inventory:destroy",
+        "inventory:duplicate",
+        "inventory:trade"
+      ],
+      authority: [
+        "authority:own",
+        "authority:delegate",
+        "authority:revoke",
+        "authority:zone",
+        "authority:world"
+      ],
+      resource: [
+        "resource:cpu",
+        "resource:memory",
+        "resource:gpu",
+        "resource:bandwidth",
+        "resource:storage"
+      ],
+      agent: ["agent:spawn", "agent:kill", "agent:communicate", "agent:observe", "agent:control"]
+    };
+    _EffectRow = class _EffectRow {
+      constructor(effects = []) {
+        this.effects = new Set(effects);
+      }
+      /** Create from effect strings */
+      static of(...effects) {
+        return new _EffectRow(effects);
+      }
+      /** Create from a category — include all effects in that category */
+      static fromCategory(cat) {
+        return new _EffectRow(EFFECTS_BY_CATEGORY[cat]);
+      }
+      /** Row union (composition): this ∪ other */
+      union(other) {
+        const merged = new Set(this.effects);
+        for (const e of other.effects) merged.add(e);
+        return new _EffectRow(merged);
+      }
+      /** Row intersection: effects in both rows */
+      intersect(other) {
+        const common = [];
+        for (const e of this.effects) {
+          if (other.has(e)) common.push(e);
+        }
+        return new _EffectRow(common);
+      }
+      /** Row difference: effects in this but not other */
+      difference(other) {
+        const diff = [];
+        for (const e of this.effects) {
+          if (!other.has(e)) diff.push(e);
+        }
+        return new _EffectRow(diff);
+      }
+      /** Does this row contain the given effect? */
+      has(effect) {
+        return this.effects.has(effect);
+      }
+      /** Does this row contain ALL effects from the other row? (subtyping) */
+      subsumes(other) {
+        for (const e of other.effects) {
+          if (!this.effects.has(e)) return false;
+        }
+        return true;
+      }
+      /** Check if this row has unknown effects from a given category */
+      hasCategory(cat) {
+        for (const e of this.effects) {
+          if (effectCategory(e) === cat) return true;
+        }
+        return false;
+      }
+      /** Get all effects of a given category in this row */
+      ofCategory(cat) {
+        return [...this.effects].filter((e) => effectCategory(e) === cat);
+      }
+      /** Is this the pure (no-effect) row? */
+      isPure() {
+        return this.effects.size === 0;
+      }
+      /** Number of effects */
+      get size() {
+        return this.effects.size;
+      }
+      /** Get all effects as array */
+      toArray() {
+        return [...this.effects];
+      }
+      /** Get categories present in this row */
+      categories() {
+        const cats = /* @__PURE__ */ new Set();
+        for (const e of this.effects) cats.add(effectCategory(e));
+        return [...cats];
+      }
+      /** Human-readable representation */
+      toString() {
+        if (this.isPure()) return "<pure>";
+        return `<${this.toArray().join(", ")}>`;
+      }
+      /** Serialize to JSON-friendly format */
+      toJSON() {
+        return this.toArray();
+      }
+      /** Deserialize from JSON */
+      static fromJSON(arr) {
+        return new _EffectRow(arr);
+      }
+    };
+    /** The pure row — no effects at all */
+    _EffectRow.PURE = new _EffectRow([]);
+    EffectRow = _EffectRow;
+  }
+});
+
+// src/compiler/safety/EffectInference.ts
+function inferFromTraits(traitNames) {
+  const allEffects = [];
+  const sources = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const trait of traitNames) {
+    const normalized = trait.startsWith("@") ? trait : `@${trait}`;
+    const effects = TRAIT_EFFECTS[normalized];
+    if (effects) {
+      for (const e of effects) {
+        allEffects.push(e);
+        const existing = sources.get(e) || [];
+        existing.push(normalized);
+        sources.set(e, existing);
+      }
+    } else {
+      warnings.push(
+        `Unknown trait '${normalized}': cannot infer effects, so the safety checker assumes pure. Register the trait in TRAIT_EFFECTS or add an explicit @effect declaration before relying on this inference.`
+      );
+    }
+  }
+  return { row: new EffectRow(allEffects), sources, warnings };
+}
+function inferFromBuiltins(functionNames) {
+  const allEffects = [];
+  const sources = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const fn of functionNames) {
+    const effects = BUILTIN_EFFECTS[fn];
+    if (effects) {
+      for (const e of effects) {
+        allEffects.push(e);
+        const existing = sources.get(e) || [];
+        existing.push(fn);
+        sources.set(e, existing);
+      }
+    }
+  }
+  return { row: new EffectRow(allEffects), sources, warnings };
+}
+function composeEffects(...inferred) {
+  let combined = EffectRow.PURE;
+  const allSources = /* @__PURE__ */ new Map();
+  const allWarnings = [];
+  for (const inf of inferred) {
+    combined = combined.union(inf.row);
+    for (const [effect, srcs] of inf.sources) {
+      const existing = allSources.get(effect) || [];
+      allSources.set(effect, [...existing, ...srcs]);
+    }
+    allWarnings.push(...inf.warnings);
+  }
+  return { row: combined, sources: allSources, warnings: allWarnings };
+}
+function knownTraits() {
+  return Object.keys(TRAIT_EFFECTS);
+}
+function knownBuiltins() {
+  return Object.keys(BUILTIN_EFFECTS);
+}
+var TRAIT_EFFECTS, BUILTIN_EFFECTS;
+var init_EffectInference = __esm({
+  "src/compiler/safety/EffectInference.ts"() {
+    init_effects();
+    TRAIT_EFFECTS = {
+      // Rendering traits
+      "@mesh": ["render:spawn"],
+      "@material": ["render:material"],
+      "@particle": ["render:particle", "render:spawn", "resource:gpu"],
+      "@light": ["render:light"],
+      "@shader": ["render:shader", "resource:gpu"],
+      "@gaussian": ["render:gaussian", "resource:gpu", "resource:memory"],
+      "@camera": ["render:spawn"],
+      "@sprite": ["render:spawn"],
+      "@vfx": ["render:particle", "render:shader", "resource:gpu"],
+      // Physics traits
+      "@physics": ["physics:force", "physics:collision", "resource:cpu"],
+      "@rigidbody": ["physics:force", "physics:collision"],
+      "@collider": ["physics:collision"],
+      "@joint": ["physics:joint"],
+      "@trigger": ["physics:collision"],
+      "@gravity": ["physics:gravity"],
+      "@teleport": ["physics:teleport"],
+      // Audio traits
+      "@audio": ["audio:play"],
+      "@spatial_audio": ["audio:spatial"],
+      "@gem_resonance": ["audio:spatial", "state:read"],
+      "@reverb": ["audio:reverb"],
+      "@music": ["audio:play", "audio:global"],
+      // State traits
+      "@state": ["state:read", "state:write"],
+      "@persistent": ["state:persistent", "io:write"],
+      "@global_state": ["state:global"],
+      // Networking
+      "@networked": ["io:network", "state:write"],
+      "@multiplayer": ["io:network", "agent:communicate"],
+      "@sync": ["io:network", "state:write"],
+      // Agent traits
+      "@agent": ["agent:spawn", "resource:cpu"],
+      "@npc": ["agent:spawn", "agent:observe"],
+      "@ai": ["agent:observe", "resource:cpu"],
+      "@behavior": ["agent:observe", "state:read"],
+      // Inventory / economy
+      "@inventory": ["inventory:take", "inventory:give"],
+      "@tradeable": ["inventory:trade"],
+      "@consumable": ["inventory:destroy"],
+      "@loot": ["inventory:give"],
+      // Authority / permissions
+      "@owned": ["authority:own"],
+      "@delegated": ["authority:delegate"],
+      "@zone": ["authority:zone"],
+      // Animation (mostly pure, some render effects)
+      "@animation": ["render:material"],
+      "@keyframe": ["state:read"],
+      "@tween": ["state:read", "state:write"],
+      // Script / lifecycle
+      "@script": ["state:read", "state:write"],
+      "@timer": ["io:timer"],
+      "@event": ["state:read"],
+      // Sandbox (explicitly limited)
+      "@sandbox": [],
+      // Pure — sandboxed code should have no effects
+      // Culture traits (emergent agent culture)
+      "@norm_compliant": ["agent:observe", "agent:communicate"],
+      // Must observe + report norms
+      "@cultural_memory": ["state:read", "state:write", "state:persistent"],
+      // Dual memory persistence
+      "@cultural_trace": ["state:write", "render:spawn"],
+      // Spatial stigmergic markers
+      // GPU Compute traits
+      "@compute_shader": ["resource:gpu", "render:shader"],
+      "@render_pipeline": ["resource:gpu", "render:spawn"],
+      "@post_process": ["resource:gpu", "render:material"],
+      "@ray_trace": ["resource:gpu", "resource:cpu"],
+      // ML / Tensor traits
+      "@tensor_op": ["resource:gpu", "resource:memory"],
+      "@onnx_runtime": ["resource:cpu", "resource:memory"],
+      "@training_loop": ["resource:gpu", "resource:cpu", "resource:memory"],
+      // Database / Persistence traits
+      "@sql_query": ["io:read", "io:write"],
+      "@orm_entity": ["io:read", "io:write", "state:read", "state:write"],
+      "@offline_sync": ["io:network", "io:write", "state:persistent"],
+      "@reactive_store": ["state:read", "state:write"],
+      // Spatial Algorithm traits
+      "@astar": ["resource:cpu"],
+      "@navmesh_solver": ["resource:cpu", "resource:memory"],
+      "@optimization": ["resource:cpu"],
+      // Debug / Cinematic traits
+      "@time_travel_debug": ["state:read", "state:write", "resource:memory"],
+      "@spatial_profiler": ["state:read", "resource:cpu"],
+      "@cinematic_seq": ["render:spawn", "state:read"],
+      "@ai_camera": ["render:spawn", "agent:observe"],
+      // FFI / OS traits
+      "@ffi": ["io:read", "io:write"],
+      "@native_call": ["io:read", "io:write"],
+      "@wasm_bridge": ["resource:memory", "resource:cpu"],
+      "@sys_io": ["io:read", "io:write"],
+      // Concurrency traits
+      "@actor": ["agent:spawn", "agent:communicate"],
+      "@csp_channel": ["state:read", "state:write"],
+      "@temporal_guard": ["state:read"],
+      "@deadlock_free": ["resource:cpu"],
+      // Safety meta-decorators — pure (no effects); they annotate constraints, not behavior.
+      // @freshnessBound(ms) is enforced by FreshnessBoundChecker at compile time.
+      "@freshnessBound": [],
+      // Auto-generated effect mappings
+      // ΓòÉΓòÉΓòÉ NEW TRAIT_EFFECTS ΓòÉΓòÉΓòÉ
+      "@absorb": [],
+      "@abtest": [],
+      "@accessible": [],
+      "@advanced_lighting": ["render:spawn", "resource:gpu"],
+      "@advanced_pbr": [],
+      "@advanced_texturing": [],
+      "@agent_discovery": ["agent:spawn", "resource:cpu"],
+      "@agent_portal": ["agent:spawn", "resource:cpu"],
+      "@ai_inpainting": ["agent:spawn", "resource:cpu"],
+      "@ai_npc_brain": ["agent:spawn", "resource:cpu"],
+      "@ai_texture_gen": ["agent:spawn", "resource:cpu"],
+      "@ai_upscaling": ["agent:spawn", "resource:cpu"],
+      "@alert": [],
+      "@alt_text": [],
+      "@ambisonics": ["audio:play"],
+      "@analytics": ["state:read"],
+      "@anchor": [],
+      "@api_key": [],
+      "@approval": [],
+      "@audio_material": ["render:spawn", "resource:gpu"],
+      "@audio_occlusion": ["audio:play"],
+      "@audio_portal": ["audio:play"],
+      "@audit_log": [],
+      "@autocomplete": [],
+      "@avatar_embodiment": [],
+      "@batch_job": [],
+      "@behavior_tree": ["agent:spawn", "resource:cpu"],
+      "@biofeedback": ["io:read", "io:write"],
+      "@blackboard": [],
+      "@blob_store": ["state:read", "state:write"],
+      "@body_tracking": ["state:read"],
+      "@buffer": [],
+      "@buoyancy": ["physics:force", "physics:collision"],
+      "@cache": ["state:read", "state:write"],
+      "@canary": [],
+      "@chain": ["agent:spawn", "resource:cpu"],
+      "@change_tracking": ["state:read"],
+      "@chaos_test": [],
+      "@choreography": [],
+      "@circuit_breaker": [],
+      "@cloth": ["physics:force", "physics:collision"],
+      "@co_located": [],
+      "@compute": ["resource:gpu", "resource:cpu"],
+      "@consent_gate": ["authority:own"],
+      "@consent_management": ["authority:own"],
+      "@controller": [],
+      "@controlnet": [],
+      "@cron": [],
+      "@database": ["state:read", "state:write"],
+      "@data_binding": [],
+      "@data_lineage": [],
+      "@data_quality": [],
+      "@data_retention": ["io:read", "io:write"],
+      "@data_transform": ["state:read", "state:write"],
+      "@deploy": [],
+      "@destruction": ["io:read", "io:write"],
+      "@dialogue": [],
+      "@diffusion_realtime": ["io:read", "io:write"],
+      "@digital_twin": [],
+      "@discord": [],
+      "@economy": [],
+      "@email": ["agent:spawn", "resource:cpu"],
+      "@embedding_search": [],
+      "@embedding": [],
+      "@emotional_voice": ["audio:play"],
+      "@emotion": ["io:read", "io:write"],
+      "@encryption": ["io:read", "io:write"],
+      "@env_config": [],
+      "@etl": [],
+      "@eye_tracked": ["state:read"],
+      "@faceted_search": [],
+      "@face_tracking": ["state:read"],
+      "@faction": ["agent:spawn", "resource:cpu"],
+      "@fbx": [],
+      "@feature_flag": [],
+      "@feedback_loop": [],
+      "@file_system": ["io:read", "io:write"],
+      "@fine_tune": [],
+      "@fixture": [],
+      "@flow_field": [],
+      "@fluid": ["physics:force", "physics:collision"],
+      "@form_builder": ["state:read", "state:write"],
+      "@full_text_search": [],
+      "@gaussian_splat": ["render:spawn", "resource:gpu"],
+      "@gdpr": ["authority:own"],
+      "@geospatial_anchor": [],
+      "@geospatial": [],
+      "@gesture_recognition": ["io:read", "io:write"],
+      "@global_illumination": ["io:read", "io:write"],
+      "@gltf": [],
+      "@goal_oriented": [],
+      "@gpu_buffer": ["resource:gpu", "resource:cpu"],
+      "@gpu_particle": ["render:spawn", "resource:gpu"],
+      "@gpu_physics": ["physics:force", "physics:collision"],
+      "@graphql": ["io:network"],
+      "@ui_hand_menu": [],
+      "@hand_mesh_ai": ["render:spawn", "resource:gpu"],
+      "@pinch": [],
+      "@haptic_cue": [],
+      "@soft": ["physics:force", "physics:collision"],
+      "@head_tracked_audio": ["audio:play"],
+      "@healthcheck": [],
+      "@high_contrast": [],
+      "@hitl": [],
+      "@hot_reload": [],
+      "@hrtf": ["audio:play"],
+      "@hsm_integration": ["io:read", "io:write"],
+      "@image_resize": [],
+      "@incident": [],
+      "@index": [],
+      "@inference": [],
+      "@interactive_graph": [],
+      "@invoice": ["audio:play"],
+      "@jwt": ["authority:own"],
+      "@layer_aware": [],
+      "@light_estimation": ["render:spawn", "resource:gpu"],
+      "@low_vowel": [],
+      "@llm_agent": ["agent:spawn", "resource:cpu"],
+      "@load_test": [],
+      "@locale": [],
+      "@log_aggregator": [],
+      "@magnifiable": [],
+      "@markdown_render": ["render:spawn", "resource:gpu"],
+      "@marketplace_integration": ["io:read", "io:write"],
+      "@marketplace": [],
+      "@material_x": ["render:spawn", "resource:gpu"],
+      "@memory": ["agent:spawn", "resource:cpu"],
+      "@mesh_detection": ["render:spawn", "resource:gpu"],
+      "@mfa": ["authority:own"],
+      "@migrate": [],
+      "@mitosis": [],
+      "@mock": [],
+      "@model_load": [],
+      "@modbus": ["io:network"],
+      "@motion_reduced": ["io:read", "io:write"],
+      "@mqtt_pub": ["io:network"],
+      "@mqtt_sink": ["io:network"],
+      "@mqtt_source": ["io:network"],
+      "@multi_agent": ["agent:spawn", "resource:cpu"],
+      "@negotiation": ["io:read", "io:write"],
+      "@nerf": ["render:spawn", "resource:gpu"],
+      "@networked_avatar": ["io:network"],
+      "@neural_animation": ["agent:spawn", "resource:cpu"],
+      "@neural_expression": ["io:read", "resource:cpu"],
+      "@neural_forge": ["agent:spawn", "resource:cpu"],
+      "@neural_link": ["agent:spawn", "resource:cpu"],
+      "@nft": [],
+      "@npc_ai": ["agent:spawn", "resource:cpu"],
+      "@oauth": ["authority:own"],
+      "@object_tracking": ["state:read"],
+      "@occlusion": ["io:read", "io:write"],
+      "@openxr_hal": [],
+      "@opc_ua": ["io:network"],
+      "@orbital": [],
+      "@package_signing": ["authority:own"],
+      "@pagerduty": [],
+      "@partner_sdk": [],
+      "@patrol": ["agent:spawn", "resource:cpu"],
+      "@pdf_generate": ["io:read", "io:write"],
+      "@perception": ["agent:spawn", "resource:cpu"],
+      "@permission": ["io:read", "io:write"],
+      "@persistent_anchor": ["state:read", "state:write"],
+      "@photogrammetry": [],
+      "@pipeline": [],
+      "@plane_detection": ["io:read", "io:write"],
+      "@point_cloud": [],
+      "@poi": [],
+      "@portable": [],
+      "@pose_estimation": ["io:read", "io:write"],
+      "@profiler": ["io:read", "io:write"],
+      "@prompt_template": [],
+      "@push_notification": ["io:read", "io:write"],
+      "@query": [],
+      "@quota": [],
+      "@rag_knowledge": [],
+      "@rate_limiter": [],
+      "@ray_tracing": [],
+      "@rbac": ["authority:own"],
+      "@realitykit_mesh": ["render:spawn", "resource:gpu"],
+      "@refund": [],
+      "@remote_presence": [],
+      "@render_network": ["io:network"],
+      "@rest_endpoint": ["io:network"],
+      "@retry": [],
+      "@reverb_zone": ["audio:play"],
+      "@roadmap_node": [],
+      "@role": [],
+      "@rollback": [],
+      "@rollout": [],
+      "@rooftop_anchor": [],
+      "@room_mesh": ["render:spawn", "resource:gpu"],
+      "@rope": ["physics:force", "physics:collision"],
+      "@rpc": ["io:network"],
+      "@rsa_encryption": ["io:read", "io:write"],
+      "@rtl": [],
+      "@sandbox_execution": ["io:read", "io:write"],
+      "@scene_graph": [],
+      "@scene_reconstruction": ["io:read", "io:write"],
+      "@scheduler": [],
+      "@schema_migrate": [],
+      "@screen_reader": ["render:spawn", "resource:gpu"],
+      "@screen_space_effects": ["render:spawn", "resource:gpu"],
+      "@script_test": [],
+      "@scrollable": [],
+      "@seated": [],
+      "@secret": ["authority:own"],
+      "@sensor": [],
+      "@session": ["io:read", "io:write"],
+      "@hologram": [],
+      "@shared_anchor": [],
+      "@shared_world": [],
+      "@shareplay": [],
+      "@shell": [],
+      "@base": [],
+      "@url": [],
+      "@slack_alert": [],
+      "@slack": [],
+      "@slo_monitor": ["state:read"],
+      "@sms": ["io:read", "io:write"],
+      "@snapshot_test": ["state:read", "state:write"],
+      "@snapshot": ["state:read", "state:write"],
+      "@soft_body": ["physics:force", "physics:collision"],
+      "@sonification": ["io:read", "io:write"],
+      "@spatial_accessory": ["authority:own"],
+      "@spatial_audio_cue": ["audio:play"],
+      "@spatial_navigation": ["io:read", "io:write"],
+      "@spatial_persona": [],
+      "@spectator": [],
+      "@sse": ["io:network"],
+      "@sso_saml": ["authority:own"],
+      "@stable_diffusion": ["io:read", "io:write"],
+      "@state_machine": ["state:read", "state:write"],
+      "@stream": ["io:network"],
+      "@stripe": [],
+      "@structured_logger": [],
+      "@subscription": ["io:read", "io:write"],
+      "@subsurface_scattering": [],
+      "@subtitle": [],
+      "@task_queue": [],
+      "@tenant": [],
+      "@terrain_anchor": ["agent:spawn", "resource:cpu"],
+      "@timeout_guard": [],
+      "@timezone": [],
+      "@token_gated": [],
+      "@transform": ["state:read", "state:write"],
+      "@translation": ["io:read", "io:write"],
+      "@urdf_robot": [],
+      "@usd": [],
+      "@user_monitor": ["state:read"],
+      "@vector_db": [],
+      "@vector_search": [],
+      "@video_transcode": [],
+      "@vision": ["io:read", "io:write"],
+      "@voice_mesh": ["render:spawn", "resource:gpu"],
+      "@voice_proximity": ["audio:play"],
+      "@volumetric": ["render:spawn", "resource:gpu"],
+      "@volumetric_video": ["render:spawn", "resource:gpu"],
+      "@volumetric_window": ["render:spawn", "resource:gpu"],
+      "@vps": [],
+      "@vulnerability_scanner": [],
+      "@wallet": [],
+      "@watcher": [],
+      "@webhook_out": ["io:network"],
+      "@webhook": ["io:network"],
+      "@wind": [],
+      "@workflow": [],
+      "@wot_thing": [],
+      "@zero_knowledge_proof": ["authority:own"],
+      "@public_hash": []
+    };
+    BUILTIN_EFFECTS = {
+      // Object manipulation
+      spawn: ["render:spawn", "resource:memory"],
+      destroy: ["render:destroy"],
+      clone: ["render:spawn", "resource:memory"],
+      // Physics
+      applyForce: ["physics:force"],
+      applyImpulse: ["physics:impulse"],
+      setVelocity: ["physics:force"],
+      teleportTo: ["physics:teleport"],
+      setGravity: ["physics:gravity"],
+      // Audio
+      playSound: ["audio:play"],
+      stopSound: ["audio:stop"],
+      playSpatial: ["audio:spatial"],
+      playMusic: ["audio:global"],
+      // State
+      setState: ["state:write"],
+      getState: ["state:read"],
+      setGlobal: ["state:global"],
+      persist: ["state:persistent", "io:write"],
+      load: ["state:read", "io:read"],
+      save: ["state:write", "io:write"],
+      // IO
+      fetch: ["io:network"],
+      httpGet: ["io:network"],
+      httpPost: ["io:network", "io:write"],
+      readFile: ["io:read"],
+      writeFile: ["io:write"],
+      setTimeout: ["io:timer"],
+      setInterval: ["io:timer"],
+      // Inventory
+      giveItem: ["inventory:give"],
+      takeItem: ["inventory:take"],
+      destroyItem: ["inventory:destroy"],
+      tradeWith: ["inventory:trade"],
+      // Agent
+      spawnAgent: ["agent:spawn", "resource:cpu"],
+      killAgent: ["agent:kill"],
+      sendMessage: ["agent:communicate"],
+      observe: ["agent:observe"],
+      // Authority
+      transferOwnership: ["authority:delegate"],
+      revokeAccess: ["authority:revoke"],
+      claimZone: ["authority:zone"],
+      // Resource-heavy operations
+      createParticleSystem: ["render:particle", "resource:gpu"],
+      compileShader: ["render:shader", "resource:gpu"],
+      allocateBuffer: ["resource:memory", "resource:gpu"],
+      // Pure functions (no effects)
+      "Math.sin": [],
+      "Math.cos": [],
+      "Math.random": [],
+      lerp: [],
+      clamp: [],
+      distance: [],
+      normalize: [],
+      dot: [],
+      cross: []
+    };
+  }
+});
+
+// src/compiler/safety/EffectChecker.ts
+function createEffectChecker(config) {
+  return new EffectChecker(config);
+}
+function isSafeTraitSet(traits) {
+  const DANGEROUS = [
+    "authority:own",
+    "authority:delegate",
+    "authority:revoke",
+    "authority:zone",
+    "authority:world",
+    "inventory:take",
+    "inventory:destroy",
+    "inventory:duplicate",
+    "agent:spawn",
+    "agent:kill",
+    "agent:control",
+    "io:network",
+    "io:write",
+    "physics:teleport"
+  ];
+  const inferred = inferFromTraits(traits);
+  const dangerous = inferred.row.toArray().filter((e) => DANGEROUS.includes(e));
+  return { safe: dangerous.length === 0, dangerous };
+}
+function dangerLevel(row) {
+  let score = 0;
+  const weights = {
+    authority: 3,
+    inventory: 2,
+    agent: 2,
+    io: 1.5,
+    physics: 1,
+    render: 0.5,
+    audio: 0.3,
+    state: 0.5,
+    resource: 1,
+    exception: 0.2
+  };
+  for (const cat of row.categories()) {
+    score += (weights[cat] || 0) * row.ofCategory(cat).length;
+  }
+  return Math.min(10, Math.round(score * 10) / 10);
+}
+var DEFAULT_CONFIG, EffectChecker;
+var init_EffectChecker = __esm({
+  "src/compiler/safety/EffectChecker.ts"() {
+    init_effects();
+    init_EffectInference();
+    DEFAULT_CONFIG = {
+      undeclaredSeverity: "error",
+      unusedDeclaredSeverity: "warning",
+      ignoredCategories: [],
+      maxEffectsPerFunction: 0,
+      strictUnknownTraits: false
+    };
+    EffectChecker = class {
+      constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+      }
+      /**
+       * Check a single AST node (function or object definition) for effect correctness.
+       */
+      checkNode(node) {
+        const name = node.name || "<anonymous>";
+        const traitEffects = inferFromTraits(node.traits || []);
+        const builtinEffects = inferFromBuiltins(node.calls || []);
+        const adapterEffects = this.inferFromAdapter(node);
+        const childEffects = [];
+        if (node.children) {
+          for (const child of node.children) {
+            const childResult = this.checkNode(child);
+            childEffects.push({
+              row: childResult.inferred,
+              sources: childResult.sources,
+              warnings: []
+            });
+          }
+        }
+        const combined = composeEffects(traitEffects, builtinEffects, adapterEffects, ...childEffects);
+        let inferred = combined.row;
+        if (this.config.ignoredCategories.length > 0) {
+          const filtered = inferred.toArray().filter((e) => {
+            const cat = e.split(":")[0];
+            return !this.config.ignoredCategories.includes(cat);
+          });
+          inferred = new EffectRow(filtered);
+        }
+        const declared = node.declaredEffects ? new EffectRow(node.declaredEffects) : EffectRow.PURE;
+        const undeclared = inferred.difference(declared);
+        const unused = declared.difference(inferred);
+        const violations = this.computeViolations(name, node, undeclared, unused, combined.sources);
+        return { name, declared, inferred, undeclared, unused, violations, sources: combined.sources };
+      }
+      /**
+       * Check an entire module (array of top-level AST nodes).
+       */
+      checkModule(nodes, moduleId) {
+        const functions = /* @__PURE__ */ new Map();
+        const allViolations = [];
+        let moduleEffects = EffectRow.PURE;
+        const warnings = [];
+        for (const node of nodes) {
+          const result = this.checkNode(node);
+          functions.set(result.name, result);
+          allViolations.push(...result.violations);
+          moduleEffects = moduleEffects.union(result.inferred);
+        }
+        const hasErrors = allViolations.some((v) => v.severity === "error");
+        return {
+          functions,
+          violations: allViolations,
+          moduleEffects,
+          passed: !hasErrors,
+          totalEffects: moduleEffects.size,
+          warnings
+        };
+      }
+      /**
+       * Quick check: does a function with given traits and calls stay within a declared effect set?
+       */
+      quickCheck(traits, calls, allowed) {
+        const inferred = composeEffects(inferFromTraits(traits), inferFromBuiltins(calls));
+        const allowedRow = new EffectRow(allowed);
+        const undeclaredRow = inferred.row.difference(allowedRow);
+        return { passed: undeclaredRow.isPure(), undeclared: undeclaredRow.toArray() };
+      }
+      // ---------------------------------------------------------------------------
+      // INTERNAL
+      // ---------------------------------------------------------------------------
+      computeViolations(name, node, undeclared, unused, sources) {
+        const violations = [];
+        for (const effect of undeclared.toArray()) {
+          const sourceList = sources.get(effect) || ["unknown"];
+          violations.push({
+            effect,
+            source: { file: node.file, line: node.line, column: node.column, functionName: name },
+            message: `Undeclared effect '${effect}' in '${name}'. Caused by: ${sourceList.join(", ")}`,
+            severity: this.config.undeclaredSeverity,
+            suggestion: `Add '${effect}' to the effect declaration of '${name}', or remove the causing trait/call.`
+          });
+        }
+        for (const effect of unused.toArray()) {
+          violations.push({
+            effect,
+            source: { file: node.file, line: node.line, column: node.column, functionName: name },
+            message: `Declared effect '${effect}' in '${name}' is never used.`,
+            severity: this.config.unusedDeclaredSeverity,
+            suggestion: `Remove '${effect}' from the effect declaration if it's not needed.`
+          });
+        }
+        if (this.config.maxEffectsPerFunction > 0) {
+          undeclared.size + unused.size;
+          undeclared.toArray().length + (node.declaredEffects?.length || 0);
+        }
+        return violations;
+      }
+      inferFromAdapter(node) {
+        const effects = node.inferredEffects || [];
+        const sources = /* @__PURE__ */ new Map();
+        for (const effect of effects) {
+          sources.set(effect, node.effectSources?.[effect] || ["config-aware AST inference"]);
+        }
+        return {
+          row: new EffectRow(effects),
+          sources,
+          warnings: []
+        };
+      }
+    };
+  }
+});
+
+export { EFFECTS_BY_CATEGORY, EffectChecker, EffectRow, TRAIT_EFFECTS, createEffectChecker, dangerLevel, effectCategory, inferFromBuiltins, inferFromTraits, init_EffectChecker, init_EffectInference, init_effects, isSafeTraitSet, knownBuiltins, knownTraits };
+//# sourceMappingURL=chunk-ZVFHPMC5.js.map
+//# sourceMappingURL=chunk-ZVFHPMC5.js.map