@holoscript/core 7.0.0 → 8.0.1

package/dist/coordinators/index.js

@@ -0,0 +1,1259 @@
+import '../chunk-OL46QLBJ.js';
+
+// src/coordinators/AssetLoadCoordinator.ts
+var ASSET_LOAD_EVENTS = [
+  // GLTF
+  "gltf:loaded",
+  "gltf:loading_progress",
+  "gltf:load_error",
+  "gltf:load_started",
+  // USD
+  "usd:loaded",
+  "usd:loading_progress",
+  "usd:load_error",
+  "usd:load_started",
+  // FBX
+  "fbx:loaded",
+  "fbx:loading_progress",
+  "fbx:load_error",
+  "fbx:load_started",
+  // Format-agnostic shared channel — all three traits ALSO emit these
+  // for cross-format observers that don't care about the source format.
+  "on_asset_loaded",
+  "on_asset_progress",
+  "on_asset_error"
+];
+var AssetLoadCoordinator = class {
+  constructor(source) {
+    this.states = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    for (const event of ASSET_LOAD_EVENTS) {
+      source.on(event, (payload) => this.handleEvent(event, payload));
+    }
+  }
+  handleEvent(event, payload) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const url = p.url ?? p.modelId ?? p.assetId;
+    if (!url || typeof url !== "string") return;
+    const format = this.formatFromEvent(event);
+    const phase = this.phaseFromEvent(event);
+    const existing = this.states.get(url);
+    const next = {
+      url,
+      format: existing?.format && existing.format !== "unknown" ? existing.format : format,
+      status: "idle",
+      progress: existing?.progress ?? 0,
+      updatedAt: Date.now()
+    };
+    if (phase === "started") {
+      next.status = "loading";
+      next.progress = 0;
+    } else if (phase === "progress") {
+      next.status = "loading";
+      const progressVal = p.progress;
+      if (typeof progressVal === "number" && progressVal >= 0 && progressVal <= 1) {
+        next.progress = progressVal;
+      }
+    } else if (phase === "loaded") {
+      next.status = "loaded";
+      next.progress = 1;
+    } else if (phase === "error") {
+      next.status = "error";
+      next.error = typeof p.error === "string" ? p.error : typeof p.message === "string" ? p.message : "unknown error";
+    }
+    this.states.set(url, next);
+    this.notifyListeners(next);
+  }
+  formatFromEvent(event) {
+    if (event.startsWith("gltf:")) return "gltf";
+    if (event.startsWith("usd:")) return "usd";
+    if (event.startsWith("fbx:")) return "fbx";
+    return "unknown";
+  }
+  phaseFromEvent(event) {
+    if (event.endsWith(":loaded") || event === "on_asset_loaded") return "loaded";
+    if (event.endsWith(":load_error") || event === "on_asset_error") return "error";
+    if (event.endsWith(":loading_progress") || event === "on_asset_progress") return "progress";
+    if (event.endsWith(":load_started")) return "started";
+    return "unknown";
+  }
+  notifyListeners(state) {
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch (_) {
+      }
+    }
+  }
+  /** Subscribe to all asset-state changes. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Read the current state of one asset (or undefined if never seen). */
+  getAssetState(url) {
+    return this.states.get(url);
+  }
+  /** Read all tracked asset states (snapshot copy — safe to iterate). */
+  getAllStates() {
+    return Array.from(this.states.values());
+  }
+  /** Aggregate stats across all tracked assets. */
+  getStats() {
+    const all = Array.from(this.states.values());
+    const loading = all.filter((s) => s.status === "loading");
+    const loaded = all.filter((s) => s.status === "loaded");
+    const failed = all.filter((s) => s.status === "error");
+    const averageProgress = loading.length > 0 ? loading.reduce((sum, s) => sum + s.progress, 0) / loading.length : 0;
+    return {
+      total: all.length,
+      loading: loading.length,
+      loaded: loaded.length,
+      failed: failed.length,
+      averageProgress
+    };
+  }
+  /** Clear all tracked state — typically called on scene change. */
+  reset() {
+    this.states.clear();
+  }
+  /** Number of distinct event types this coordinator subscribes to (diagnostic). */
+  get subscribedEventCount() {
+    return ASSET_LOAD_EVENTS.length;
+  }
+};
+
+// src/coordinators/SecurityEventBus.ts
+var SECURITY_EVENTS = [
+  // --- RBAC (authz) ---
+  "rbac_initialized",
+  "rbac_error",
+  "rbac_role_assigned",
+  "rbac_role_revoked",
+  "rbac_permission_result",
+  "rbac_custom_role_created",
+  "rbac_custom_role_deleted",
+  "rbac_user_roles",
+  "rbac_access_log",
+  "rbac_capability_result",
+  "rbac_capability_granted",
+  "rbac_capability_revoked",
+  "rbac_tenant_changed",
+  "rbac_capability_delegated",
+  "rbac_tenant_id",
+  "rbac_agent_capabilities",
+  "rbac_sync_roles",
+  // --- SSO (auth) ---
+  "sso_initialized",
+  "sso_error",
+  "sso_session_revoked",
+  "sso_session_expired",
+  "sso_idp_registered",
+  "sso_idp_removed",
+  "sso_auth_error",
+  "sso_saml_authn_request",
+  "sso_oidc_auth_redirect",
+  "sso_user_provisioned",
+  "sso_authenticated",
+  "sso_global_logout",
+  "sso_saml_slo_request",
+  "sso_session_validation",
+  "sso_info",
+  // --- Quota ---
+  "quota_initialized",
+  "quota_error",
+  "quota_reset",
+  "quota_grace_expired",
+  "quota_grace_started",
+  "quota_exceeded",
+  "quota_threshold_reached",
+  "quota_consumed",
+  "quota_released",
+  "quota_limit_changed",
+  "quota_tier_applied",
+  "quota_info",
+  "quota_usage_report_result",
+  // --- Tenant ---
+  "tenant_provisioned",
+  "tenant_error",
+  "tenant_decommissioned",
+  "tenant_status_changed",
+  "tenant_trait_registered",
+  "tenant_trait_unregistered",
+  "tenant_tier_changed",
+  "tenant_info",
+  "cross_tenant_grant_created",
+  "cross_tenant_grant_revoked",
+  "cross_tenant_grant_denied",
+  "cross_tenant_grant_expired",
+  // --- AuditLog (cross-cutting) ---
+  "audit_log",
+  "audit_entry_created",
+  "audit_siem_notify",
+  "audit_critical_event",
+  "audit_query_result",
+  "audit_integrity_result",
+  "audit_stats_result",
+  "audit_export_result",
+  "audit_error",
+  // --- ForgetPolicy ---
+  "forget_policy_attached",
+  "forget_policy_detached",
+  "forget_evaluate",
+  "forget_audit_entry",
+  "forget_apply",
+  "forget_audit_log",
+  "forget_error"
+];
+var DEFAULT_AUDIT_BUFFER_SIZE = 256;
+var SecurityEventBus = class {
+  constructor(source, auditBufferSize = DEFAULT_AUDIT_BUFFER_SIZE) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.agents = /* @__PURE__ */ new Map();
+    this.quotas = /* @__PURE__ */ new Map();
+    // key = `${resource}:${subject}`
+    this.tenants = /* @__PURE__ */ new Map();
+    this.auditLog = [];
+    this.listeners = /* @__PURE__ */ new Set();
+    this.auditBufferSize = Math.max(0, Math.floor(auditBufferSize));
+    for (const event of SECURITY_EVENTS) {
+      source.on(event, (payload) => this.handleEvent(event, payload));
+    }
+  }
+  // ---- Event ingestion ---------------------------------------------------
+  handleEvent(event, payload) {
+    const domain = this.domainFromEvent(event);
+    const observedAt = Date.now();
+    if (domain === "auth") this.applyAuthEvent(event, payload, observedAt);
+    else if (domain === "authz") this.applyAuthzEvent(event, payload, observedAt);
+    else if (domain === "quota") this.applyQuotaEvent(event, payload, observedAt);
+    else if (domain === "tenant") this.applyTenantEvent(event, payload, observedAt);
+    if (domain === "audit" || event === "audit_log" || event === "forget_audit_log" || event === "forget_audit_entry") {
+      this.appendAudit(event, payload, observedAt);
+    }
+    this.notifyListeners({ domain, event, payload, observedAt });
+  }
+  domainFromEvent(event) {
+    if (event.startsWith("sso_")) return "auth";
+    if (event.startsWith("rbac_")) return "authz";
+    if (event.startsWith("quota_")) return "quota";
+    if (event.startsWith("tenant_") || event.startsWith("cross_tenant_")) return "tenant";
+    if (event.startsWith("audit_")) return "audit";
+    if (event.startsWith("forget_")) return "forget";
+    return "unknown";
+  }
+  applyAuthEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const sessionId = p.sessionId ?? p.sid;
+    if (!sessionId || typeof sessionId !== "string") return;
+    const existing = this.sessions.get(sessionId);
+    let status = null;
+    if (event === "sso_authenticated") status = "authenticated";
+    else if (event === "sso_session_expired") status = "expired";
+    else if (event === "sso_session_revoked" || event === "sso_global_logout") status = "revoked";
+    if (status === null) return;
+    const next = {
+      sessionId,
+      status,
+      idp: typeof p.idp === "string" ? p.idp : existing?.idp,
+      userId: typeof p.userId === "string" ? p.userId : existing?.userId,
+      updatedAt: observedAt
+    };
+    this.sessions.set(sessionId, next);
+  }
+  applyAuthzEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const agentId = p.agentId ?? p.userId ?? p.subject;
+    if (!agentId || typeof agentId !== "string") return;
+    const existing = this.agents.get(agentId) ?? {
+      roles: /* @__PURE__ */ new Set(),
+      capabilities: /* @__PURE__ */ new Set()};
+    const roles = new Set(existing.roles);
+    const capabilities = new Set(existing.capabilities);
+    let tenantId = existing.tenantId;
+    if (event === "rbac_role_assigned" && typeof p.role === "string") roles.add(p.role);
+    else if (event === "rbac_role_revoked" && typeof p.role === "string") roles.delete(p.role);
+    else if (event === "rbac_capability_granted" && typeof p.capability === "string") capabilities.add(p.capability);
+    else if (event === "rbac_capability_revoked" && typeof p.capability === "string") capabilities.delete(p.capability);
+    else if (event === "rbac_tenant_changed" && typeof p.tenantId === "string") tenantId = p.tenantId;
+    else if (event === "rbac_user_roles" && Array.isArray(p.roles)) {
+      roles.clear();
+      for (const r of p.roles) if (typeof r === "string") roles.add(r);
+    } else if (event === "rbac_agent_capabilities" && Array.isArray(p.capabilities)) {
+      capabilities.clear();
+      for (const c of p.capabilities) if (typeof c === "string") capabilities.add(c);
+    } else {
+      return;
+    }
+    this.agents.set(agentId, { agentId, tenantId, roles, capabilities, updatedAt: observedAt });
+  }
+  applyQuotaEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const resource = typeof p.resource === "string" ? p.resource : void 0;
+    const subject = typeof p.tenantId === "string" && p.tenantId || typeof p.agentId === "string" && p.agentId || typeof p.subject === "string" && p.subject || void 0;
+    if (!resource || !subject) return;
+    const key = `${resource}:${subject}`;
+    const existing = this.quotas.get(key) ?? {
+      consumed: 0,
+      limit: 0,
+      status: "ok"};
+    let status = existing.status;
+    let consumed = existing.consumed;
+    let limit = existing.limit;
+    if (typeof p.consumed === "number") consumed = p.consumed;
+    if (typeof p.limit === "number") limit = p.limit;
+    if (event === "quota_exceeded") status = "exceeded";
+    else if (event === "quota_grace_started") status = "grace";
+    else if (event === "quota_grace_expired") status = "exceeded";
+    else if (event === "quota_threshold_reached") status = "threshold_reached";
+    else if (event === "quota_reset" || event === "quota_released" || event === "quota_consumed") {
+      if (limit > 0 && consumed >= limit) status = "exceeded";
+      else if (limit > 0 && consumed >= limit * 0.9) status = "threshold_reached";
+      else status = "ok";
+    }
+    this.quotas.set(key, { resource, subject, consumed, limit, status, updatedAt: observedAt });
+  }
+  applyTenantEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const tenantId = typeof p.tenantId === "string" ? p.tenantId : void 0;
+    if (!tenantId) return;
+    const existing = this.tenants.get(tenantId);
+    let status = existing?.status;
+    let tier = existing?.tier;
+    if (event === "tenant_provisioned") status = "provisioned";
+    else if (event === "tenant_decommissioned") status = "decommissioned";
+    else if (event === "tenant_status_changed" && typeof p.status === "string") {
+      const s = p.status;
+      if (s === "active" || s === "suspended" || s === "provisioned" || s === "decommissioned") status = s;
+    } else if (event === "tenant_tier_changed" && typeof p.tier === "string") {
+      tier = p.tier;
+    } else {
+      return;
+    }
+    if (!status) return;
+    this.tenants.set(tenantId, { tenantId, status, tier, updatedAt: observedAt });
+  }
+  appendAudit(event, payload, observedAt) {
+    if (this.auditBufferSize === 0) return;
+    const p = payload && typeof payload === "object" ? payload : {};
+    const entry = {
+      event,
+      action: typeof p.action === "string" ? p.action : void 0,
+      actor: typeof p.actor === "string" && p.actor || typeof p.agentId === "string" && p.agentId || typeof p.userId === "string" && p.userId || void 0,
+      tenantId: typeof p.tenantId === "string" ? p.tenantId : void 0,
+      outcome: p.outcome === "success" || p.outcome === "denied" || p.outcome === "error" ? p.outcome : void 0,
+      observedAt
+    };
+    this.auditLog.push(entry);
+    if (this.auditLog.length > this.auditBufferSize) {
+      this.auditLog.splice(0, this.auditLog.length - this.auditBufferSize);
+    }
+  }
+  notifyListeners(envelope) {
+    for (const listener of this.listeners) {
+      try {
+        listener(envelope);
+      } catch (_) {
+      }
+    }
+  }
+  // ---- Public API --------------------------------------------------------
+  /** Subscribe to all security events. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  getAllSessions() {
+    return Array.from(this.sessions.values());
+  }
+  getAgent(agentId) {
+    const a = this.agents.get(agentId);
+    if (!a) return void 0;
+    return { ...a, roles: new Set(a.roles), capabilities: new Set(a.capabilities) };
+  }
+  getAllAgents() {
+    return Array.from(this.agents.values()).map((a) => ({
+      ...a,
+      roles: new Set(a.roles),
+      capabilities: new Set(a.capabilities)
+    }));
+  }
+  getQuota(resource, subject) {
+    return this.quotas.get(`${resource}:${subject}`);
+  }
+  getAllQuotas() {
+    return Array.from(this.quotas.values());
+  }
+  getTenant(tenantId) {
+    return this.tenants.get(tenantId);
+  }
+  getAllTenants() {
+    return Array.from(this.tenants.values());
+  }
+  /** Snapshot of the rolling audit-log buffer (oldest first). */
+  getAuditLog() {
+    return this.auditLog.slice();
+  }
+  getStats() {
+    const sessions = Array.from(this.sessions.values());
+    const tenants = Array.from(this.tenants.values());
+    const quotas = Array.from(this.quotas.values());
+    return {
+      sessions: {
+        authenticated: sessions.filter((s) => s.status === "authenticated").length,
+        expired: sessions.filter((s) => s.status === "expired").length,
+        revoked: sessions.filter((s) => s.status === "revoked").length
+      },
+      agents: { tracked: this.agents.size },
+      tenants: {
+        active: tenants.filter((t) => t.status === "active" || t.status === "provisioned").length,
+        suspended: tenants.filter((t) => t.status === "suspended").length,
+        decommissioned: tenants.filter((t) => t.status === "decommissioned").length
+      },
+      quotas: {
+        tracked: quotas.length,
+        exceeded: quotas.filter((q) => q.status === "exceeded").length,
+        grace: quotas.filter((q) => q.status === "grace").length
+      },
+      auditLog: { entries: this.auditLog.length, capacity: this.auditBufferSize }
+    };
+  }
+  /** Clear all tracked state — typically called on tenant teardown or test reset. */
+  reset() {
+    this.sessions.clear();
+    this.agents.clear();
+    this.quotas.clear();
+    this.tenants.clear();
+    this.auditLog = [];
+  }
+  /** Number of distinct event types this bus subscribes to (diagnostic). */
+  get subscribedEventCount() {
+    return SECURITY_EVENTS.length;
+  }
+};
+
+// src/coordinators/GenerativeJobMonitor.ts
+var GENERATIVE_JOB_EVENTS = [
+  // --- AiInpainting ---
+  "inpainting:ready",
+  "inpainting:cancelled",
+  "inpainting:mask_set",
+  "inpainting:started",
+  "inpainting:result",
+  "inpainting:original_restored",
+  "inpainting:error",
+  // --- AiTextureGen ---
+  "texture_gen:ready",
+  "texture_gen:cancelled",
+  "texture_gen:queued",
+  "texture_gen:started",
+  "texture_gen:applied",
+  // --- ControlNet ---
+  "controlnet:ready",
+  "controlnet:cancelled",
+  "controlnet:started",
+  "controlnet:result",
+  "controlnet:error",
+  "controlnet:map_requested",
+  // --- DiffusionRealtime ---
+  "diffusion_rt:ready",
+  "diffusion_rt:stopped",
+  "diffusion_rt:started",
+  "diffusion_rt:frame_ready",
+  "diffusion_rt:prompt_updated"
+];
+var KIND_PREFIXES = [
+  ["inpainting:", "inpainting"],
+  ["texture_gen:", "texture_gen"],
+  ["controlnet:", "controlnet"],
+  ["diffusion_rt:", "diffusion_rt"]
+];
+var GenerativeJobMonitor = class {
+  constructor(source) {
+    this.jobs = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    /** Tracks which trait kinds have fired their `<kind>:ready` event. */
+    this.readyKinds = /* @__PURE__ */ new Set();
+    for (const event of GENERATIVE_JOB_EVENTS) {
+      source.on(event, (payload) => this.handleEvent(event, payload));
+    }
+  }
+  // ---- Event ingestion ---------------------------------------------------
+  handleEvent(event, payload) {
+    const kind = this.kindFromEvent(event);
+    if (!kind) return;
+    const phase = this.phaseFromEvent(event);
+    const observedAt = Date.now();
+    if (phase === "ready") {
+      this.readyKinds.add(kind);
+      this.notifyListeners({
+        jobId: `__ready:${kind}`,
+        kind,
+        status: "completed",
+        startedAt: observedAt,
+        updatedAt: observedAt
+      });
+      return;
+    }
+    if (phase === "config") return;
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const jobId = this.jobIdFromPayload(p, kind);
+    if (!jobId) return;
+    const existing = this.jobs.get(jobId);
+    const startedAt = existing?.startedAt ?? observedAt;
+    let status = null;
+    let durationMs = existing?.durationMs;
+    let error = existing?.error;
+    if (phase === "queued") {
+      status = "queued";
+    } else if (phase === "started") {
+      status = "running";
+    } else if (phase === "success") {
+      status = "completed";
+      durationMs = observedAt - startedAt;
+    } else if (phase === "cancelled") {
+      status = "cancelled";
+      durationMs = observedAt - startedAt;
+    } else if (phase === "error") {
+      status = "errored";
+      durationMs = observedAt - startedAt;
+      error = typeof p.error === "string" ? p.error : typeof p.message === "string" ? p.message : "unknown error";
+    }
+    if (status === null) return;
+    const next = {
+      jobId,
+      kind,
+      status,
+      startedAt,
+      updatedAt: observedAt,
+      durationMs,
+      error
+    };
+    this.jobs.set(jobId, next);
+    this.notifyListeners(next);
+  }
+  kindFromEvent(event) {
+    for (const [prefix, kind] of KIND_PREFIXES) {
+      if (event.startsWith(prefix)) return kind;
+    }
+    return null;
+  }
+  phaseFromEvent(event) {
+    const suffix = event.slice(event.indexOf(":") + 1);
+    if (suffix === "ready") return "ready";
+    if (suffix === "queued") return "queued";
+    if (suffix === "started") return "started";
+    if (suffix === "result" || suffix === "applied" || suffix === "original_restored" || suffix === "frame_ready")
+      return "success";
+    if (suffix === "cancelled" || suffix === "stopped") return "cancelled";
+    if (suffix === "error") return "error";
+    if (suffix === "mask_set" || suffix === "map_requested" || suffix === "prompt_updated") return "config";
+    return "unknown";
+  }
+  /**
+   * Resolve the stable job ID from a payload, falling back across the
+   * fields each trait happens to use. Mirrors the heuristic in
+   * AssetLoadCoordinator.handleEvent.
+   */
+  jobIdFromPayload(p, kind) {
+    if (kind === "diffusion_rt" && typeof p.frameNumber === "number") {
+      const sid = typeof p.sessionId === "string" ? p.sessionId : "rt";
+      return `${sid}:${p.frameNumber}`;
+    }
+    const candidates = [p.requestId, p.jobId, p.textureId, p.sessionId, p.nodeId, p.id];
+    for (const c of candidates) {
+      if (typeof c === "string" && c.length > 0) return c;
+    }
+    return void 0;
+  }
+  notifyListeners(state) {
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch (_) {
+      }
+    }
+  }
+  // ---- Public API --------------------------------------------------------
+  /** Subscribe to all job-state changes. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getJob(jobId) {
+    return this.jobs.get(jobId);
+  }
+  getAllJobs() {
+    return Array.from(this.jobs.values());
+  }
+  getJobsByKind(kind) {
+    return Array.from(this.jobs.values()).filter((j) => j.kind === kind);
+  }
+  isReady(kind) {
+    return this.readyKinds.has(kind);
+  }
+  getStats() {
+    const empty = () => ({
+      queued: 0,
+      running: 0,
+      completed: 0,
+      cancelled: 0,
+      errored: 0,
+      meanLatencyMs: 0
+    });
+    const byKind = {
+      inpainting: empty(),
+      texture_gen: empty(),
+      controlnet: empty(),
+      diffusion_rt: empty()
+    };
+    const latencyTotals = {
+      inpainting: { sum: 0, count: 0 },
+      texture_gen: { sum: 0, count: 0 },
+      controlnet: { sum: 0, count: 0 },
+      diffusion_rt: { sum: 0, count: 0 }
+    };
+    for (const job of this.jobs.values()) {
+      const stats = byKind[job.kind];
+      if (job.status === "queued") stats.queued++;
+      else if (job.status === "running") stats.running++;
+      else if (job.status === "completed") {
+        stats.completed++;
+        if (typeof job.durationMs === "number") {
+          latencyTotals[job.kind].sum += job.durationMs;
+          latencyTotals[job.kind].count++;
+        }
+      } else if (job.status === "cancelled") stats.cancelled++;
+      else if (job.status === "errored") stats.errored++;
+    }
+    for (const k of Object.keys(byKind)) {
+      const t = latencyTotals[k];
+      byKind[k].meanLatencyMs = t.count > 0 ? t.sum / t.count : 0;
+    }
+    return {
+      total: this.jobs.size,
+      byKind,
+      anyReady: this.readyKinds.size > 0
+    };
+  }
+  /** Clear all tracked jobs — typically called on scene change. */
+  reset() {
+    this.jobs.clear();
+    this.readyKinds.clear();
+  }
+  /** Number of distinct event types this monitor subscribes to (diagnostic). */
+  get subscribedEventCount() {
+    return GENERATIVE_JOB_EVENTS.length;
+  }
+};
+
+// src/coordinators/SessionPresenceCoordinator.ts
+var PRESENCE_EVENTS = [
+  // --- SharePlay ---
+  "shareplay:ready",
+  "shareplay:ended",
+  "shareplay:started",
+  "shareplay:joined",
+  "shareplay:participant_joined",
+  "shareplay:participant_left",
+  "shareplay:state_synced",
+  // --- SpatialVoice ---
+  "spatial_voice_create",
+  "spatial_voice_destroy",
+  "spatial_voice_position",
+  "spatial_voice_peer_joined",
+  "spatial_voice_peer_left",
+  "spatial_voice_muted",
+  "spatial_voice_unmuted",
+  "on_voice_activity",
+  // --- Messaging ---
+  "messaging_connected",
+  "messaging_disconnected",
+  "messaging_error",
+  "messaging_stats",
+  "message_received",
+  "message_sent",
+  "command_parsed",
+  // (`command_<name>` events are dynamic — not subscribed here. Consumers
+  // that care about specific commands subscribe directly through the
+  // event source.)
+  // --- WorldHeartbeat ---
+  "heartbeat_initialized",
+  "heartbeat_tick",
+  "heartbeat_failover",
+  "heartbeat_error"
+];
+var SessionPresenceCoordinator = class {
+  constructor(source) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.voice = /* @__PURE__ */ new Map();
+    this.messaging = /* @__PURE__ */ new Map();
+    this.heartbeats = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    for (const event of PRESENCE_EVENTS) {
+      source.on(event, (payload) => this.handleEvent(event, payload));
+    }
+  }
+  // ---- Event ingestion ---------------------------------------------------
+  handleEvent(event, payload) {
+    const domain = this.domainFromEvent(event);
+    const observedAt = Date.now();
+    if (domain === "shareplay") this.applySharePlayEvent(event, payload, observedAt);
+    else if (domain === "voice") this.applyVoiceEvent(event, payload, observedAt);
+    else if (domain === "messaging") this.applyMessagingEvent(event, payload, observedAt);
+    else if (domain === "heartbeat") this.applyHeartbeatEvent(event, payload, observedAt);
+    this.notifyListeners({ domain, event, payload, observedAt });
+  }
+  domainFromEvent(event) {
+    if (event.startsWith("shareplay:")) return "shareplay";
+    if (event.startsWith("spatial_voice_") || event === "on_voice_activity") return "voice";
+    if (event.startsWith("messaging_") || event === "message_received" || event === "message_sent" || event === "command_parsed")
+      return "messaging";
+    if (event.startsWith("heartbeat_")) return "heartbeat";
+    return "unknown";
+  }
+  // ---- SharePlay ---------------------------------------------------------
+  applySharePlayEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    if (event === "shareplay:ready") return;
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : void 0;
+    if (!sessionId) return;
+    const existing = this.sessions.get(sessionId);
+    const participants = new Set(existing?.participants ?? []);
+    let status = existing?.status ?? "idle";
+    if (event === "shareplay:started") status = "started";
+    else if (event === "shareplay:joined") status = "joined";
+    else if (event === "shareplay:ended") status = "ended";
+    else if (event === "shareplay:participant_joined") {
+      const pid = typeof p.participantId === "string" ? p.participantId : void 0;
+      if (pid) participants.add(pid);
+    } else if (event === "shareplay:participant_left") {
+      const pid = typeof p.participantId === "string" ? p.participantId : void 0;
+      if (pid) participants.delete(pid);
+    }
+    this.sessions.set(sessionId, {
+      sessionId,
+      status,
+      participants,
+      activityTitle: existing?.activityTitle,
+      updatedAt: observedAt
+    });
+  }
+  // ---- SpatialVoice ------------------------------------------------------
+  applyVoiceEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const nodeId = typeof p.nodeId === "string" ? p.nodeId : void 0;
+    if (event === "spatial_voice_create" && nodeId) {
+      this.voice.set(nodeId, {
+        nodeId,
+        peers: /* @__PURE__ */ new Set(),
+        muted: false,
+        lastVoiceActivityAt: 0,
+        updatedAt: observedAt
+      });
+      return;
+    }
+    if (event === "spatial_voice_destroy" && nodeId) {
+      this.voice.delete(nodeId);
+      return;
+    }
+    if (event === "spatial_voice_peer_joined" && nodeId) {
+      const peerId = typeof p.peerId === "string" ? p.peerId : void 0;
+      const existing = this.voice.get(nodeId);
+      if (!existing || !peerId) return;
+      const peers = new Set(existing.peers);
+      peers.add(peerId);
+      this.voice.set(nodeId, { ...existing, peers, updatedAt: observedAt });
+      return;
+    }
+    if (event === "spatial_voice_peer_left" && nodeId) {
+      const peerId = typeof p.peerId === "string" ? p.peerId : void 0;
+      const existing = this.voice.get(nodeId);
+      if (!existing || !peerId) return;
+      const peers = new Set(existing.peers);
+      peers.delete(peerId);
+      this.voice.set(nodeId, { ...existing, peers, updatedAt: observedAt });
+      return;
+    }
+    for (const existing of this.voice.values()) {
+      let next = existing;
+      if (event === "spatial_voice_muted") next = { ...existing, muted: true, updatedAt: observedAt };
+      else if (event === "spatial_voice_unmuted") next = { ...existing, muted: false, updatedAt: observedAt };
+      else if (event === "on_voice_activity")
+        next = { ...existing, lastVoiceActivityAt: observedAt, updatedAt: observedAt };
+      else continue;
+      this.voice.set(existing.nodeId, next);
+    }
+  }
+  // ---- Messaging ---------------------------------------------------------
+  applyMessagingEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const platform = typeof p.platform === "string" ? p.platform : void 0;
+    if (!platform) return;
+    const existing = this.messaging.get(platform) ?? {
+      status: "disconnected",
+      messagesReceived: 0,
+      messagesSent: 0};
+    let status = existing.status;
+    let error = existing.error;
+    let received = existing.messagesReceived;
+    let sent = existing.messagesSent;
+    if (event === "messaging_connected") {
+      status = "connected";
+      error = void 0;
+    } else if (event === "messaging_disconnected") {
+      status = "disconnected";
+    } else if (event === "messaging_error") {
+      status = "errored";
+      error = typeof p.error === "string" ? p.error : "unknown error";
+    } else if (event === "message_received") {
+      received++;
+    } else if (event === "message_sent") {
+      sent++;
+    } else ;
+    this.messaging.set(platform, {
+      platform,
+      status,
+      messagesReceived: received,
+      messagesSent: sent,
+      error,
+      updatedAt: observedAt
+    });
+  }
+  // ---- WorldHeartbeat ----------------------------------------------------
+  applyHeartbeatEvent(event, payload, observedAt) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const nodeId = typeof p.nodeId === "string" && p.nodeId || typeof p.worldId === "string" && p.worldId || typeof p.id === "string" && p.id || void 0;
+    if (!nodeId) return;
+    const existing = this.heartbeats.get(nodeId) ?? {
+      status: "initialized",
+      ticks: 0,
+      lastTickAt: 0};
+    let status = existing.status;
+    let ticks = existing.ticks;
+    let lastTickAt = existing.lastTickAt;
+    let error = existing.error;
+    if (event === "heartbeat_initialized") {
+      status = "initialized";
+      error = void 0;
+    } else if (event === "heartbeat_tick") {
+      status = "alive";
+      ticks++;
+      lastTickAt = observedAt;
+    } else if (event === "heartbeat_failover") {
+      status = "failover";
+    } else if (event === "heartbeat_error") {
+      status = "errored";
+      error = typeof p.error === "string" ? p.error : typeof p.message === "string" ? p.message : "unknown error";
+    }
+    this.heartbeats.set(nodeId, { nodeId, status, ticks, lastTickAt, error, updatedAt: observedAt });
+  }
+  notifyListeners(envelope) {
+    for (const listener of this.listeners) {
+      try {
+        listener(envelope);
+      } catch (_) {
+      }
+    }
+  }
+  // ---- Public API --------------------------------------------------------
+  /** Subscribe to all presence events. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  // SharePlay
+  getSession(sessionId) {
+    const s = this.sessions.get(sessionId);
+    return s ? { ...s, participants: new Set(s.participants) } : void 0;
+  }
+  getAllSessions() {
+    return Array.from(this.sessions.values()).map((s) => ({ ...s, participants: new Set(s.participants) }));
+  }
+  // SpatialVoice
+  getVoiceNode(nodeId) {
+    const v = this.voice.get(nodeId);
+    return v ? { ...v, peers: new Set(v.peers) } : void 0;
+  }
+  getAllVoiceNodes() {
+    return Array.from(this.voice.values()).map((v) => ({ ...v, peers: new Set(v.peers) }));
+  }
+  // Messaging
+  getMessagingConnection(platform) {
+    return this.messaging.get(platform);
+  }
+  getAllMessagingConnections() {
+    return Array.from(this.messaging.values());
+  }
+  // Heartbeat
+  getHeartbeat(nodeId) {
+    return this.heartbeats.get(nodeId);
+  }
+  getAllHeartbeats() {
+    return Array.from(this.heartbeats.values());
+  }
+  getStats() {
+    const sessions = Array.from(this.sessions.values());
+    const voice = Array.from(this.voice.values());
+    const messaging = Array.from(this.messaging.values());
+    const heartbeats = Array.from(this.heartbeats.values());
+    const totalParticipants = sessions.reduce((sum, s) => sum + s.participants.size, 0);
+    const totalPeers = voice.reduce((sum, v) => sum + v.peers.size, 0);
+    return {
+      sessions: {
+        active: sessions.filter((s) => s.status === "started" || s.status === "joined").length,
+        ended: sessions.filter((s) => s.status === "ended").length,
+        participants: totalParticipants
+      },
+      voice: {
+        nodes: voice.length,
+        peers: totalPeers,
+        muted: voice.filter((v) => v.muted).length
+      },
+      messaging: {
+        connections: messaging.length,
+        connected: messaging.filter((m) => m.status === "connected").length,
+        errored: messaging.filter((m) => m.status === "errored").length
+      },
+      heartbeat: {
+        tracked: heartbeats.length,
+        alive: heartbeats.filter((h) => h.status === "alive").length,
+        failover: heartbeats.filter((h) => h.status === "failover").length,
+        errored: heartbeats.filter((h) => h.status === "errored").length
+      }
+    };
+  }
+  /** Clear all tracked state — typically called on world teardown / scene change. */
+  reset() {
+    this.sessions.clear();
+    this.voice.clear();
+    this.messaging.clear();
+    this.heartbeats.clear();
+  }
+  /** Number of distinct event types this coordinator subscribes to (diagnostic). */
+  get subscribedEventCount() {
+    return PRESENCE_EVENTS.length;
+  }
+};
+
+// src/coordinators/NeuralForgeCoordinator.ts
+var NEURAL_FORGE_EVENTS = [
+  "neural_forge_connected",
+  "neural_synthesis_request",
+  "neural_synthesis_timeout",
+  "neural_shard_created",
+  "neural_cognition_evolved"
+];
+var NeuralForgeCoordinator = class {
+  constructor(source) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    /** Tracks which nodes have fired neural_forge_connected. */
+    this.connectedNodes = /* @__PURE__ */ new Set();
+    for (const event of NEURAL_FORGE_EVENTS) {
+      source.on(event, (payload) => this.handleEvent(event, payload));
+    }
+  }
+  // ---- Event ingestion ---------------------------------------------------
+  handleEvent(event, payload) {
+    if (!payload || typeof payload !== "object") return;
+    const p = payload;
+    const nodeObj = p.node;
+    const nodeId = nodeObj?.id ?? p.nodeId ?? p.sourceId;
+    if (!nodeId || typeof nodeId !== "string") return;
+    const observedAt = Date.now();
+    switch (event) {
+      case "neural_forge_connected": {
+        this.connectedNodes.add(nodeId);
+        const existing = this.nodes.get(nodeId);
+        const next = {
+          nodeId,
+          status: existing?.status ?? "connected",
+          shardCount: existing?.shardCount ?? 0,
+          weights: existing?.weights ?? {},
+          lastSynthesisAt: existing?.lastSynthesisAt ?? null,
+          pendingExternalSynthesis: existing?.pendingExternalSynthesis ?? false,
+          pendingSince: existing?.pendingSince ?? null,
+          experienceLogLength: existing?.experienceLogLength ?? 0,
+          updatedAt: observedAt
+        };
+        this.nodes.set(nodeId, next);
+        this.notifyListeners(next);
+        break;
+      }
+      case "neural_synthesis_request": {
+        const mode = p.mode;
+        const experiences = p.experiences;
+        const weights = p.currentWeights;
+        const existing = this.nodes.get(nodeId);
+        const next = {
+          nodeId,
+          status: mode === "external" ? "synthesizing" : existing?.status ?? "idle",
+          shardCount: existing?.shardCount ?? 0,
+          weights: weights ?? existing?.weights ?? {},
+          lastSynthesisAt: existing?.lastSynthesisAt ?? null,
+          pendingExternalSynthesis: mode === "external",
+          pendingSince: mode === "external" ? observedAt : null,
+          experienceLogLength: Array.isArray(experiences) ? experiences.length : existing?.experienceLogLength ?? 0,
+          updatedAt: observedAt
+        };
+        this.nodes.set(nodeId, next);
+        this.notifyListeners(next);
+        break;
+      }
+      case "neural_synthesis_timeout": {
+        const experienceCount = p.experienceCount;
+        const existing = this.nodes.get(nodeId);
+        const next = {
+          nodeId,
+          status: "timeout_fallback",
+          shardCount: existing?.shardCount ?? 0,
+          weights: existing?.weights ?? {},
+          lastSynthesisAt: existing?.lastSynthesisAt ?? null,
+          pendingExternalSynthesis: false,
+          pendingSince: null,
+          experienceLogLength: experienceCount ?? (existing?.experienceLogLength ?? 0),
+          updatedAt: observedAt
+        };
+        this.nodes.set(nodeId, next);
+        this.notifyListeners(next);
+        break;
+      }
+      case "neural_shard_created": {
+        p.shard;
+        const existing = this.nodes.get(nodeId);
+        const next = {
+          nodeId,
+          status: existing?.pendingExternalSynthesis ? "synthesizing" : existing?.status ?? "idle",
+          shardCount: (existing?.shardCount ?? 0) + 1,
+          weights: existing?.weights ?? {},
+          lastSynthesisAt: observedAt,
+          pendingExternalSynthesis: existing?.pendingExternalSynthesis ?? false,
+          pendingSince: existing?.pendingSince ?? null,
+          experienceLogLength: existing?.experienceLogLength ?? 0,
+          updatedAt: observedAt
+        };
+        this.nodes.set(nodeId, next);
+        this.notifyListeners(next);
+        break;
+      }
+      case "neural_cognition_evolved": {
+        const weights = p.currentWeights;
+        const existing = this.nodes.get(nodeId);
+        if (!existing) {
+          const next = {
+            nodeId,
+            status: "idle",
+            shardCount: 0,
+            weights: weights ?? {},
+            lastSynthesisAt: null,
+            pendingExternalSynthesis: false,
+            pendingSince: null,
+            experienceLogLength: 0,
+            updatedAt: observedAt
+          };
+          this.nodes.set(nodeId, next);
+          this.notifyListeners(next);
+        } else {
+          existing.weights = weights ?? existing.weights;
+          existing.updatedAt = observedAt;
+          this.notifyListeners(existing);
+        }
+        break;
+      }
+    }
+  }
+  notifyListeners(state) {
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch (_) {
+      }
+    }
+  }
+  // ---- Public API --------------------------------------------------------
+  /** Subscribe to all neural-node state changes. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Get the state of a specific node (undefined if never seen). */
+  getNodeState(nodeId) {
+    return this.nodes.get(nodeId);
+  }
+  /** Get all tracked node states (snapshot — safe to iterate). */
+  getAllStates() {
+    return Array.from(this.nodes.values());
+  }
+  /** Whether a specific node has fired neural_forge_connected. */
+  isConnected(nodeId) {
+    return this.connectedNodes.has(nodeId);
+  }
+  /** Aggregate stats across all tracked nodes. */
+  getStats() {
+    const all = Array.from(this.nodes.values());
+    return {
+      total: all.length,
+      synthesizing: all.filter((s) => s.status === "synthesizing").length,
+      timeoutFallback: all.filter((s) => s.status === "timeout_fallback").length,
+      totalShards: all.reduce((sum, s) => sum + s.shardCount, 0),
+      anyConnected: this.connectedNodes.size > 0
+    };
+  }
+  /** Clear all tracked state — typically called on scene change. */
+  reset() {
+    this.nodes.clear();
+    this.connectedNodes.clear();
+  }
+  /** Number of distinct event types this coordinator subscribes to (diagnostic). */
+  get subscribedEventCount() {
+    return NEURAL_FORGE_EVENTS.length;
+  }
+};
+
+// src/coordinators/ObjectTrackingCoordinator.ts
+var OBJECT_TRACKING_EVENTS = [
+  "tracking:init",
+  "tracking:updated",
+  "tracking:lost",
+  "tracking:recovery_attempt",
+  "tracking:anchor_removed"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readVector3(value) {
+  if (!Array.isArray(value) || value.length !== 3 || !value.every((n) => Number.isFinite(n))) {
+    return void 0;
+  }
+  return [...value];
+}
+function clampConfidence(value, fallback) {
+  const confidence = readNumber(value);
+  if (confidence === void 0) return fallback;
+  return Math.max(0, Math.min(1, confidence));
+}
+var ObjectTrackingCoordinator = class {
+  constructor(source) {
+    this.targets = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    for (const event of OBJECT_TRACKING_EVENTS) {
+      source.on(event, (payload) => this.handleEvent(event, payload));
+    }
+  }
+  handleEvent(event, payload) {
+    if (!isRecord(payload)) return;
+    const key = this.resolveKey(payload);
+    if (!key) return;
+    const observedAt = Date.now();
+    const existing = this.targets.get(key);
+    const next = existing ? { ...existing, updatedAt: observedAt } : {
+      nodeId: key,
+      anchorId: null,
+      status: "initialized",
+      position: null,
+      rotation: null,
+      confidence: 0,
+      recoveryAttempts: 0,
+      timestampMs: null,
+      updatedAt: observedAt
+    };
+    next.target = readString(payload.target) ?? next.target;
+    next.anchorId = readString(payload.anchorId) ?? next.anchorId;
+    if (event === "tracking:init") {
+      next.status = "initialized";
+    } else if (event === "tracking:updated") {
+      next.status = "tracking";
+      next.position = readVector3(payload.position) ?? next.position;
+      next.rotation = readVector3(payload.rotation) ?? next.rotation;
+      next.confidence = clampConfidence(payload.confidence, next.confidence);
+      next.source = readString(payload.source) ?? next.source;
+      next.timestampMs = readNumber(payload.timestampMs) ?? next.timestampMs;
+    } else if (event === "tracking:lost") {
+      next.status = "lost";
+      next.confidence = 0;
+    } else if (event === "tracking:recovery_attempt") {
+      next.status = "recovering";
+      next.recoveryAttempts = readNumber(payload.attempt) ?? next.recoveryAttempts + 1;
+    } else if (event === "tracking:anchor_removed") {
+      next.status = "removed";
+    }
+    this.targets.set(key, next);
+    this.notifyListeners(next);
+  }
+  resolveKey(payload) {
+    const nodeId = readString(payload.nodeId);
+    if (nodeId) return nodeId;
+    const anchorId = readString(payload.anchorId);
+    if (anchorId) return `anchor:${anchorId}`;
+    const target = readString(payload.target);
+    return target ? `target:${target}` : void 0;
+  }
+  notifyListeners(state) {
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch {
+      }
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  getTrackingState(nodeId) {
+    return this.targets.get(nodeId);
+  }
+  getAllStates() {
+    return Array.from(this.targets.values());
+  }
+  getStats() {
+    const states = this.getAllStates();
+    return {
+      total: states.length,
+      tracking: states.filter((s) => s.status === "tracking").length,
+      lost: states.filter((s) => s.status === "lost").length,
+      recovering: states.filter((s) => s.status === "recovering").length,
+      removed: states.filter((s) => s.status === "removed").length
+    };
+  }
+  reset() {
+    this.targets.clear();
+  }
+  get subscribedEventCount() {
+    return OBJECT_TRACKING_EVENTS.length;
+  }
+};
+
+export { AssetLoadCoordinator, GenerativeJobMonitor, NeuralForgeCoordinator, ObjectTrackingCoordinator, SecurityEventBus, SessionPresenceCoordinator };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map