@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-4SDKXQ4C.js

@@ -0,0 +1,811 @@
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, compileParticleBlock, compilePhysicsBlock, compileMaterialBlock } from './chunk-BOVPWH4H.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { init_safeJsonParse, jsonClone } from './chunk-VVKVQZI6.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/VRRCompiler.ts
+var VRRCompiler_exports = {};
+__export(VRRCompiler_exports, {
+  VRRCompiler: () => VRRCompiler,
+  default: () => VRRCompiler_default
+});
+var VRRTraitDefs, VRRCompiler, VRRCompiler_default;
+var init_VRRCompiler = __esm({
+  "src/compiler/VRRCompiler.ts"() {
+    init_CompilerBase();
+    init_safeJsonParse();
+    init_DomainBlockCompilerMixin();
+    VRRTraitDefs = {
+      vrr_twin: { validator: (p) => !!p.mirror },
+      reality_mirror: { validator: (p) => Array.isArray(p.sync) && p.sync.length > 0 },
+      geo_anchor: {
+        validator: (p) => typeof p.lat === "number" && typeof p.lng === "number" && p.lat >= -90 && p.lat <= 90 && p.lng >= -180 && p.lng <= 180
+      },
+      weather_sync: {
+        validator: (p) => ["weather.gov", "openweathermap"].includes(String(p.provider))
+      },
+      event_sync: { validator: (p) => ["eventbrite", "ticketmaster"].includes(String(p.provider)) },
+      inventory_sync: {
+        validator: (p) => ["square_pos", "shopify", "woocommerce"].includes(String(p.provider))
+      },
+      quest_hub: { validator: (p) => Array.isArray(p.quests) && p.quests.length > 0 },
+      layer_shift: {
+        validator: (p) => {
+          const valid = ["ar", "vrr", "vr"];
+          return valid.includes(String(p.from)) && valid.includes(String(p.to));
+        }
+      },
+      x402_paywall: {
+        validator: (p) => Number(p.price) > 0 && ["USDC", "ETH", "SOL"].includes(String(p.asset || "USDC")) && ["base", "ethereum", "solana"].includes(String(p.network || "base"))
+      },
+      geo_sync: { validator: (p) => !!p.center && Number(p.radius || 0) >= 0 }
+    };
+    VRRCompiler = class extends CompilerBase {
+      constructor(options) {
+        super();
+        this.compilerName = "VRRCompiler";
+        this.errors = [];
+        this.warnings = [];
+        this.generatedCode = [];
+        this.options = options;
+      }
+      getRequiredCapability() {
+        return ANSCapabilityPath.VRR;
+      }
+      // ─── 1. parseVRRComposition ───────────────────────────────────────────
+      /**
+       * Parse a HoloScript AST and extract VRR-specific traits.
+       * Walks AST nodes, collects trait annotations, validates params against VRRTraits definitions.
+       */
+      parseVRRComposition(composition) {
+        const data = {
+          twinNodes: [],
+          weatherNodes: [],
+          eventNodes: [],
+          inventoryNodes: [],
+          questNodes: [],
+          layerShiftNodes: [],
+          paywallNodes: [],
+          geoAnchorNodes: []
+        };
+        const traitToField = {
+          vrr_twin: "twinNodes",
+          weather_sync: "weatherNodes",
+          event_sync: "eventNodes",
+          inventory_sync: "inventoryNodes",
+          quest_hub: "questNodes",
+          layer_shift: "layerShiftNodes",
+          x402_paywall: "paywallNodes",
+          geo_anchor: "geoAnchorNodes"
+        };
+        const traverse = (node) => {
+          if (!node || typeof node !== "object") return;
+          const n = node;
+          if (n.traits && Array.isArray(n.traits)) {
+            for (const trait of n.traits) {
+              const field = traitToField[trait.name];
+              if (field) {
+                const traitDef = VRRTraitDefs[trait.name];
+                if (traitDef?.validator && !traitDef.validator(trait.params)) {
+                  this.warnings.push(`@${trait.name} on "${n.name || "unnamed"}" has invalid params`);
+                }
+                data[field].push(n);
+              }
+            }
+          }
+          for (const key of Object.keys(n)) {
+            const val = n[key];
+            if (val && typeof val === "object") {
+              if (Array.isArray(val)) {
+                for (const item of val) {
+                  traverse(item);
+                }
+              } else {
+                traverse(val);
+              }
+            }
+          }
+        };
+        traverse(composition);
+        return data;
+      }
+      // ─── 2. compileToThreeJS ──────────────────────────────────────────────
+      /**
+       * Generate a complete Three.js scene from VRR composition data.
+       * Places objects using geo_anchor coordinates, sets up materials/lighting/camera.
+       */
+      compileToThreeJS(compositionData, twinGroupName) {
+        this.generatedCode.push(`
+// === Three.js Scene Generation ===`);
+        this.generatedCode.push(`const ambientLight = new THREE.AmbientLight(0x404040, 0.6);`);
+        this.generatedCode.push(`scene.add(ambientLight);`);
+        this.generatedCode.push(`const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);`);
+        this.generatedCode.push(`directionalLight.position.set(50, 200, 100);`);
+        this.generatedCode.push(`directionalLight.castShadow = true;`);
+        this.generatedCode.push(`scene.add(directionalLight);`);
+        this.generatedCode.push(`const groundGeo = new THREE.PlaneGeometry(10000, 10000);`);
+        this.generatedCode.push(
+          `const groundMat = new THREE.MeshStandardMaterial({ color: 0x3a7d3a, roughness: 0.9 });`
+        );
+        this.generatedCode.push(`const ground = new THREE.Mesh(groundGeo, groundMat);`);
+        this.generatedCode.push(`ground.rotation[0] = -Math.PI / 2;`);
+        this.generatedCode.push(`ground.receiveShadow = true;`);
+        this.generatedCode.push(`scene.add(ground);`);
+        this.generatedCode.push(`camera.position.set(0, 50, 100);`);
+        this.generatedCode.push(`camera.lookAt(0, 0, 0);`);
+        for (const node of compositionData.geoAnchorNodes) {
+          const geoTrait = this.findTrait(node, "geo_anchor");
+          if (!geoTrait) continue;
+          const lat = Number(geoTrait.params.lat) || 0;
+          const lng = Number(geoTrait.params.lng) || 0;
+          const safeName = this.escapeStringValue(String(node.name || "geo_object"), "TypeScript");
+          this.generatedCode.push(`
+// Geo-anchored: ${safeName} (${lat}, ${lng})`);
+          this.generatedCode.push(`const marker_${safeName} = new THREE.Group();`);
+          this.generatedCode.push(
+            `marker_${safeName}.position.copy(vrr.geoToSceneCoords(${lat}, ${lng}));`
+          );
+          this.generatedCode.push(`marker_${safeName}.userData.geo = { lat: ${lat}, lng: ${lng} };`);
+          this.generatedCode.push(`${twinGroupName}.add(marker_${safeName});`);
+        }
+        this.generatedCode.push(`
+// Skybox`);
+        this.generatedCode.push(`scene.background = new THREE.Color(0x87ceeb);`);
+        this.generatedCode.push(`
+// Render loop`);
+        this.generatedCode.push(`renderer.shadowMap.enabled = true;`);
+        this.generatedCode.push(`renderer.shadowMap.type = THREE.PCFSoftShadowMap;`);
+        this.generatedCode.push(`function animate() {`);
+        this.generatedCode.push(`  requestAnimationFrame(animate);`);
+        this.generatedCode.push(`  vrr.tick();`);
+        this.generatedCode.push(`  renderer.render(scene, camera);`);
+        this.generatedCode.push(`}`);
+        this.generatedCode.push(`animate();`);
+      }
+      // ─── 3. generateWeatherSync ───────────────────────────────────────────
+      /**
+       * Generate code that connects to weather API and updates scene
+       * lighting/particles/skybox based on real-time weather data.
+       */
+      generateWeatherSync(nodes) {
+        if (nodes.length === 0) return;
+        this.generatedCode.push(`
+// === @weather_sync \u2014 Real-Time Weather Integration ===`);
+        for (const node of nodes) {
+          const trait = this.findTrait(node, "weather_sync");
+          if (!trait) continue;
+          const provider = String(trait.params.provider || "weather.gov");
+          const refresh = String(trait.params.refresh || "5_minutes");
+          const safeName = this.escapeStringValue(String(node.name || "zone"), "TypeScript");
+          this.generatedCode.push(`// Weather sync for "${safeName}" via ${provider}`);
+          this.generatedCode.push(`const weatherSync_${safeName} = vrr.createWeatherSync({`);
+          this.generatedCode.push(`  provider: '${provider}',`);
+          this.generatedCode.push(`  refresh: '${refresh}',`);
+          this.generatedCode.push(`  location: vrr.getGeoCenter(),`);
+          this.generatedCode.push(`});`);
+          this.generatedCode.push(`const rainGeometry = new THREE.BufferGeometry();`);
+          this.generatedCode.push(`const rainPositions = new Float32Array(3000 * 3);`);
+          this.generatedCode.push(`for (let i = 0; i < 3000; i++) {`);
+          this.generatedCode.push(`  rainPositions[i * 3] = (Math.random() - 0.5) * 500;`);
+          this.generatedCode.push(`  rainPositions[i * 3 + 1] = Math.random() * 200;`);
+          this.generatedCode.push(`  rainPositions[i * 3 + 2] = (Math.random() - 0.5) * 500;`);
+          this.generatedCode.push(`}`);
+          this.generatedCode.push(
+            `rainGeometry.setAttribute('position', new THREE.BufferAttribute(rainPositions, 3));`
+          );
+          this.generatedCode.push(
+            `const rainMaterial = new THREE.PointsMaterial({ color: 0xaaaaaa, size: 0.1, transparent: true });`
+          );
+          this.generatedCode.push(`const rainSystem = new THREE.Points(rainGeometry, rainMaterial);`);
+          this.generatedCode.push(`rainSystem.visible = false;`);
+          this.generatedCode.push(`scene.add(rainSystem);`);
+          this.generatedCode.push(`weatherSync_${safeName}.onUpdate((weather) => {`);
+          this.generatedCode.push(`  // Update fog based on visibility`);
+          this.generatedCode.push(
+            `  scene.fog = new THREE.Fog(0xcccccc, 10, Math.max(weather.visibility, 50));`
+          );
+          this.generatedCode.push(`  // Toggle rain particles`);
+          this.generatedCode.push(`  rainSystem.visible = weather.precipitation > 0;`);
+          this.generatedCode.push(`  // Adjust sun intensity based on cloud cover`);
+          this.generatedCode.push(
+            `  directionalLight.intensity = Math.max(0.2, 1.0 - (weather.cloud_cover || 0) / 100);`
+          );
+          this.generatedCode.push(`  // Update skybox color`);
+          this.generatedCode.push(`  const skyHue = weather.precipitation > 50 ? 0x666680 : 0x87ceeb;`);
+          this.generatedCode.push(`  scene.background = new THREE.Color(skyHue);`);
+          this.generatedCode.push(`  // Temperature-based ambient tint`);
+          this.generatedCode.push(
+            `  const tempNorm = Math.max(0, Math.min(1, (weather.temperature_f || 70) / 120));`
+          );
+          this.generatedCode.push(`  ambientLight.color.setHSL(0.6 - tempNorm * 0.4, 0.3, 0.4);`);
+          this.generatedCode.push(`});`);
+        }
+      }
+      // ─── 4. generateEventSync ─────────────────────────────────────────────
+      /**
+       * Generate code that fetches events from providers (Eventbrite/Ticketmaster)
+       * and creates event markers + UI overlays in the scene.
+       */
+      generateEventSync(nodes) {
+        if (nodes.length === 0) return;
+        this.generatedCode.push(`
+// === @event_sync \u2014 Real-Time Event Integration ===`);
+        for (const node of nodes) {
+          const trait = this.findTrait(node, "event_sync");
+          if (!trait) continue;
+          const provider = String(trait.params.provider || "eventbrite");
+          const refresh = String(trait.params.refresh || "5_minutes");
+          const safeName = this.escapeStringValue(String(node.name || "zone"), "TypeScript");
+          this.generatedCode.push(`// Event sync for "${safeName}" via ${provider}`);
+          this.generatedCode.push(`const eventSync_${safeName} = vrr.createEventSync({`);
+          this.generatedCode.push(`  provider: '${provider}',`);
+          this.generatedCode.push(`  refresh: '${refresh}',`);
+          this.generatedCode.push(`  location: vrr.getGeoCenter(),`);
+          this.generatedCode.push(`});`);
+          this.generatedCode.push(`const eventMarkers_${safeName} = new THREE.Group();`);
+          this.generatedCode.push(`scene.add(eventMarkers_${safeName});`);
+          this.generatedCode.push(`eventSync_${safeName}.onUpdate((events) => {`);
+          this.generatedCode.push(`  // Clear previous markers`);
+          this.generatedCode.push(`  while (eventMarkers_${safeName}.children.length > 0) {`);
+          this.generatedCode.push(
+            `    eventMarkers_${safeName}.remove(eventMarkers_${safeName}.children[0]);`
+          );
+          this.generatedCode.push(`  }`);
+          this.generatedCode.push(`  for (const evt of events) {`);
+          this.generatedCode.push(`    // Create event marker billboard`);
+          this.generatedCode.push(`    const markerGeo = new THREE.CylinderGeometry(0.5, 0.5, 8, 8);`);
+          this.generatedCode.push(
+            `    const markerMat = new THREE.MeshStandardMaterial({ color: 0xff4444, emissive: 0x331111 });`
+          );
+          this.generatedCode.push(`    const marker = new THREE.Mesh(markerGeo, markerMat);`);
+          this.generatedCode.push(`    if (evt.geo) {`);
+          this.generatedCode.push(
+            `      marker.position.copy(vrr.geoToSceneCoords(evt.geo.lat, evt.geo.lng));`
+          );
+          this.generatedCode.push(`    }`);
+          this.generatedCode.push(
+            `    marker.userData.event = { name: evt.name, date: evt.date, url: evt.url };`
+          );
+          this.generatedCode.push(`    eventMarkers_${safeName}.add(marker);`);
+          this.generatedCode.push(`    // Spawn NPC crowds for active events`);
+          this.generatedCode.push(`    if (evt.status === 'active') {`);
+          this.generatedCode.push(
+            `      vrr.spawnNPCCrowd(marker.position, evt.expected_attendance || 20);`
+          );
+          this.generatedCode.push(`    }`);
+          this.generatedCode.push(`  }`);
+          this.generatedCode.push(`});`);
+        }
+      }
+      // ─── 5. generateInventorySync ─────────────────────────────────────────
+      /**
+       * Generate code for real-time inventory display:
+       * product counts, availability badges, stock-level indicators.
+       */
+      generateInventorySync(nodes, twinGroupName) {
+        if (nodes.length === 0) return;
+        this.generatedCode.push(`
+// === @inventory_sync \u2014 Real-Time Inventory Display ===`);
+        for (const node of nodes) {
+          const trait = this.findTrait(node, "inventory_sync");
+          if (!trait) continue;
+          const provider = String(trait.params.provider || "square_pos");
+          const refresh = String(trait.params.refresh || "1_minute");
+          const useWebSocket = Boolean(trait.params.websocket);
+          const safeName = this.escapeStringValue(String(node.name || "shop"), "TypeScript");
+          this.generatedCode.push(`// Inventory sync for "${safeName}" via ${provider}`);
+          this.generatedCode.push(`const inventorySync_${safeName} = vrr.createInventorySync({`);
+          this.generatedCode.push(`  provider: '${provider}',`);
+          this.generatedCode.push(`  refresh: '${refresh}',`);
+          this.generatedCode.push(`  websocket: ${useWebSocket},`);
+          this.generatedCode.push(`  business_id: '${safeName}',`);
+          this.generatedCode.push(`});`);
+          this.generatedCode.push(`const inventoryUI_${safeName} = new THREE.Group();`);
+          this.generatedCode.push(`${twinGroupName}.add(inventoryUI_${safeName});`);
+          this.generatedCode.push(`inventorySync_${safeName}.onUpdate((inventory) => {`);
+          this.generatedCode.push(`  // Clear previous inventory display`);
+          this.generatedCode.push(`  while (inventoryUI_${safeName}.children.length > 0) {`);
+          this.generatedCode.push(
+            `    inventoryUI_${safeName}.remove(inventoryUI_${safeName}.children[0]);`
+          );
+          this.generatedCode.push(`  }`);
+          this.generatedCode.push(`  for (const item of inventory.items) {`);
+          this.generatedCode.push(
+            `    // Availability badge color: green=in-stock, yellow=low, red=out`
+          );
+          this.generatedCode.push(
+            `    const badgeColor = item.quantity > 10 ? 0x00ff00 : item.quantity > 0 ? 0xffaa00 : 0xff0000;`
+          );
+          this.generatedCode.push(`    const badgeGeo = new THREE.SphereGeometry(0.3, 8, 8);`);
+          this.generatedCode.push(
+            `    const badgeMat = new THREE.MeshStandardMaterial({ color: badgeColor, emissive: badgeColor, emissiveIntensity: 0.5 });`
+          );
+          this.generatedCode.push(`    const badge = new THREE.Mesh(badgeGeo, badgeMat);`);
+          this.generatedCode.push(
+            `    badge.userData.product = { name: item.name, quantity: item.quantity, price: item.price };`
+          );
+          this.generatedCode.push(`    inventoryUI_${safeName}.add(badge);`);
+          this.generatedCode.push(`  }`);
+          this.generatedCode.push(`});`);
+        }
+      }
+      // ─── 6. generateQuestLogic ────────────────────────────────────────────
+      /**
+       * Generate quest/gamification code: visit locations, collect items,
+       * earn rewards, track progress across AR/VRR/VR layers.
+       */
+      generateQuestLogic(nodes) {
+        if (nodes.length === 0) return;
+        this.generatedCode.push(`
+// === @quest_hub \u2014 Business Quest Mechanics ===`);
+        for (const node of nodes) {
+          const trait = this.findTrait(node, "quest_hub");
+          if (!trait) continue;
+          const quests = Array.isArray(trait.params.quests) ? trait.params.quests : [];
+          const safeName = this.escapeStringValue(String(node.name || "business"), "TypeScript");
+          this.generatedCode.push(`// Quest hub: "${safeName}" with ${quests.length} quest(s)`);
+          this.generatedCode.push(`const questHub_${safeName} = vrr.createQuestHub({`);
+          this.generatedCode.push(`  business_id: '${safeName}',`);
+          this.generatedCode.push(`  quests: ${JSON.stringify(quests)},`);
+          this.generatedCode.push(`});`);
+          this.generatedCode.push(`// Quest NPC beacon`);
+          this.generatedCode.push(
+            `const questBeacon_${safeName} = new THREE.PointLight(0xffdd00, 2, 30);`
+          );
+          this.generatedCode.push(`questBeacon_${safeName}.position.set(0, 5, 0);`);
+          this.generatedCode.push(
+            `if (marker_${safeName}) marker_${safeName}.add(questBeacon_${safeName});`
+          );
+          this.generatedCode.push(`questHub_${safeName}.onQuestStart((quest) => {`);
+          this.generatedCode.push(`  vrr.persistState('quest_progress_' + quest.id, {`);
+          this.generatedCode.push(`    started_at: Date.now(),`);
+          this.generatedCode.push(`    current_step: 0,`);
+          this.generatedCode.push(`    steps_completed: [],`);
+          this.generatedCode.push(`  });`);
+          this.generatedCode.push(`});`);
+          this.generatedCode.push(`questHub_${safeName}.onStepComplete((quest, stepIndex) => {`);
+          this.generatedCode.push(`  const state = vrr.getState('quest_progress_' + quest.id);`);
+          this.generatedCode.push(`  if (state) {`);
+          this.generatedCode.push(`    state.steps_completed.push(stepIndex);`);
+          this.generatedCode.push(`    state.current_step = stepIndex + 1;`);
+          this.generatedCode.push(`    vrr.persistState('quest_progress_' + quest.id, state);`);
+          this.generatedCode.push(`  }`);
+          this.generatedCode.push(`});`);
+          this.generatedCode.push(`questHub_${safeName}.onQuestComplete((quest, reward) => {`);
+          this.generatedCode.push(`  vrr.persistState('quest_progress_' + quest.id, {`);
+          this.generatedCode.push(`    completed_at: Date.now(),`);
+          this.generatedCode.push(`    reward_claimed: false,`);
+          this.generatedCode.push(`  });`);
+          this.generatedCode.push(`  // Grant reward (coupon, NFT, etc.)`);
+          this.generatedCode.push(`  vrr.grantReward(quest.id, reward);`);
+          this.generatedCode.push(`  // Visual celebration`);
+          this.generatedCode.push(`  questBeacon_${safeName}.color.setHex(0x00ff00);`);
+          this.generatedCode.push(`});`);
+        }
+      }
+      // ─── 7. generateLayerShift ────────────────────────────────────────────
+      /**
+       * Generate AR/VRR/VR transition handlers with state persistence.
+       * Preserves quest progress, inventory state, and player position across layers.
+       */
+      generateLayerShift(nodes) {
+        if (nodes.length === 0) return;
+        this.generatedCode.push(`
+// === @layer_shift \u2014 AR/VRR/VR Transition Handlers ===`);
+        this.generatedCode.push(`const layerState = {`);
+        this.generatedCode.push(`  current: 'vrr',`);
+        this.generatedCode.push(`  persist: async (data) => {`);
+        this.generatedCode.push(`    // IndexedDB for client-side persistence`);
+        this.generatedCode.push(`    const db = await vrr.getIndexedDB('hololand_layers');`);
+        this.generatedCode.push(`    await db.put('layer_state', data);`);
+        this.generatedCode.push(`    // Server-side sync`);
+        this.generatedCode.push(`    await vrr.syncToServer('layer_state', data);`);
+        this.generatedCode.push(`  },`);
+        this.generatedCode.push(`  restore: async () => {`);
+        this.generatedCode.push(`    const db = await vrr.getIndexedDB('hololand_layers');`);
+        this.generatedCode.push(`    return await db.get('layer_state');`);
+        this.generatedCode.push(`  },`);
+        this.generatedCode.push(`};`);
+        for (const node of nodes) {
+          const trait = this.findTrait(node, "layer_shift");
+          if (!trait) continue;
+          const from = String(trait.params.from || "ar");
+          const to = String(trait.params.to || "vrr");
+          const price = Number(trait.params.price) || 0;
+          const persistState = trait.params.persist_state !== false;
+          const safeName = this.escapeStringValue(String(node.name || "portal"), "TypeScript");
+          this.generatedCode.push(`
+// Layer shift: ${from} -> ${to} (${safeName})`);
+          this.generatedCode.push(`vrr.registerLayerShift({`);
+          this.generatedCode.push(`  id: '${safeName}',`);
+          this.generatedCode.push(`  from: '${from}',`);
+          this.generatedCode.push(`  to: '${to}',`);
+          this.generatedCode.push(`  price: ${price},`);
+          this.generatedCode.push(`  persist_state: ${persistState},`);
+          this.generatedCode.push(`  onTransition: async (player) => {`);
+          if (persistState) {
+            this.generatedCode.push(`    // Save current state before transition`);
+            this.generatedCode.push(`    await layerState.persist({`);
+            this.generatedCode.push(`      player_position: player.position,`);
+            this.generatedCode.push(`      quest_progress: vrr.getAllQuestProgress(),`);
+            this.generatedCode.push(`      inventory: vrr.getPlayerInventory(),`);
+            this.generatedCode.push(`      layer_from: '${from}',`);
+            this.generatedCode.push(`      timestamp: Date.now(),`);
+            this.generatedCode.push(`    });`);
+          }
+          if (price > 0) {
+            this.generatedCode.push(`    // Require payment before transition`);
+            this.generatedCode.push(
+              `    const paid = await vrr.requirePayment({ price: ${price}, asset: 'USDC', network: 'base' });`
+            );
+            this.generatedCode.push(`    if (!paid) return false;`);
+          }
+          this.generatedCode.push(`    // Execute layer transition`);
+          this.generatedCode.push(`    layerState.current = '${to}';`);
+          this.generatedCode.push(`    vrr.transitionToLayer('${to}');`);
+          this.generatedCode.push(`    return true;`);
+          this.generatedCode.push(`  },`);
+          this.generatedCode.push(`  onArrive: async (player) => {`);
+          if (persistState) {
+            this.generatedCode.push(`    // Restore state after transition`);
+            this.generatedCode.push(`    const saved = await layerState.restore();`);
+            this.generatedCode.push(`    if (saved) {`);
+            this.generatedCode.push(`      vrr.restoreQuestProgress(saved.quest_progress);`);
+            this.generatedCode.push(`      vrr.restorePlayerInventory(saved.inventory);`);
+            this.generatedCode.push(`    }`);
+          }
+          this.generatedCode.push(`  },`);
+          this.generatedCode.push(`});`);
+        }
+      }
+      // ─── 8. generateX402Paywall ───────────────────────────────────────────
+      /**
+       * Generate payment requirement checks using x402 protocol.
+       * Blocks content access until on-chain payment is verified.
+       */
+      generateX402Paywall(nodes) {
+        if (nodes.length === 0) return;
+        this.generatedCode.push(`
+// === @x402_paywall \u2014 Payment Requirement Checks ===`);
+        for (const node of nodes) {
+          const trait = this.findTrait(node, "x402_paywall");
+          if (!trait) continue;
+          const price = Number(trait.params.price) || 0;
+          const asset = String(trait.params.asset || "USDC");
+          const network = String(trait.params.network || "base");
+          const safeName = this.escapeStringValue(String(node.name || "content"), "TypeScript");
+          this.generatedCode.push(`// x402 paywall: "${safeName}" \u2014 ${price} ${asset} on ${network}`);
+          this.generatedCode.push(`const paywall_${safeName} = vrr.createPaywall({`);
+          this.generatedCode.push(`  content_id: '${safeName}',`);
+          this.generatedCode.push(`  price: ${price},`);
+          this.generatedCode.push(`  asset: '${asset}',`);
+          this.generatedCode.push(`  network: '${network}',`);
+          this.generatedCode.push(`  on402: async (req) => {`);
+          this.generatedCode.push(`    // Return 402 Payment Required with payment details`);
+          this.generatedCode.push(`    return {`);
+          this.generatedCode.push(`      status: 402,`);
+          this.generatedCode.push(`      headers: {`);
+          this.generatedCode.push(`        'X-Payment-Required': 'true',`);
+          this.generatedCode.push(`        'X-Payment-Amount': '${price}',`);
+          this.generatedCode.push(`        'X-Payment-Asset': '${asset}',`);
+          this.generatedCode.push(`        'X-Payment-Network': '${network}',`);
+          this.generatedCode.push(`        'X-Payment-Address': vrr.getPaymentAddress('${safeName}'),`);
+          this.generatedCode.push(`      },`);
+          this.generatedCode.push(`    };`);
+          this.generatedCode.push(`  },`);
+          this.generatedCode.push(`  onPaymentVerified: (receipt) => {`);
+          this.generatedCode.push(`    vrr.persistState('paywall_${safeName}', {`);
+          this.generatedCode.push(`      paid: true,`);
+          this.generatedCode.push(`      tx_hash: receipt.tx_hash,`);
+          this.generatedCode.push(`      timestamp: Date.now(),`);
+          this.generatedCode.push(`    });`);
+          this.generatedCode.push(`    // Unlock content in scene`);
+          this.generatedCode.push(`    vrr.unlockContent('${safeName}');`);
+          this.generatedCode.push(`  },`);
+          this.generatedCode.push(`  onPaymentFailed: (error) => {`);
+          this.generatedCode.push(
+            `    console.warn('Payment failed for ${safeName}:', error.message);`
+          );
+          this.generatedCode.push(
+            `    vrr.showPaywallUI('${safeName}', { price: ${price}, asset: '${asset}', network: '${network}' });`
+          );
+          this.generatedCode.push(`  },`);
+          this.generatedCode.push(`});`);
+        }
+      }
+      // ─── Utility: find trait on node ──────────────────────────────────────
+      findTrait(node, traitName) {
+        if (!node.traits) return void 0;
+        return node.traits.find((t) => t.name === traitName);
+      }
+      // ─── Main compile() ──────────────────────────────────────────────────
+      normalizeToCompositionTree(input) {
+        if (!input || typeof input !== "object") return null;
+        const node = input;
+        const nodeType = String(node.type || "").toLowerCase();
+        if (nodeType === "composition") {
+          return input;
+        }
+        if (nodeType === "world") {
+          return {
+            type: "Composition",
+            name: String(node.name || "WorldRoot"),
+            templates: [],
+            objects: [],
+            spatialGroups: [],
+            lights: [],
+            imports: [],
+            timelines: [],
+            audio: [],
+            zones: [],
+            transitions: [],
+            conditionals: [],
+            iterators: [],
+            npcs: [],
+            quests: [],
+            abilities: [],
+            dialogues: [],
+            stateMachines: [],
+            achievements: [],
+            talentTrees: [],
+            shapes: [],
+            children: [node],
+            worlds: [node]
+          };
+        }
+        return null;
+      }
+      extractGlobalSimulationStateFromWorlds(comp) {
+        const worlds = Array.isArray(comp.worlds) ? comp.worlds : [];
+        if (worlds.length > 0 && worlds[0]) {
+          const w = worlds[0];
+          if (w.simulation_state && typeof w.simulation_state === "object") {
+            return w.simulation_state;
+          }
+          if (w.simulationState && typeof w.simulationState === "object") {
+            return w.simulationState;
+          }
+          if (w.state && typeof w.state === "object") {
+            return w.state;
+          }
+        }
+        const children = Array.isArray(comp.children) ? comp.children : [];
+        const worldChild = children.find((c) => String(c?.type || "").toLowerCase() === "world");
+        if (worldChild) {
+          if (worldChild.simulation_state && typeof worldChild.simulation_state === "object") {
+            return worldChild.simulation_state;
+          }
+          if (worldChild.simulationState && typeof worldChild.simulationState === "object") {
+            return worldChild.simulationState;
+          }
+          if (worldChild.state && typeof worldChild.state === "object") {
+            return worldChild.state;
+          }
+        }
+        return {};
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.errors = [];
+        this.warnings = [];
+        this.generatedCode = [];
+        const normalizedComposition = this.normalizeToCompositionTree(composition);
+        if (!normalizedComposition) {
+          this.errors.push("Invalid composition tree");
+          return this.buildResult();
+        }
+        const compositionData = this.parseVRRComposition(normalizedComposition);
+        const twinNodes = compositionData.twinNodes;
+        if (twinNodes.length === 0) {
+          this.warnings.push(
+            "No @vrr_twin traits found. Compiling as standard 3D instead of reality mirror."
+          );
+        }
+        const comp = normalizedComposition;
+        const globalSimulationState = this.extractGlobalSimulationStateFromWorlds(comp);
+        this.generateImports();
+        this.generateSceneSetup();
+        const twinGroupName = this.generateAPIHooks(twinNodes, globalSimulationState);
+        this.compileToThreeJS(compositionData, twinGroupName);
+        this.generateWeatherSync(compositionData.weatherNodes);
+        this.generateEventSync(compositionData.eventNodes);
+        this.generateInventorySync(compositionData.inventoryNodes, twinGroupName);
+        this.generateQuestLogic(compositionData.questNodes);
+        this.generateLayerShift(compositionData.layerShiftNodes);
+        this.generateX402Paywall(compositionData.paywallNodes);
+        const domainBlocks = Array.isArray(comp.domainBlocks) ? comp.domainBlocks : [];
+        if (domainBlocks.length > 0) {
+          this.generatedCode.push("\n// === v4.2 Domain Blocks ===");
+          const compiled = compileDomainBlocks(
+            // @ts-expect-error During migration
+            domainBlocks,
+            {
+              material: (block) => {
+                const m = compileMaterialBlock(block);
+                return `// VRR Material: "${this.escapeStringValue(m.name, "TypeScript")}" type=${m.type} baseColor=${m.baseColor || "none"}`;
+              },
+              physics: (block) => {
+                const p = compilePhysicsBlock(block);
+                return `// VRR Physics: ${p.keyword} "${p.name || ""}" colliders=${p.colliders?.length || 0}`;
+              },
+              vfx: (block) => {
+                const ps = compileParticleBlock(block);
+                return `// VRR Particles: "${this.escapeStringValue(ps.name, "TypeScript")}" rate=${ps.properties.rate || "default"}`;
+              },
+              audio: (block) => {
+                const a = compileAudioSourceBlock(block);
+                return `// VRR Audio: "${this.escapeStringValue(a.name, "TypeScript")}" clip=${a.properties.clip || "none"}`;
+              },
+              weather: (block) => {
+                const w = compileWeatherBlock(block);
+                return `// VRR Weather: ${w.keyword} layers=[${w.layers.map((l) => l.type).join(", ")}]`;
+              }
+            },
+            (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}"`
+          );
+          for (const line of compiled) {
+            this.generatedCode.push(line);
+          }
+        }
+        this.generatedCode.push(`
+// --- End of VRR Bindings --- //
+`);
+        this.generatedCode.push(`scene.add(${twinGroupName});`);
+        return this.buildResult();
+      }
+      extractNodesWithTrait(astNode, traitName) {
+        const matched = [];
+        const cleanTraitName = traitName.startsWith("@") ? traitName.slice(1) : traitName;
+        const traverse = (node) => {
+          if (!node || typeof node !== "object") return;
+          const n = node;
+          if (n.traits && Array.isArray(n.traits) && n.traits.some((t) => t.name === cleanTraitName)) {
+            matched.push(n);
+          }
+          for (const key of Object.keys(n)) {
+            const val = n[key];
+            if (typeof val === "object" && val !== null) {
+              traverse(val);
+            }
+          }
+        };
+        traverse(astNode);
+        return matched;
+      }
+      generateImports() {
+        if (this.options.provenanceHash) {
+          this.generatedCode.push(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
+        this.generatedCode.push(`import * as THREE from 'three';`);
+        this.generatedCode.push(`import { VRRRuntime } from '@holoscript/runtime';`);
+      }
+      generateSceneSetup() {
+        this.generatedCode.push(`
+// Initialize Scene`);
+        this.generatedCode.push(`const scene = new THREE.Scene();`);
+        this.generatedCode.push(
+          `const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);`
+        );
+        this.generatedCode.push(`const renderer = new THREE.WebGLRenderer({ antialias: true });`);
+        this.generatedCode.push(`renderer.setSize(window.innerWidth, window.innerHeight);`);
+        this.generatedCode.push(`document.body.appendChild(renderer.domElement);`);
+      }
+      generateAPIHooks(twinNodes, globalSimulationState = {}) {
+        this.generatedCode.push(`
+// Engine Initialization via @vrr_twin`);
+        let geoCenter = { lat: 0, lng: 0 };
+        let twinId = `auto_gen_twin`;
+        let twinName = "globalWorldContext";
+        let weatherProvider = "";
+        let eventProvider = "";
+        let inventoryProvider = "";
+        for (const rawNode of twinNodes) {
+          const node = rawNode;
+          if (node.name) {
+            twinName = this.escapeStringValue(String(node.name), "TypeScript");
+          }
+          if (node.traits) {
+            for (const trait of node.traits) {
+              if (trait.name === "geo_anchor")
+                geoCenter = { lat: Number(trait.params.lat), lng: Number(trait.params.lng) };
+              else if (trait.name === "vrr_twin" && trait.params.mirror)
+                twinId = String(trait.params.mirror);
+              else if (trait.name === "weather_sync") weatherProvider = String(trait.params.provider);
+              else if (trait.name === "event_sync") eventProvider = String(trait.params.provider);
+              else if (trait.name === "inventory_sync")
+                inventoryProvider = String(trait.params.provider);
+            }
+          }
+        }
+        const apiConfig = jsonClone(this.options.api_integrations || {});
+        if (weatherProvider && !apiConfig.weather) apiConfig.weather = { provider: weatherProvider };
+        if (eventProvider && !apiConfig.events) apiConfig.events = { provider: eventProvider };
+        if (inventoryProvider && !apiConfig.inventory)
+          apiConfig.inventory = { provider: inventoryProvider };
+        this.generatedCode.push(`const vrr = new VRRRuntime({`);
+        this.generatedCode.push(`  twin_id: '${twinId}',`);
+        this.generatedCode.push(`  geo_center: { lat: ${geoCenter.lat}, lng: ${geoCenter.lng} },`);
+        this.generatedCode.push(`  apis: ${JSON.stringify(apiConfig, null, 2)},`);
+        this.generatedCode.push(`  multiplayer: { enabled: true, max_players: 1000, tick_rate: 20 },`);
+        this.generatedCode.push(`  simulation_state: ${JSON.stringify(globalSimulationState)},`);
+        this.generatedCode.push(
+          `  state_persistence: { client: 'indexeddb', server: 'https://supabase.hololand.io' }`
+        );
+        this.generatedCode.push(`});`);
+        this.generatedCode.push(`
+const ${twinName} = new THREE.Group();`);
+        if (weatherProvider) {
+          this.generatedCode.push(`
+// Extracted @weather_sync hook`);
+          this.generatedCode.push(`vrr.syncWeather((weather) => {`);
+          this.generatedCode.push(`  scene.fog = new THREE.Fog(0xcccccc, 10, weather.visibility);`);
+          this.generatedCode.push(
+            `  if (weather.precipitation > 50) console.log("Heavy Rain Detected in Twin");`
+          );
+          this.generatedCode.push(`});`);
+        }
+        if (eventProvider) {
+          this.generatedCode.push(`
+// Extracted @event_sync hook`);
+          this.generatedCode.push(`vrr.syncEvents((events) => {`);
+          this.generatedCode.push(
+            `  events.forEach(evt => console.log('Spawning event NPCs for:', evt.name));`
+          );
+          this.generatedCode.push(`});`);
+        }
+        const questHubs = this.extractNodesWithTrait(twinNodes[0] || {}, "@quest_hub");
+        for (let i = 0; i < questHubs.length; i++) {
+          const hub = questHubs[i];
+          const questTrait = hub.traits?.find((t) => t.name === "quest_hub");
+          const quests = questTrait ? Array.isArray(questTrait.params.quests) ? questTrait.params.quests : [] : [];
+          this.generatedCode.push(`
+// Configured @quest_hub for ${hub.name || "Business"}`);
+          this.generatedCode.push(`const hub_${i} = {`);
+          this.generatedCode.push(`  quests: ${JSON.stringify(quests)}`);
+          this.generatedCode.push(`};`);
+          const inventory = hub.traits?.find((t) => t.name === "inventory_sync");
+          if (inventory) {
+            this.generatedCode.push(`vrr.syncInventory('${hub.name || "shop"}', (inv) => {`);
+            this.generatedCode.push(`  console.log('Stock updated:', inv);`);
+            this.generatedCode.push(`});`);
+          }
+        }
+        const paywalls = this.extractNodesWithTrait(twinNodes[0] || {}, "@x402_paywall");
+        for (const pw of paywalls) {
+          const trait = pw.traits?.find((t) => t.name === "x402_paywall");
+          if (!trait) continue;
+          this.generatedCode.push(
+            `
+// @x402_paywall requirement for ${this.escapeStringValue(String(pw.name || ""), "TypeScript")}`
+          );
+          this.generatedCode.push(
+            `vrr.persistState('paywall_${this.escapeStringValue(String(pw.name || ""), "TypeScript")}', ${JSON.stringify(trait.params)});`
+          );
+        }
+        this.generatedCode.push(`
+// Extracted Multiplayer logic`);
+        this.generatedCode.push(`vrr.syncPlayers((players) => {`);
+        this.generatedCode.push(`  // Render avatars in scene mapped to players.position`);
+        this.generatedCode.push(`});`);
+        return twinName;
+      }
+      buildResult() {
+        return {
+          success: this.errors.length === 0,
+          target: this.options.target,
+          code: this.generatedCode.join("\n"),
+          assets: [],
+          api_endpoints: [],
+          warnings: this.warnings,
+          errors: this.errors
+        };
+      }
+    };
+    VRRCompiler_default = VRRCompiler;
+  }
+});
+
+export { VRRCompiler, VRRCompiler_default, VRRCompiler_exports, init_VRRCompiler };
+//# sourceMappingURL=chunk-4SDKXQ4C.js.map
+//# sourceMappingURL=chunk-4SDKXQ4C.js.map