@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-6CTRH7HT.cjs

@@ -0,0 +1,1985 @@
+'use strict';
+
+var chunkGTU2Z2WW_cjs = require('./chunk-GTU2Z2WW.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/hololand/index.ts
+var hololand_exports = {};
+chunkHCCQLAA4_cjs.__export(hololand_exports, {
+  CrossValidationRegistry: () => CrossValidationRegistry,
+  DEFAULT_ENVELOPES: () => DEFAULT_ENVELOPES,
+  DEFAULT_ITEM_AUTONOMOUS_AGENDA: () => DEFAULT_ITEM_AUTONOMOUS_AGENDA,
+  DEFAULT_ITEM_REPUTATION_LEDGER: () => DEFAULT_ITEM_REPUTATION_LEDGER,
+  DEFAULT_ITEM_VERBAL_FINGERPRINT: () => DEFAULT_ITEM_VERBAL_FINGERPRINT,
+  DEFAULT_ITEM_VOCABULARY_REGISTER: () => DEFAULT_ITEM_VOCABULARY_REGISTER,
+  HEARTBEAT_INTERVAL: () => HEARTBEAT_INTERVAL,
+  HololandClient: () => HololandClient,
+  ITEM_DEFAULT_TICK_INTERVAL_MS: () => ITEM_DEFAULT_TICK_INTERVAL_MS,
+  MAX_CHUNK_SIZE: () => MAX_CHUNK_SIZE,
+  MAX_MESSAGE_SIZE: () => MAX_MESSAGE_SIZE,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  PhysicsBoundsRegistry: () => PhysicsBoundsRegistry,
+  StreamProtocol: () => StreamProtocol,
+  TIMEOUT_INTERVAL: () => TIMEOUT_INTERVAL,
+  computeConsensus: () => computeConsensus,
+  connectToHololand: () => connectToHololand,
+  createHoloLandItem: () => createHoloLandItem,
+  createStreamMessage: () => createMessage,
+  createWorldConfig: () => createWorldConfig,
+  createWorldDefinition: () => createWorldDefinition,
+  createWorldEnvironment: () => createWorldEnvironment,
+  createWorldMetadata: () => createWorldMetadata,
+  disconnectFromHololand: () => disconnectFromHololand,
+  getCrossValidationRegistry: () => getCrossValidationRegistry,
+  getHololandClient: () => getHololandClient,
+  getItemChain: () => getItemChain,
+  getPhysicsBoundsRegistry: () => getPhysicsBoundsRegistry,
+  getStreamProtocol: () => getStreamProtocol,
+  linkItems: () => linkItems,
+  resetCrossValidationRegistry: () => resetCrossValidationRegistry,
+  resetPhysicsBoundsRegistry: () => resetPhysicsBoundsRegistry,
+  suggestedQuorum: () => suggestedQuorum,
+  wrapPhysicsService: () => wrapPhysicsService
+});
+
+// src/hololand/WorldDefinitionSchema.ts
+function createWorldMetadata(id, name, options = {}) {
+  return {
+    id,
+    name,
+    displayName: options.displayName ?? name,
+    description: options.description,
+    version: options.version ?? "1.0.0",
+    author: options.author,
+    license: options.license,
+    tags: options.tags ?? [],
+    thumbnailUrl: options.thumbnailUrl,
+    previewImages: options.previewImages ?? [],
+    platforms: options.platforms ?? ["web"],
+    ageRating: options.ageRating ?? "everyone",
+    category: options.category ?? "experience",
+    createdAt: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    modifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: options.status ?? "draft",
+    metadata: options.metadata ?? {}
+  };
+}
+function createWorldConfig(options = {}) {
+  return {
+    maxUsers: options.maxUsers ?? 50,
+    bounds: options.bounds ?? {
+      minX: -1e3,
+      maxX: 1e3,
+      minY: -100,
+      maxY: 500,
+      minZ: -1e3,
+      maxZ: 1e3,
+      wrap: false,
+      outOfBoundsAction: "teleport"
+    },
+    physics: options.physics ?? {
+      engine: "rapier",
+      gravity: [0, -9.81, 0],
+      fixedTimestep: 1 / 60,
+      maxSubsteps: 4,
+      collisionDetection: "continuous",
+      sleepThreshold: 0.01
+    },
+    rendering: options.rendering ?? {
+      targetFPS: 72,
+      shadows: true,
+      shadowQuality: "medium",
+      antiAliasing: "fxaa",
+      msaaSamples: 4,
+      bloom: true,
+      ambientOcclusion: true,
+      aoQuality: "medium",
+      toneMapping: "aces",
+      exposure: 1,
+      fog: false
+    },
+    audio: options.audio ?? {
+      masterVolume: 1,
+      spatialAudio: true,
+      hrtfProfile: "default",
+      reverbPreset: "room",
+      maxSources: 32,
+      distanceModel: "inverse",
+      rolloffFactor: 1
+    },
+    networking: options.networking ?? {
+      region: "auto",
+      tickRate: 20,
+      interpolationDelay: 100,
+      prediction: true,
+      protocol: "websocket",
+      compression: "lz4",
+      syncStrategy: "delta",
+      interestRadius: 100
+    },
+    performance: options.performance ?? {
+      maxDrawCalls: 1e3,
+      maxTriangles: 2e6,
+      maxTextureMemory: 512,
+      maxAudioSources: 32,
+      maxPhysicsBodies: 1e3,
+      maxNetworkedEntities: 500,
+      cpuBudgetMs: 11
+    },
+    accessibility: options.accessibility ?? {
+      subtitles: true,
+      audioDescriptions: false,
+      colorblindMode: "none",
+      reduceMotion: false,
+      highContrast: false,
+      screenReader: true,
+      hapticIntensity: 1
+    }
+  };
+}
+function createWorldEnvironment(options = {}) {
+  return {
+    skybox: options.skybox ?? {
+      type: "procedural",
+      procedural: {
+        turbidity: 10,
+        rayleigh: 2,
+        mieCoefficient: 5e-3,
+        mieDirectionalG: 0.8,
+        sunPosition: [0, 1, 0]
+      }
+    },
+    ambientLight: options.ambientLight ?? {
+      color: "#ffffff",
+      intensity: 0.4,
+      groundColor: "#444444"
+    },
+    directionalLights: options.directionalLights ?? [
+      {
+        id: "sun",
+        color: "#fffaf0",
+        intensity: 1,
+        direction: [-0.5, -1, -0.5],
+        castShadow: true,
+        shadowMapSize: 2048,
+        shadowBias: -1e-4
+      }
+    ],
+    environmentMap: options.environmentMap,
+    timeOfDay: options.timeOfDay,
+    weather: options.weather,
+    postProcessing: options.postProcessing ?? {
+      enabled: true,
+      effects: []
+    }
+  };
+}
+function createWorldDefinition(id, name, options = {}) {
+  return {
+    schemaVersion: "1.0.0",
+    metadata: createWorldMetadata(id, name),
+    config: createWorldConfig(),
+    environment: createWorldEnvironment(),
+    zones: options.zones ?? [],
+    spawnPoints: options.spawnPoints ?? [
+      {
+        id: "default-spawn",
+        name: "Default Spawn",
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        type: "default",
+        priority: 10,
+        capacity: 100,
+        tags: ["default"]
+      }
+    ],
+    assetManifest: options.assetManifest ?? "",
+    prefabs: options.prefabs ?? [],
+    sceneGraph: options.sceneGraph ?? {
+      id: "root",
+      name: "Root",
+      type: "group",
+      transform: {
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        scale: [1, 1, 1]
+      },
+      components: [],
+      children: [],
+      active: true,
+      tags: [],
+      layers: 1
+    },
+    scripts: options.scripts ?? [],
+    events: options.events ?? [],
+    lod: options.lod ?? {
+      enabled: true,
+      distances: [25, 50, 100, 200],
+      chunkSize: 64,
+      maxLoadedChunks: 9,
+      unloadDelay: 5
+    }
+  };
+}
+
+// src/hololand/HololandIntegration.ts
+var _HololandClient = class _HololandClient {
+  constructor(config) {
+    this.services = null;
+    this.world = null;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.config = {
+      serverUrl: config.serverUrl ?? "wss://api.hololand.io",
+      apiKey: config.apiKey,
+      debug: config.debug ?? false,
+      autoReconnect: config.autoReconnect ?? true,
+      reconnectDelay: config.reconnectDelay ?? 1e3,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      connectionTimeout: config.connectionTimeout ?? 3e4
+    };
+    this.connectionInfo = {
+      state: "disconnected",
+      serverUrl: this.config.serverUrl,
+      latency: 0,
+      bytesSent: 0,
+      bytesReceived: 0
+    };
+  }
+  static getInstance(config) {
+    if (!_HololandClient.instance) {
+      _HololandClient.instance = new _HololandClient(config ?? {});
+    }
+    return _HololandClient.instance;
+  }
+  static resetInstance() {
+    _HololandClient.instance?.disconnect();
+    _HololandClient.instance = null;
+  }
+  // ─── Connection Management ────────────────────────────────────────────────
+  /**
+   * Connect to Hololand server
+   */
+  async connect(worldId) {
+    if (this.connectionInfo.state === "connected") {
+      return;
+    }
+    this.setConnectionState("connecting");
+    try {
+      await this.simulateConnection();
+      if (worldId) {
+        await this.joinWorld(worldId);
+      }
+      this.setConnectionState("connected");
+      this.emit("connected", { sessionId: this.connectionInfo.sessionId });
+    } catch (error) {
+      this.connectionInfo.lastError = error.message;
+      this.setConnectionState("error");
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from server
+   */
+  disconnect() {
+    if (this.connectionInfo.state === "disconnected") {
+      return;
+    }
+    this.setConnectionState("disconnected");
+    this.services = null;
+    this.world = null;
+    this.emit("disconnected", {});
+  }
+  /**
+   * Get connection info
+   */
+  getConnectionInfo() {
+    return { ...this.connectionInfo };
+  }
+  // ─── World Management ─────────────────────────────────────────────────────
+  /**
+   * Join a world
+   */
+  async joinWorld(worldId) {
+    if (this.connectionInfo.state !== "connected") {
+      throw new Error("Not connected to server");
+    }
+    const world = await this.fetchWorldDefinition(worldId);
+    this.world = world;
+    this.emit("worldJoined", { worldId, world });
+    return world;
+  }
+  /**
+   * Leave current world
+   */
+  async leaveWorld() {
+    if (!this.world) return;
+    const worldId = this.world.metadata.id;
+    this.world = null;
+    this.emit("worldLeft", { worldId });
+  }
+  /**
+   * Get current world
+   */
+  getCurrentWorld() {
+    return this.world;
+  }
+  /**
+   * Register a world definition
+   */
+  async registerWorld(world) {
+    if (this.connectionInfo.state !== "connected") {
+      throw new Error("Not connected to server");
+    }
+    const worldId = world.metadata.id;
+    this.emit("worldRegistered", { worldId });
+    return worldId;
+  }
+  /**
+   * Update world definition
+   */
+  async updateWorld(worldId, updates) {
+    if (this.connectionInfo.state !== "connected") {
+      throw new Error("Not connected to server");
+    }
+    this.emit("worldUpdated", { worldId, updates });
+  }
+  // ─── Runtime Services ─────────────────────────────────────────────────────
+  /**
+   * Get runtime services
+   */
+  getServices() {
+    if (!this.services) {
+      this.services = this.createServices();
+    }
+    return this.services;
+  }
+  /**
+   * Create runtime services (stub implementations)
+   */
+  createServices() {
+    return {
+      assets: this.createAssetService(),
+      networking: this.createNetworkingService(),
+      audio: this.createAudioService(),
+      physics: this.createPhysicsService(),
+      input: this.createInputService(),
+      analytics: this.createAnalyticsService(),
+      voice: this.createVoiceService(),
+      storage: this.createStorageService()
+    };
+  }
+  // ─── Service Factory Methods ──────────────────────────────────────────────
+  createAssetService() {
+    return {
+      requestAsset: async (assetId, _priority) => {
+        this.log(`Requesting asset: ${assetId}`);
+        return null;
+      },
+      prefetch: async (assetIds) => {
+        this.log(`Prefetching ${assetIds.length} assets`);
+      },
+      cancelLoad: (assetId) => {
+        this.log(`Cancelling load: ${assetId}`);
+      },
+      getProgress: (_assetId) => 0,
+      clearCache: () => {
+        this.log("Clearing asset cache");
+      },
+      getCacheStats: () => ({ size: 0, maxSize: 256 * 1024 * 1024, hitRate: 0 })
+    };
+  }
+  createNetworkingService() {
+    const subscriptions = /* @__PURE__ */ new Map();
+    return {
+      send: (channel, data) => {
+        this.log(`Send to ${channel}:`, data);
+      },
+      subscribe: (channel, handler) => {
+        if (!subscriptions.has(channel)) {
+          subscriptions.set(channel, /* @__PURE__ */ new Set());
+        }
+        subscriptions.get(channel).add(handler);
+        return () => subscriptions.get(channel)?.delete(handler);
+      },
+      rpc: async (_method, _params) => {
+        return null;
+      },
+      getConnectionInfo: () => this.connectionInfo,
+      setPlayerData: (_key, _value) => {
+      },
+      getPlayerData: (_key) => null
+    };
+  }
+  createAudioService() {
+    let handleId = 0;
+    return {
+      play: (soundId, _options) => {
+        const id = `audio_${handleId++}`;
+        this.log(`Playing sound: ${soundId}`);
+        return {
+          id,
+          stop: () => {
+          },
+          setVolume: () => {
+          },
+          setPitch: () => {
+          },
+          isPlaying: () => false
+        };
+      },
+      stop: (_handle) => {
+      },
+      setListenerPosition: (_position) => {
+      },
+      setListenerOrientation: (_forward, _up) => {
+      },
+      setMasterVolume: (_volume) => {
+      },
+      createSource: (soundId, _position) => {
+        const id = `source_${handleId++}`;
+        this.log(`Creating audio source: ${soundId}`);
+        return {
+          id,
+          play: () => {
+          },
+          stop: () => {
+          },
+          setPosition: () => {
+          },
+          setVolume: () => {
+          },
+          destroy: () => {
+          }
+        };
+      }
+    };
+  }
+  createPhysicsService() {
+    let bodyId = 0;
+    return {
+      createBody: (config) => {
+        const id = `body_${bodyId++}`;
+        this.log(`Creating physics body: ${config.type}`);
+        return {
+          id,
+          setPosition: () => {
+          },
+          setRotation: () => {
+          },
+          setVelocity: () => {
+          },
+          applyForce: () => {
+          },
+          applyImpulse: () => {
+          },
+          getPosition: () => [config.position[0], config.position[1], config.position[2]],
+          getVelocity: () => [0, 0, 0],
+          destroy: () => {
+          }
+        };
+      },
+      raycast: (_origin, _direction, _maxDistance) => null,
+      overlap: (_shape, _position) => [],
+      setGravity: (_gravity) => {
+      },
+      step: (_deltaTime) => {
+      }
+    };
+  }
+  createInputService() {
+    const bindings = /* @__PURE__ */ new Map();
+    return {
+      getValue: (_action) => 0,
+      isPressed: (_action) => false,
+      isJustPressed: (_action) => false,
+      isJustReleased: (_action) => false,
+      getPointerPosition: () => ({ x: 0, y: 0 }),
+      getXRController: (_hand) => null,
+      bindAction: (action, binding) => {
+        bindings.set(action, binding);
+      },
+      setVibration: (_hand, _intensity, _duration) => {
+      }
+    };
+  }
+  createAnalyticsService() {
+    const timings = /* @__PURE__ */ new Map();
+    return {
+      track: (event, properties) => {
+        this.log(`Analytics: ${event}`, properties);
+      },
+      setUserProperty: (_key, _value) => {
+      },
+      startTiming: (label) => {
+        timings.set(label, performance.now());
+      },
+      endTiming: (label) => {
+        const start = timings.get(label);
+        if (!start) return 0;
+        const duration = performance.now() - start;
+        timings.delete(label);
+        return duration;
+      },
+      getMetrics: () => ({
+        fps: 60,
+        frameTime: 16.67,
+        drawCalls: 0,
+        triangles: 0,
+        textureMemory: 0,
+        geometryMemory: 0,
+        physicsTime: 0,
+        networkLatency: this.connectionInfo.latency
+      })
+    };
+  }
+  createVoiceService() {
+    return {
+      startVoiceChat: async () => {
+      },
+      stopVoiceChat: () => {
+      },
+      setMuted: (_muted) => {
+      },
+      setVolume: (_userId, _volume) => {
+      },
+      getSpeakingUsers: () => [],
+      speak: async (_text, _options) => {
+      },
+      startListening: async () => {
+      },
+      stopListening: async () => ""
+    };
+  }
+  createStorageService() {
+    const storage = /* @__PURE__ */ new Map();
+    return {
+      get: async (key) => storage.get(key) ?? null,
+      set: async (key, value) => {
+        storage.set(key, value);
+      },
+      delete: async (key) => {
+        storage.delete(key);
+      },
+      keys: async () => Array.from(storage.keys()),
+      clear: async () => {
+        storage.clear();
+      },
+      getQuota: async () => ({ used: 0, total: 50 * 1024 * 1024 })
+    };
+  }
+  // ─── Event System ─────────────────────────────────────────────────────────
+  /**
+   * Subscribe to events
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+    return () => this.eventHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * Emit event
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`Event handler error for ${event}:`, error);
+        }
+      }
+    }
+  }
+  // ─── Internal Helpers ─────────────────────────────────────────────────────
+  setConnectionState(state) {
+    this.connectionInfo.state = state;
+    this.emit("connectionStateChanged", { state });
+  }
+  async simulateConnection() {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    this.connectionInfo.sessionId = `session_${Date.now()}`;
+    this.connectionInfo.connectedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.connectionInfo.latency = 50;
+  }
+  async fetchWorldDefinition(worldId) {
+    const httpBaseUrl = this.config.serverUrl.replace(/^wss:\/\//, "https://").replace(/^ws:\/\//, "http://");
+    const url = `${httpBaseUrl}/api/worlds/${encodeURIComponent(worldId)}`;
+    const headers = {
+      Accept: "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.connectionTimeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch world "${worldId}": ${response.status} ${response.statusText}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[Hololand]", ...args);
+    }
+  }
+};
+_HololandClient.instance = null;
+var HololandClient = _HololandClient;
+function getHololandClient(config) {
+  return HololandClient.getInstance(config);
+}
+async function connectToHololand(config, worldId) {
+  const client = getHololandClient(config);
+  await client.connect(worldId);
+  return client;
+}
+function disconnectFromHololand() {
+  HololandClient.resetInstance();
+}
+
+// src/hololand/PhysicsBoundsRegistry.ts
+chunkGTU2Z2WW_cjs.init_AgentRiskRegistry();
+var DEFAULT_ENVELOPES = {
+  ["low" /* LOW */]: {
+    maxForceN: 1e3,
+    maxImpulseNs: 200,
+    maxVelocityMps: 50,
+    maxGravityMps2: 30,
+    allowSetGravity: true,
+    allowDynamicMutation: true
+  },
+  ["medium" /* MEDIUM */]: {
+    maxForceN: 500,
+    maxImpulseNs: 100,
+    maxVelocityMps: 20,
+    maxGravityMps2: 15,
+    allowSetGravity: true,
+    allowDynamicMutation: true
+  },
+  ["high" /* HIGH */]: {
+    maxForceN: 100,
+    maxImpulseNs: 25,
+    maxVelocityMps: 5,
+    maxGravityMps2: 10,
+    // High-risk agents can't reshape gravity — that's a global effect that
+    // would propagate confabulation risk to every body in the world.
+    allowSetGravity: false,
+    allowDynamicMutation: true
+  },
+  ["quarantined" /* QUARANTINED */]: {
+    maxForceN: 0,
+    maxImpulseNs: 0,
+    maxVelocityMps: 0,
+    maxGravityMps2: 0,
+    allowSetGravity: false,
+    allowDynamicMutation: false
+  }
+};
+var PhysicsBoundsRegistry = class {
+  constructor(config = {}) {
+    const overrides = config.envelopeOverrides ?? {};
+    const merged = {
+      ["low" /* LOW */]: { ...DEFAULT_ENVELOPES["low" /* LOW */] },
+      ["medium" /* MEDIUM */]: { ...DEFAULT_ENVELOPES["medium" /* MEDIUM */] },
+      ["high" /* HIGH */]: { ...DEFAULT_ENVELOPES["high" /* HIGH */] },
+      ["quarantined" /* QUARANTINED */]: { ...DEFAULT_ENVELOPES["quarantined" /* QUARANTINED */] }
+    };
+    for (const tier of Object.keys(overrides)) {
+      const partial = overrides[tier];
+      if (!partial) continue;
+      merged[tier] = { ...merged[tier], ...partial };
+    }
+    this.envelopes = merged;
+  }
+  /**
+   * Look up the envelope for a risk tier (read-only view).
+   */
+  getEnvelope(tier) {
+    return { ...this.envelopes[tier] };
+  }
+};
+var globalBoundsRegistry = null;
+function getPhysicsBoundsRegistry(config) {
+  if (!globalBoundsRegistry) {
+    globalBoundsRegistry = new PhysicsBoundsRegistry(config);
+  }
+  return globalBoundsRegistry;
+}
+function resetPhysicsBoundsRegistry() {
+  globalBoundsRegistry = null;
+}
+function wrapPhysicsService(service, agentId, options = {}) {
+  const riskRegistry = options.riskRegistry ?? chunkGTU2Z2WW_cjs.getAgentRiskRegistry();
+  const boundsRegistry = options.boundsRegistry ?? getPhysicsBoundsRegistry();
+  const onViolation = options.onViolation;
+  function currentEnvelope() {
+    const tier = riskRegistry.getTier(agentId);
+    return { tier, env: boundsRegistry.getEnvelope(tier) };
+  }
+  function emit(v) {
+    if (onViolation) {
+      try {
+        onViolation(v);
+      } catch {
+      }
+    }
+  }
+  function wrapBody(body) {
+    return {
+      get id() {
+        return body.id;
+      },
+      setPosition(position) {
+        const { tier, env } = currentEnvelope();
+        if (!env.allowDynamicMutation) {
+          emit({
+            agentId,
+            tier,
+            kind: "rejected",
+            operation: "setPosition",
+            requestedMagnitude: vectorMagnitude(position),
+            allowedMagnitude: 0,
+            bodyId: body.id
+          });
+          return;
+        }
+        body.setPosition(position);
+      },
+      setRotation(rotation) {
+        const { tier, env } = currentEnvelope();
+        if (!env.allowDynamicMutation) {
+          emit({
+            agentId,
+            tier,
+            kind: "rejected",
+            operation: "setRotation",
+            requestedMagnitude: 0,
+            allowedMagnitude: 0,
+            bodyId: body.id
+          });
+          return;
+        }
+        body.setRotation(rotation);
+      },
+      setVelocity(velocity) {
+        const { tier, env } = currentEnvelope();
+        if (!env.allowDynamicMutation) {
+          emit({
+            agentId,
+            tier,
+            kind: "rejected",
+            operation: "setVelocity",
+            requestedMagnitude: vectorMagnitude(velocity),
+            allowedMagnitude: 0,
+            bodyId: body.id
+          });
+          return;
+        }
+        const { value, clamped, requested } = clampVector(velocity, env.maxVelocityMps);
+        if (clamped) {
+          emit({
+            agentId,
+            tier,
+            kind: "clamped",
+            operation: "setVelocity",
+            requestedMagnitude: requested,
+            allowedMagnitude: env.maxVelocityMps,
+            bodyId: body.id
+          });
+        }
+        body.setVelocity(value);
+      },
+      applyForce(force) {
+        const { tier, env } = currentEnvelope();
+        if (!env.allowDynamicMutation) {
+          emit({
+            agentId,
+            tier,
+            kind: "rejected",
+            operation: "applyForce",
+            requestedMagnitude: vectorMagnitude(force),
+            allowedMagnitude: 0,
+            bodyId: body.id
+          });
+          return;
+        }
+        const { value, clamped, requested } = clampVector(force, env.maxForceN);
+        if (clamped) {
+          emit({
+            agentId,
+            tier,
+            kind: "clamped",
+            operation: "applyForce",
+            requestedMagnitude: requested,
+            allowedMagnitude: env.maxForceN,
+            bodyId: body.id
+          });
+        }
+        body.applyForce(value);
+      },
+      applyImpulse(impulse) {
+        const { tier, env } = currentEnvelope();
+        if (!env.allowDynamicMutation) {
+          emit({
+            agentId,
+            tier,
+            kind: "rejected",
+            operation: "applyImpulse",
+            requestedMagnitude: vectorMagnitude(impulse),
+            allowedMagnitude: 0,
+            bodyId: body.id
+          });
+          return;
+        }
+        const { value, clamped, requested } = clampVector(impulse, env.maxImpulseNs);
+        if (clamped) {
+          emit({
+            agentId,
+            tier,
+            kind: "clamped",
+            operation: "applyImpulse",
+            requestedMagnitude: requested,
+            allowedMagnitude: env.maxImpulseNs,
+            bodyId: body.id
+          });
+        }
+        body.applyImpulse(value);
+      },
+      // Reads pass through unchanged — confabulation doesn't propagate via
+      // queries.
+      getPosition() {
+        return body.getPosition();
+      },
+      getVelocity() {
+        return body.getVelocity();
+      },
+      destroy() {
+        body.destroy();
+      }
+    };
+  }
+  return {
+    createBody(config) {
+      const body = service.createBody(config);
+      return wrapBody(body);
+    },
+    raycast(origin, direction, maxDistance) {
+      const result = service.raycast(origin, direction, maxDistance);
+      if (!result) return null;
+      return { ...result, body: wrapBody(result.body) };
+    },
+    overlap(shape, position) {
+      return service.overlap(shape, position).map(wrapBody);
+    },
+    setGravity(gravity) {
+      const { tier, env } = currentEnvelope();
+      const requested = vectorMagnitude(gravity);
+      if (!env.allowSetGravity) {
+        emit({
+          agentId,
+          tier,
+          kind: "rejected",
+          operation: "setGravity",
+          requestedMagnitude: requested,
+          allowedMagnitude: 0,
+          bodyId: null
+        });
+        return;
+      }
+      const { value, clamped } = clampVector(gravity, env.maxGravityMps2);
+      if (clamped) {
+        emit({
+          agentId,
+          tier,
+          kind: "clamped",
+          operation: "setGravity",
+          requestedMagnitude: requested,
+          allowedMagnitude: env.maxGravityMps2,
+          bodyId: null
+        });
+      }
+      service.setGravity(value);
+    },
+    step(deltaTime) {
+      service.step(deltaTime);
+    }
+  };
+}
+function vectorMagnitude(v) {
+  return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+}
+function clampVector(v, maxMagnitude) {
+  const requested = vectorMagnitude(v);
+  if (maxMagnitude <= 0) {
+    return { value: [0, 0, 0], clamped: requested > 0, requested };
+  }
+  if (requested <= maxMagnitude) {
+    return { value: [v[0], v[1], v[2]], clamped: false, requested };
+  }
+  const scale = maxMagnitude / requested;
+  return {
+    value: [v[0] * scale, v[1] * scale, v[2] * scale],
+    clamped: true,
+    requested
+  };
+}
+
+// src/hololand/CrossValidationRegistry.ts
+chunkGTU2Z2WW_cjs.init_AgentRiskRegistry();
+var DEFAULT_MIN_OBSERVERS = 3;
+var DEFAULT_NUMERIC_TOLERANCE = 1;
+var DEFAULT_AGREEMENT_SEVERITY = 15;
+var DEFAULT_MAX_ROUNDS = 1024;
+var CrossValidationRegistry = class {
+  constructor(config = {}) {
+    /** eventId -> round state. Insertion order = age order (Map preserves it). */
+    this.rounds = /* @__PURE__ */ new Map();
+    /**
+     * Per-round set of agentIds we have ALREADY emitted feedback for, so a
+     * late submission after `resolved=true` doesn't double-count.
+     */
+    this.emittedFor = /* @__PURE__ */ new Map();
+    this.defaultMinObservers = config.defaultMinObservers ?? DEFAULT_MIN_OBSERVERS;
+    this.tolerance = {
+      defaultNumericTolerance: config.tolerance?.defaultNumericTolerance ?? DEFAULT_NUMERIC_TOLERANCE,
+      perField: config.tolerance?.perField
+    };
+    this.agreementSeverityThreshold = config.agreementSeverityThreshold ?? DEFAULT_AGREEMENT_SEVERITY;
+    this.riskRegistry = config.riskRegistry ?? chunkGTU2Z2WW_cjs.getAgentRiskRegistry();
+    this.maxRounds = config.maxRounds ?? DEFAULT_MAX_ROUNDS;
+    this.now = config.now ?? (() => Date.now());
+    if (this.defaultMinObservers < 2) {
+      throw new Error(
+        "CrossValidationRegistry: defaultMinObservers must be >= 2 (consensus requires at least two observers)"
+      );
+    }
+    if (this.agreementSeverityThreshold < 0 || this.agreementSeverityThreshold > 100) {
+      throw new Error(
+        "CrossValidationRegistry: agreementSeverityThreshold must be in [0,100]"
+      );
+    }
+    if (this.tolerance.defaultNumericTolerance <= 0) {
+      throw new Error(
+        "CrossValidationRegistry: defaultNumericTolerance must be > 0"
+      );
+    }
+    if (this.maxRounds < 1) {
+      throw new Error("CrossValidationRegistry: maxRounds must be >= 1");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // ROUND LIFECYCLE
+  // ---------------------------------------------------------------------------
+  /**
+   * Open a new validation round for a world-state event.
+   *
+   * Idempotent: if a round with `eventId` already exists, this is a no-op
+   * (returns the existing snapshot). This matters for CRDT correctness: two
+   * peers may both call `openRound` on the same event before any
+   * observations arrive.
+   */
+  openRound(eventId, minObservers) {
+    const existing = this.rounds.get(eventId);
+    if (existing) return existing;
+    const round = {
+      eventId,
+      openedAt: this.now(),
+      minObservers: minObservers ?? this.defaultMinObservers,
+      observations: {},
+      resolved: false
+    };
+    this.rounds.set(eventId, round);
+    this.evictIfNeeded();
+    return round;
+  }
+  /**
+   * Submit an observation. Implicitly opens the round if it doesn't exist.
+   *
+   * Returns a `SubmissionResult` describing whether quorum was reached
+   * (and therefore whether risk feedback was emitted).
+   */
+  submitObservation(observation) {
+    const submittedAt = observation.submittedAt ?? this.now();
+    const round = this.openRound(observation.eventId);
+    const existing = round.observations[observation.agentId];
+    if (existing && existing.submittedAt > submittedAt) {
+      return {
+        resolved: round.resolved,
+        observerCount: Object.keys(round.observations).length,
+        consensus: null,
+        emittedRiskEvents: []
+      };
+    }
+    const merged = {
+      eventId: observation.eventId,
+      agentId: observation.agentId,
+      claim: observation.claim,
+      submittedAt
+    };
+    const next = {
+      ...round,
+      observations: { ...round.observations, [observation.agentId]: merged }
+    };
+    this.rounds.set(observation.eventId, next);
+    return this.maybeResolve(observation.eventId);
+  }
+  /**
+   * Merge a remote round snapshot into the local registry.
+   *
+   * CRDT semantics:
+   *   - Per-agent observations merge by LWW on `submittedAt`.
+   *   - The local `resolved` flag is sticky once true (don't un-resolve a
+   *     round just because a peer hadn't seen the resolution yet).
+   *   - `minObservers` and `openedAt` from the EARLIEST `openedAt` win
+   *     (deterministic across peers).
+   *   - After merging, attempts to resolve in case the merged observations
+   *     just crossed quorum.
+   */
+  mergeRound(remote) {
+    const local = this.rounds.get(remote.eventId);
+    const mergedObservations = {};
+    const allAgents = /* @__PURE__ */ new Set([
+      ...Object.keys(local?.observations ?? {}),
+      ...Object.keys(remote.observations)
+    ]);
+    for (const agentId of allAgents) {
+      const l = local?.observations[agentId];
+      const r = remote.observations[agentId];
+      if (l && r) {
+        mergedObservations[agentId] = l.submittedAt >= r.submittedAt ? l : r;
+      } else {
+        mergedObservations[agentId] = l ?? r;
+      }
+    }
+    const openedAt = local ? Math.min(local.openedAt, remote.openedAt) : remote.openedAt;
+    const minObservers = local ? Math.min(local.minObservers, remote.minObservers) : remote.minObservers;
+    const resolved = (local?.resolved ?? false) || remote.resolved;
+    const merged = {
+      eventId: remote.eventId,
+      openedAt,
+      minObservers,
+      observations: mergedObservations,
+      resolved
+    };
+    this.rounds.set(remote.eventId, merged);
+    this.evictIfNeeded();
+    return this.maybeResolve(remote.eventId);
+  }
+  /**
+   * Force-resolve a round even if the quorum hasn't been met. Used by
+   * orchestrators that want to close a round on a deadline. The consensus
+   * is computed over whatever observations are present (>=1 required).
+   */
+  forceResolve(eventId) {
+    const round = this.rounds.get(eventId);
+    if (!round) return null;
+    if (Object.keys(round.observations).length === 0) return null;
+    const result = this.resolveNow(eventId);
+    return result.consensus;
+  }
+  /**
+   * Read-only snapshot of a round (for diagnostics, exports, CRDT sync).
+   */
+  exportRound(eventId) {
+    const r = this.rounds.get(eventId);
+    if (!r) return null;
+    return {
+      eventId: r.eventId,
+      openedAt: r.openedAt,
+      minObservers: r.minObservers,
+      observations: { ...r.observations },
+      resolved: r.resolved
+    };
+  }
+  /**
+   * List active rounds (for diagnostics).
+   */
+  listRounds() {
+    return Array.from(this.rounds.keys());
+  }
+  /**
+   * Compute a consensus result without mutating the round or emitting
+   * feedback. Useful for dashboards and tests.
+   *
+   * Returns null if the round doesn't exist or has no observations.
+   */
+  previewConsensus(eventId) {
+    const round = this.rounds.get(eventId);
+    if (!round) return null;
+    const observations = Object.values(round.observations);
+    if (observations.length === 0) return null;
+    return computeConsensus(eventId, observations, this.tolerance);
+  }
+  /**
+   * Drop a round from memory. Idempotent.
+   */
+  clearRound(eventId) {
+    this.rounds.delete(eventId);
+    this.emittedFor.delete(eventId);
+  }
+  /**
+   * Drop all state (tests).
+   */
+  clearAll() {
+    this.rounds.clear();
+    this.emittedFor.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // INTERNAL — RESOLUTION + FEEDBACK
+  // ---------------------------------------------------------------------------
+  maybeResolve(eventId) {
+    const round = this.rounds.get(eventId);
+    const observerCount = Object.keys(round.observations).length;
+    if (round.resolved) {
+      const events = this.emitForLateAgents(eventId);
+      return {
+        resolved: true,
+        observerCount,
+        consensus: null,
+        emittedRiskEvents: events
+      };
+    }
+    if (observerCount < round.minObservers) {
+      return {
+        resolved: false,
+        observerCount,
+        consensus: null,
+        emittedRiskEvents: []
+      };
+    }
+    return this.resolveNow(eventId);
+  }
+  resolveNow(eventId) {
+    const round = this.rounds.get(eventId);
+    const observations = Object.values(round.observations);
+    const consensus = computeConsensus(eventId, observations, this.tolerance);
+    const emitted = [];
+    const emittedSet = this.getEmittedSet(eventId);
+    for (const div of consensus.divergence) {
+      if (emittedSet.has(div.agentId)) continue;
+      emittedSet.add(div.agentId);
+      const ev = this.emitForObserver(eventId, div.agentId, div.severity);
+      if (ev) emitted.push(ev);
+    }
+    const resolvedRound = { ...round, resolved: true };
+    this.rounds.set(eventId, resolvedRound);
+    return {
+      resolved: true,
+      observerCount: observations.length,
+      consensus,
+      emittedRiskEvents: emitted
+    };
+  }
+  emitForLateAgents(eventId) {
+    const round = this.rounds.get(eventId);
+    const observations = Object.values(round.observations);
+    const consensus = computeConsensus(eventId, observations, this.tolerance);
+    const emitted = [];
+    const emittedSet = this.getEmittedSet(eventId);
+    for (const div of consensus.divergence) {
+      if (emittedSet.has(div.agentId)) continue;
+      emittedSet.add(div.agentId);
+      const ev = this.emitForObserver(eventId, div.agentId, div.severity);
+      if (ev) emitted.push(ev);
+    }
+    return emitted;
+  }
+  emitForObserver(eventId, agentId, severity) {
+    if (severity < this.agreementSeverityThreshold) {
+      this.riskRegistry.recordSuccess(agentId);
+      return null;
+    }
+    const event = {
+      agentId,
+      severity: Math.round(severity),
+      reason: `cross-validation-divergence:${eventId}`,
+      timestamp: this.now()
+    };
+    this.riskRegistry.recordEvent(event);
+    return event;
+  }
+  getEmittedSet(eventId) {
+    let set = this.emittedFor.get(eventId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.emittedFor.set(eventId, set);
+    }
+    return set;
+  }
+  evictIfNeeded() {
+    while (this.rounds.size > this.maxRounds) {
+      const oldest = this.rounds.keys().next().value;
+      if (!oldest) break;
+      this.rounds.delete(oldest);
+      this.emittedFor.delete(oldest);
+    }
+  }
+};
+function computeConsensus(eventId, observations, tolerance) {
+  if (observations.length === 0) {
+    return {
+      eventId,
+      observerCount: 0,
+      consensus: {},
+      divergence: []
+    };
+  }
+  const sorted = [...observations].sort(
+    (a, b) => a.agentId < b.agentId ? -1 : a.agentId > b.agentId ? 1 : 0
+  );
+  const numericFields = /* @__PURE__ */ new Set();
+  const enumFields = /* @__PURE__ */ new Set();
+  for (const obs of sorted) {
+    if (obs.claim.numeric) {
+      for (const f of Object.keys(obs.claim.numeric)) numericFields.add(f);
+    }
+    if (obs.claim.enum) {
+      for (const f of Object.keys(obs.claim.enum)) enumFields.add(f);
+    }
+  }
+  const consensusNumeric = {};
+  for (const field of numericFields) {
+    const samples = [];
+    let dim = 0;
+    for (const obs of sorted) {
+      const v = obs.claim.numeric?.[field];
+      if (!v) continue;
+      samples.push([...v]);
+      dim = Math.max(dim, v.length);
+    }
+    if (samples.length === 0 || dim === 0) continue;
+    const median = [];
+    for (let i = 0; i < dim; i++) {
+      const col = [];
+      for (const s of samples) {
+        if (i < s.length) col.push(s[i]);
+      }
+      median.push(medianOf(col));
+    }
+    consensusNumeric[field] = median;
+  }
+  const consensusEnum = {};
+  for (const field of enumFields) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const obs of sorted) {
+      const v = obs.claim.enum?.[field];
+      if (v === void 0) continue;
+      counts.set(v, (counts.get(v) ?? 0) + 1);
+    }
+    if (counts.size === 0) continue;
+    const sortedByCount = Array.from(counts.entries()).sort((a, b) => {
+      if (b[1] !== a[1]) return b[1] - a[1];
+      return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+    });
+    consensusEnum[field] = sortedByCount[0][0];
+  }
+  const divergence = sorted.map((obs) => {
+    const breakdown = [];
+    let maxSeverity = 0;
+    if (obs.claim.numeric) {
+      for (const [field, v] of Object.entries(obs.claim.numeric)) {
+        const cons = consensusNumeric[field];
+        if (!cons) continue;
+        const tol = tolerance.perField?.[field] ?? tolerance.defaultNumericTolerance;
+        let lInf = 0;
+        const dim = Math.min(v.length, cons.length);
+        for (let i = 0; i < dim; i++) {
+          const d = Math.abs(v[i] - cons[i]);
+          if (d > lInf) lInf = d;
+        }
+        const sev = numericSeverity(lInf, tol);
+        breakdown.push({ field, kind: "numeric", delta: lInf, severity: sev });
+        if (sev > maxSeverity) maxSeverity = sev;
+      }
+    }
+    if (obs.claim.enum) {
+      for (const [field, v] of Object.entries(obs.claim.enum)) {
+        const cons = consensusEnum[field];
+        if (cons === void 0) continue;
+        const matches = v === cons;
+        const sev = matches ? 0 : 100;
+        breakdown.push({
+          field,
+          kind: "enum",
+          delta: matches ? 0 : 1,
+          severity: sev
+        });
+        if (sev > maxSeverity) maxSeverity = sev;
+      }
+    }
+    return {
+      agentId: obs.agentId,
+      severity: maxSeverity,
+      breakdown
+    };
+  });
+  const consensusClaim = {};
+  if (Object.keys(consensusNumeric).length > 0) {
+    consensusClaim.numeric = consensusNumeric;
+  }
+  if (Object.keys(consensusEnum).length > 0) {
+    consensusClaim.enum = consensusEnum;
+  }
+  return {
+    eventId,
+    observerCount: sorted.length,
+    consensus: consensusClaim,
+    divergence
+  };
+}
+function numericSeverity(delta, tol) {
+  if (delta <= tol) return 0;
+  if (delta >= 2 * tol) return 100;
+  return (delta - tol) / tol * 100;
+}
+function medianOf(xs) {
+  if (xs.length === 0) return 0;
+  const sorted = [...xs].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1) return sorted[mid];
+  return (sorted[mid - 1] + sorted[mid]) / 2;
+}
+var globalCrossValidationRegistry = null;
+function getCrossValidationRegistry(config) {
+  if (!globalCrossValidationRegistry) {
+    globalCrossValidationRegistry = new CrossValidationRegistry(config);
+  }
+  return globalCrossValidationRegistry;
+}
+function resetCrossValidationRegistry() {
+  globalCrossValidationRegistry = null;
+}
+function suggestedQuorum(observerTiers, options = {}) {
+  const base = options.base ?? 3;
+  const maxObservers = options.maxObservers ?? 9;
+  let bonus = 0;
+  for (const tier of observerTiers) {
+    switch (tier) {
+      case "low" /* LOW */:
+        break;
+      case "medium" /* MEDIUM */:
+        bonus += 1;
+        break;
+      case "high" /* HIGH */:
+        bonus += 2;
+        break;
+      case "quarantined" /* QUARANTINED */:
+        bonus += 3;
+        break;
+    }
+  }
+  return Math.min(maxObservers, base + bonus);
+}
+
+// src/hololand/ItemManifest.ts
+var ITEM_DEFAULT_TICK_INTERVAL_MS = 864e5;
+var DEFAULT_ITEM_VERBAL_FINGERPRINT = {
+  fingerprint_key: "item_default",
+  style: {
+    label: "item_neutral",
+    minSentenceLength: 5,
+    maxSentenceLength: 40,
+    forbiddenPhrases: [],
+    requiredPhrases: [],
+    tone: "neutral"
+  },
+  enforce: false,
+  rolling_window: 50
+};
+var DEFAULT_ITEM_AUTONOMOUS_AGENDA = {
+  agent_class: "item",
+  tick_interval_ms: ITEM_DEFAULT_TICK_INTERVAL_MS,
+  daily_budget_usd: 0.05,
+  max_actions_per_tick: 1,
+  max_actions_per_day: 5,
+  pause_on_ceiling: true
+};
+var DEFAULT_ITEM_REPUTATION_LEDGER = {
+  world_id: "",
+  subject_id: "",
+  initial_trust: 50,
+  max_behavior_facts: 20,
+  world_ttl_days: 90,
+  emit_world_entry_disclosure: true,
+  disclosure_text: "",
+  deletion_modes: ["npc", "global"],
+  ttl_breach_alert_rule: "behavior_fact_ttl_breach"
+};
+var DEFAULT_ITEM_VOCABULARY_REGISTER = {
+  active_register: "medieval-fantasy",
+  max_injected_entries: 20,
+  prepend_tone_hint: true
+};
+function createHoloLandItem(id, name, options = {}) {
+  const ancestry = {
+    originType: options.ancestry?.originType ?? "world_spawn",
+    originId: options.ancestry?.originId ?? "world",
+    originName: options.ancestry?.originName ?? "World Spawn",
+    loreEvent: options.ancestry?.loreEvent,
+    crafterNpcId: options.ancestry?.crafterNpcId,
+    materialSourceItemId: options.ancestry?.materialSourceItemId
+  };
+  const state = {
+    durability: options.state?.durability ?? 1,
+    corrosion: options.state?.corrosion ?? 0,
+    curseDepth: options.state?.curseDepth ?? 0,
+    restorationProgress: options.state?.restorationProgress ?? 0,
+    awakened: options.state?.awakened ?? false,
+    equippedDurationSeconds: options.state?.equippedDurationSeconds ?? 0,
+    boundToPlayerId: options.state?.boundToPlayerId
+  };
+  const trajectory = {
+    type: options.trajectory?.type ?? "none",
+    conditionDescription: options.trajectory?.conditionDescription ?? "",
+    targetState: options.trajectory?.targetState ?? {},
+    requiredNpcId: options.trajectory?.requiredNpcId,
+    requiredLocationId: options.trajectory?.requiredLocationId,
+    requiredItemId: options.trajectory?.requiredItemId
+  };
+  const constraint = {
+    description: options.constraint?.description ?? "",
+    affectedEquipmentSlots: options.constraint?.affectedEquipmentSlots,
+    maxEquipDurationSeconds: options.constraint?.maxEquipDurationSeconds,
+    playstyleImpact: options.constraint?.playstyleImpact ?? ""
+  };
+  const verbalFingerprint = {
+    ...DEFAULT_ITEM_VERBAL_FINGERPRINT,
+    ...options.verbalFingerprint,
+    style: {
+      ...DEFAULT_ITEM_VERBAL_FINGERPRINT.style,
+      ...options.verbalFingerprint?.style
+    }
+  };
+  const autonomousAgenda = {
+    ...DEFAULT_ITEM_AUTONOMOUS_AGENDA,
+    ...options.autonomousAgenda
+  };
+  const reputationLedger = {
+    ...DEFAULT_ITEM_REPUTATION_LEDGER,
+    subject_id: id,
+    ...options.reputationLedger
+  };
+  const vocabularyRegister = {
+    ...DEFAULT_ITEM_VOCABULARY_REGISTER,
+    ...options.vocabularyRegister
+  };
+  return {
+    id,
+    name,
+    displayName: options.displayName ?? name,
+    description: options.description ?? "",
+    ancestry,
+    state,
+    trajectory,
+    constraint,
+    verbalFingerprint,
+    autonomousAgenda,
+    reputationLedger,
+    vocabularyRegister,
+    speechAwareEncounter: options.speechAwareEncounter,
+    previousItemId: options.previousItemId,
+    nextItemId: options.nextItemId,
+    chainDepth: options.chainDepth ?? 0,
+    traits: options.traits ?? [],
+    tags: options.tags ?? []
+  };
+}
+function linkItems(source, derivative) {
+  source.nextItemId = derivative.id;
+  derivative.previousItemId = source.id;
+  derivative.chainDepth = source.chainDepth + 1;
+  derivative.ancestry.materialSourceItemId = source.id;
+}
+function getItemChain(item, itemIndex) {
+  const chain = [item];
+  let current = item.previousItemId;
+  while (current) {
+    const prev = itemIndex.get(current);
+    if (!prev) break;
+    chain.unshift(prev);
+    current = prev.previousItemId;
+  }
+  return chain;
+}
+
+// src/hololand/StreamingProtocol.ts
+var PROTOCOL_VERSION = "1.0.0";
+var MAX_MESSAGE_SIZE = 64 * 1024;
+var MAX_CHUNK_SIZE = 16 * 1024;
+var HEARTBEAT_INTERVAL = 5e3;
+var TIMEOUT_INTERVAL = 15e3;
+var _StreamProtocol = class _StreamProtocol {
+  constructor() {
+    this.connection = null;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.pendingAcks = /* @__PURE__ */ new Map();
+    this.sequenceNumber = 0;
+    this.lastAckSeq = 0;
+    this.heartbeatTimer = null;
+    this.connectionState = "disconnected";
+  }
+  static getInstance() {
+    if (!_StreamProtocol.instance) {
+      _StreamProtocol.instance = new _StreamProtocol();
+    }
+    return _StreamProtocol.instance;
+  }
+  static resetInstance() {
+    _StreamProtocol.instance?.close();
+    _StreamProtocol.instance = null;
+  }
+  // ─── Connection Management ────────────────────────────────────────────────
+  /**
+   * Connect to streaming server
+   */
+  async connect(url, options) {
+    if (this.connectionState !== "disconnected") {
+      throw new Error("Already connected or connecting");
+    }
+    this.connectionState = "connecting";
+    return new Promise((resolve, reject) => {
+      try {
+        this.connection = new WebSocket(url);
+        this.connection.binaryType = "arraybuffer";
+        this.connection.onopen = () => {
+          this.sendHandshake(options);
+        };
+        this.connection.onmessage = (event) => {
+          const message = this.deserialize(event.data);
+          if (!message) return;
+          this.handleMessage(message);
+          if (message.type === "handshake_ack") {
+            this.connectionState = "connected";
+            this.startHeartbeat();
+            resolve();
+          }
+        };
+        this.connection.onerror = (_event) => {
+          const error = new Error("WebSocket error");
+          if (this.connectionState === "connecting") {
+            reject(error);
+          }
+          this.emit("error", {
+            type: "error",
+            seq: 0,
+            timestamp: Date.now(),
+            reliable: false,
+            priority: 0,
+            payload: { error }
+          });
+        };
+        this.connection.onclose = (event) => {
+          this.connectionState = "disconnected";
+          this.stopHeartbeat();
+          this.emit("close", {
+            type: "close",
+            seq: 0,
+            timestamp: Date.now(),
+            reliable: false,
+            priority: 0,
+            payload: { code: event.code, reason: event.reason }
+          });
+        };
+      } catch (error) {
+        this.connectionState = "disconnected";
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Close connection
+   */
+  close() {
+    this.stopHeartbeat();
+    if (this.connection) {
+      this.connection.close(1e3, "Client disconnect");
+      this.connection = null;
+    }
+    this.connectionState = "disconnected";
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connectionState === "connected";
+  }
+  // ─── Message Handling ─────────────────────────────────────────────────────
+  /**
+   * Subscribe to message type
+   */
+  on(type, handler) {
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, /* @__PURE__ */ new Set());
+    }
+    const h = handler;
+    this.handlers.get(type).add(h);
+    return () => this.handlers.get(type)?.delete(h);
+  }
+  /**
+   * Emit message to handlers
+   */
+  emit(type, message) {
+    const handlers = this.handlers.get(type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(message);
+        } catch (error) {
+          console.error(`Handler error for ${type}:`, error);
+        }
+      }
+    }
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(message) {
+    this.lastAckSeq = Math.max(this.lastAckSeq, message.seq);
+    const msgExt = message;
+    if (message.type === "heartbeat_ack" || msgExt.ack) {
+      const ackKey = msgExt.ackSeq || message.seq;
+      const pending = this.pendingAcks.get(ackKey);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        pending.resolve();
+        this.pendingAcks.delete(ackKey);
+      }
+    }
+    this.emit(message.type, message);
+  }
+  // ─── Message Sending ──────────────────────────────────────────────────────
+  /**
+   * Send message
+   */
+  send(message) {
+    if (!this.connection || this.connectionState !== "connected") {
+      throw new Error("Not connected");
+    }
+    const fullMessage = {
+      ...message,
+      seq: this.sequenceNumber++,
+      timestamp: Date.now()
+    };
+    const data = this.serialize(fullMessage);
+    this.connection.send(data);
+  }
+  /**
+   * Send message and wait for acknowledgment
+   */
+  async sendReliable(message, timeout = 5e3) {
+    const fullMessage = {
+      ...message,
+      seq: this.sequenceNumber++,
+      timestamp: Date.now(),
+      reliable: true
+    };
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingAcks.delete(fullMessage.seq);
+        reject(new Error("Message timeout"));
+      }, timeout);
+      this.pendingAcks.set(fullMessage.seq, { resolve, reject, timeout: timeoutId });
+      const data = this.serialize(fullMessage);
+      this.connection.send(data);
+    });
+  }
+  // ─── Specific Message Senders ─────────────────────────────────────────────
+  /**
+   * Send handshake
+   */
+  sendHandshake(options) {
+    const message = {
+      type: "handshake",
+      reliable: true,
+      priority: 255,
+      payload: {
+        protocolVersion: PROTOCOL_VERSION,
+        clientId: options.clientId,
+        clientVersion: options.clientVersion,
+        capabilities: options.capabilities ?? ["entity_sync", "asset_streaming"],
+        compression: "lz4",
+        encryption: "none"
+      }
+    };
+    const fullMessage = {
+      ...message,
+      seq: this.sequenceNumber++,
+      timestamp: Date.now()
+    };
+    const data = this.serialize(fullMessage);
+    this.connection.send(data);
+  }
+  /**
+   * Send heartbeat
+   */
+  sendHeartbeat() {
+    if (!this.isConnected()) return;
+    this.send({
+      type: "heartbeat",
+      reliable: false,
+      priority: 128,
+      payload: {
+        clientTime: Date.now(),
+        lastAckSeq: this.lastAckSeq
+      }
+    });
+  }
+  /**
+   * Join world
+   */
+  async joinWorld(worldId, spawnPoint) {
+    await this.sendReliable({
+      type: "world_join",
+      priority: 200,
+      payload: {
+        worldId,
+        spawnPoint
+      }
+    });
+  }
+  /**
+   * Leave world
+   */
+  async leaveWorld() {
+    await this.sendReliable({
+      type: "world_leave",
+      priority: 200,
+      payload: {}
+    });
+  }
+  /**
+   * Send entity update
+   */
+  sendEntityUpdate(entityId, changes) {
+    this.send({
+      type: "entity_update",
+      reliable: false,
+      priority: 128,
+      payload: {
+        id: entityId,
+        changes,
+        timestamp: Date.now()
+      }
+    });
+  }
+  /**
+   * Send entity RPC
+   */
+  async sendEntityRPC(entityId, method, args) {
+    const callId = `rpc_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    await this.sendReliable({
+      type: "entity_rpc",
+      priority: 192,
+      payload: {
+        entityId,
+        method,
+        args,
+        callId
+      }
+    });
+  }
+  /**
+   * Request asset
+   */
+  async requestAsset(assetId, options = {}) {
+    await this.sendReliable({
+      type: "asset_request",
+      priority: options.priority ?? 128,
+      payload: {
+        assetId,
+        priority: options.priority ?? 128,
+        acceptedFormats: options.acceptedFormats ?? ["gltf", "glb"],
+        maxQuality: options.maxQuality ?? "high"
+      }
+    });
+  }
+  /**
+   * Send player input
+   */
+  sendPlayerInput(inputs) {
+    this.send({
+      type: "player_input",
+      reliable: false,
+      priority: 192,
+      payload: {
+        playerId: "",
+        // Set by server
+        inputs,
+        timestamp: Date.now()
+      }
+    });
+  }
+  /**
+   * Send chat message
+   */
+  async sendChat(content, channel = "world", targetId) {
+    await this.sendReliable({
+      type: "chat_message",
+      priority: 160,
+      payload: {
+        senderId: "",
+        // Set by server
+        senderName: "",
+        // Set by server
+        content,
+        channel,
+        targetId
+      }
+    });
+  }
+  /**
+   * Send voice data
+   */
+  sendVoiceData(data, codec = "opus") {
+    this.send({
+      type: "voice_data",
+      reliable: false,
+      priority: 224,
+      payload: {
+        playerId: "",
+        // Set by server
+        data,
+        codec,
+        sampleRate: 48e3
+      }
+    });
+  }
+  // ─── Serialization ────────────────────────────────────────────────────────
+  /**
+   * Serialize message to binary
+   */
+  serialize(message) {
+    const json = JSON.stringify(message, (key, value) => {
+      if (value instanceof ArrayBuffer) {
+        return { __type: "ArrayBuffer", data: Array.from(new Uint8Array(value)) };
+      }
+      return value;
+    });
+    const encoder = new TextEncoder();
+    return encoder.encode(json).buffer;
+  }
+  /**
+   * Deserialize binary to message. Returns null on malformed payloads so the
+   * WebSocket onmessage handler does not crash the connection (W2-T1).
+   *
+   * Note: uses raw JSON.parse with a reviver because safeJsonParse does not
+   * expose the reviver hook. The outer try/catch restores crash-safety.
+   */
+  deserialize(data) {
+    let json;
+    if (data instanceof ArrayBuffer) {
+      const decoder = new TextDecoder();
+      json = decoder.decode(data);
+    } else {
+      json = data;
+    }
+    try {
+      return JSON.parse(json, (_key, value) => {
+        if (value && value.__type === "ArrayBuffer") {
+          return new Uint8Array(value.data).buffer;
+        }
+        return value;
+      });
+    } catch (err) {
+      console.error(
+        `[StreamingProtocol] Malformed JSON payload (${err instanceof Error ? err.message : String(err)})`
+      );
+      return null;
+    }
+  }
+  // ─── Heartbeat ────────────────────────────────────────────────────────────
+  /**
+   * Start heartbeat timer
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.sendHeartbeat();
+    }, HEARTBEAT_INTERVAL);
+  }
+  /**
+   * Stop heartbeat timer
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ─── Statistics ───────────────────────────────────────────────────────────
+  /**
+   * Get protocol statistics
+   */
+  getStats() {
+    return {
+      messagesSent: this.sequenceNumber,
+      messagesReceived: this.lastAckSeq,
+      pendingAcks: this.pendingAcks.size,
+      connectionState: this.connectionState
+    };
+  }
+};
+_StreamProtocol.instance = null;
+var StreamProtocol = _StreamProtocol;
+function getStreamProtocol() {
+  return StreamProtocol.getInstance();
+}
+function createMessage(type, payload, options = {}) {
+  return {
+    type,
+    payload,
+    reliable: options.reliable ?? (type.includes("_rpc") || type.includes("request")),
+    priority: options.priority ?? 128,
+    channel: options.channel
+  };
+}
+
+exports.CrossValidationRegistry = CrossValidationRegistry;
+exports.DEFAULT_ENVELOPES = DEFAULT_ENVELOPES;
+exports.DEFAULT_ITEM_AUTONOMOUS_AGENDA = DEFAULT_ITEM_AUTONOMOUS_AGENDA;
+exports.DEFAULT_ITEM_REPUTATION_LEDGER = DEFAULT_ITEM_REPUTATION_LEDGER;
+exports.DEFAULT_ITEM_VERBAL_FINGERPRINT = DEFAULT_ITEM_VERBAL_FINGERPRINT;
+exports.DEFAULT_ITEM_VOCABULARY_REGISTER = DEFAULT_ITEM_VOCABULARY_REGISTER;
+exports.HEARTBEAT_INTERVAL = HEARTBEAT_INTERVAL;
+exports.HololandClient = HololandClient;
+exports.ITEM_DEFAULT_TICK_INTERVAL_MS = ITEM_DEFAULT_TICK_INTERVAL_MS;
+exports.MAX_CHUNK_SIZE = MAX_CHUNK_SIZE;
+exports.MAX_MESSAGE_SIZE = MAX_MESSAGE_SIZE;
+exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+exports.PhysicsBoundsRegistry = PhysicsBoundsRegistry;
+exports.StreamProtocol = StreamProtocol;
+exports.TIMEOUT_INTERVAL = TIMEOUT_INTERVAL;
+exports.computeConsensus = computeConsensus;
+exports.connectToHololand = connectToHololand;
+exports.createHoloLandItem = createHoloLandItem;
+exports.createMessage = createMessage;
+exports.createWorldConfig = createWorldConfig;
+exports.createWorldDefinition = createWorldDefinition;
+exports.createWorldEnvironment = createWorldEnvironment;
+exports.createWorldMetadata = createWorldMetadata;
+exports.disconnectFromHololand = disconnectFromHololand;
+exports.getCrossValidationRegistry = getCrossValidationRegistry;
+exports.getHololandClient = getHololandClient;
+exports.getItemChain = getItemChain;
+exports.getPhysicsBoundsRegistry = getPhysicsBoundsRegistry;
+exports.getStreamProtocol = getStreamProtocol;
+exports.hololand_exports = hololand_exports;
+exports.linkItems = linkItems;
+exports.resetCrossValidationRegistry = resetCrossValidationRegistry;
+exports.resetPhysicsBoundsRegistry = resetPhysicsBoundsRegistry;
+exports.suggestedQuorum = suggestedQuorum;
+exports.wrapPhysicsService = wrapPhysicsService;
+//# sourceMappingURL=chunk-6CTRH7HT.cjs.map
+//# sourceMappingURL=chunk-6CTRH7HT.cjs.map