@holoscript/core 6.0.3 → 6.1.1

package/dist/chunk-AIA52I7T.cjs

@@ -0,0 +1,543 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/compiler/platform/PlatformConditional.ts
+function platformCategory(target) {
+  for (const [cat, platforms] of Object.entries(exports.PLATFORM_CATEGORIES)) {
+    if (platforms.includes(target)) return cat;
+  }
+  return "desktop";
+}
+function resolvePlatforms(condition) {
+  let platforms = /* @__PURE__ */ new Set();
+  if (condition.include) {
+    for (const p of condition.include) platforms.add(p);
+  }
+  if (condition.includeCategories) {
+    for (const cat of condition.includeCategories) {
+      for (const p of exports.PLATFORM_CATEGORIES[cat]) platforms.add(p);
+    }
+  }
+  if (!condition.include && !condition.includeCategories) {
+    for (const p of exports.ALL_PLATFORMS) platforms.add(p);
+  }
+  if (condition.exclude) {
+    for (const p of condition.exclude) platforms.delete(p);
+  }
+  if (condition.requireCapabilities) {
+    platforms = new Set(
+      [...platforms].filter((p) => {
+        const caps = exports.PLATFORM_CAPABILITIES[p];
+        return condition.requireCapabilities.every((cap) => {
+          const val = caps[cap];
+          return typeof val === "boolean" ? val : Number(val) > 0;
+        });
+      })
+    );
+  }
+  return [...platforms];
+}
+function matchesPlatform(target, condition) {
+  return resolvePlatforms(condition).includes(target);
+}
+function selectBlock(target, blocks) {
+  for (const block of blocks) {
+    if (matchesPlatform(target, block.condition)) return block.body;
+  }
+  return void 0;
+}
+function embodimentFor(target) {
+  return exports.DEFAULT_EMBODIMENT[platformCategory(target)];
+}
+function agentBudgetFor(target) {
+  return exports.PLATFORM_CAPABILITIES[target].agentBudgetMs;
+}
+function hasCapability(target, cap) {
+  const val = exports.PLATFORM_CAPABILITIES[target][cap];
+  return typeof val === "boolean" ? val : Number(val) > 0;
+}
+exports.PLATFORM_CATEGORIES = void 0; exports.ALL_PLATFORMS = void 0; exports.PLATFORM_CAPABILITIES = void 0; exports.DEFAULT_EMBODIMENT = void 0;
+var init_PlatformConditional = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/platform/PlatformConditional.ts"() {
+    exports.PLATFORM_CATEGORIES = {
+      vr: ["quest3", "pcvr", "visionos", "android-xr"],
+      ar: ["visionos-ar", "android-xr-ar", "webxr"],
+      mobile: ["ios", "android"],
+      desktop: ["windows", "macos", "linux", "web"],
+      automotive: ["android-auto", "carplay"],
+      wearable: ["watchos", "wearos"]
+    };
+    exports.ALL_PLATFORMS = Object.values(
+      exports.PLATFORM_CATEGORIES
+    ).flat();
+    exports.PLATFORM_CAPABILITIES = {
+      quest3: {
+        spatialTracking: true,
+        handTracking: true,
+        eyeTracking: true,
+        haptics: true,
+        spatialAudio: true,
+        gpu3D: true,
+        arCamera: true,
+        gps: false,
+        npu: true,
+        webxrSupport: true,
+        frameBudgetMs: 11.1,
+        agentBudgetMs: 5,
+        computeModel: "edge-first"
+      },
+      pcvr: {
+        spatialTracking: true,
+        handTracking: true,
+        eyeTracking: true,
+        haptics: true,
+        spatialAudio: true,
+        gpu3D: true,
+        arCamera: false,
+        gps: false,
+        npu: false,
+        webxrSupport: true,
+        frameBudgetMs: 11.1,
+        agentBudgetMs: 5,
+        computeModel: "edge-first"
+      },
+      visionos: {
+        spatialTracking: true,
+        handTracking: true,
+        eyeTracking: true,
+        haptics: false,
+        spatialAudio: true,
+        gpu3D: true,
+        arCamera: true,
+        gps: false,
+        npu: true,
+        webxrSupport: false,
+        frameBudgetMs: 11.1,
+        agentBudgetMs: 5,
+        computeModel: "edge-first"
+      },
+      "android-xr": {
+        spatialTracking: true,
+        handTracking: true,
+        eyeTracking: true,
+        haptics: true,
+        spatialAudio: true,
+        gpu3D: true,
+        arCamera: true,
+        gps: true,
+        npu: true,
+        webxrSupport: true,
+        frameBudgetMs: 11.1,
+        agentBudgetMs: 5,
+        computeModel: "edge-first"
+      },
+      "visionos-ar": {
+        spatialTracking: true,
+        handTracking: true,
+        eyeTracking: true,
+        haptics: false,
+        spatialAudio: true,
+        gpu3D: true,
+        arCamera: true,
+        gps: true,
+        npu: true,
+        webxrSupport: false,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 10,
+        computeModel: "edge-first"
+      },
+      "android-xr-ar": {
+        spatialTracking: true,
+        handTracking: true,
+        eyeTracking: false,
+        haptics: true,
+        spatialAudio: true,
+        gpu3D: true,
+        arCamera: true,
+        gps: true,
+        npu: true,
+        webxrSupport: true,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 10,
+        computeModel: "edge-first"
+      },
+      webxr: {
+        spatialTracking: true,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: false,
+        spatialAudio: false,
+        gpu3D: true,
+        arCamera: true,
+        gps: false,
+        npu: false,
+        webxrSupport: true,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 15,
+        computeModel: "cloud-first"
+      },
+      ios: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: true,
+        spatialAudio: false,
+        gpu3D: true,
+        arCamera: true,
+        gps: true,
+        npu: true,
+        webxrSupport: false,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 100,
+        computeModel: "cloud-first"
+      },
+      android: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: true,
+        spatialAudio: false,
+        gpu3D: true,
+        arCamera: true,
+        gps: true,
+        npu: true,
+        webxrSupport: true,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 100,
+        computeModel: "cloud-first"
+      },
+      windows: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: false,
+        spatialAudio: false,
+        gpu3D: true,
+        arCamera: false,
+        gps: false,
+        npu: false,
+        webxrSupport: true,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 200,
+        computeModel: "cloud-first"
+      },
+      macos: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: false,
+        spatialAudio: false,
+        gpu3D: true,
+        arCamera: false,
+        gps: false,
+        npu: true,
+        webxrSupport: true,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 200,
+        computeModel: "cloud-first"
+      },
+      linux: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: false,
+        spatialAudio: false,
+        gpu3D: true,
+        arCamera: false,
+        gps: false,
+        npu: false,
+        webxrSupport: true,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 200,
+        computeModel: "cloud-first"
+      },
+      web: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: false,
+        spatialAudio: false,
+        gpu3D: true,
+        arCamera: false,
+        gps: false,
+        npu: false,
+        webxrSupport: true,
+        frameBudgetMs: 16.6,
+        agentBudgetMs: 200,
+        computeModel: "cloud-first"
+      },
+      "android-auto": {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: false,
+        spatialAudio: true,
+        gpu3D: false,
+        arCamera: false,
+        gps: true,
+        npu: false,
+        webxrSupport: false,
+        frameBudgetMs: 30,
+        agentBudgetMs: 15,
+        computeModel: "safety-critical"
+      },
+      carplay: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: false,
+        spatialAudio: true,
+        gpu3D: false,
+        arCamera: false,
+        gps: true,
+        npu: false,
+        webxrSupport: false,
+        frameBudgetMs: 30,
+        agentBudgetMs: 15,
+        computeModel: "safety-critical"
+      },
+      watchos: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: true,
+        spatialAudio: false,
+        gpu3D: false,
+        arCamera: false,
+        gps: true,
+        npu: true,
+        webxrSupport: false,
+        frameBudgetMs: 33.3,
+        agentBudgetMs: 50,
+        computeModel: "cloud-first"
+      },
+      wearos: {
+        spatialTracking: false,
+        handTracking: false,
+        eyeTracking: false,
+        haptics: true,
+        spatialAudio: false,
+        gpu3D: false,
+        arCamera: false,
+        gps: true,
+        npu: false,
+        webxrSupport: false,
+        frameBudgetMs: 33.3,
+        agentBudgetMs: 50,
+        computeModel: "cloud-first"
+      }
+    };
+    exports.DEFAULT_EMBODIMENT = {
+      vr: "Avatar3D",
+      ar: "SpatialPersona",
+      mobile: "UI2D",
+      desktop: "FullGUI",
+      automotive: "VoiceHUD",
+      wearable: "UI2D"
+    };
+  }
+});
+
+// src/compiler/PlatformConditionalCompilerMixin.ts
+function createPlatformTarget(platform) {
+  const normalized = normalizePlatformName(platform);
+  return {
+    platform: normalized,
+    formFactor: platformCategory(normalized)
+  };
+}
+function normalizePlatformName(name) {
+  const normalized = name.trim().toLowerCase();
+  return PLATFORM_ALIASES[normalized] ?? normalized;
+}
+function expandPlatformNames(names) {
+  const expanded = [];
+  for (const rawName of names) {
+    const name = normalizePlatformName(rawName);
+    if (name in exports.PLATFORM_CATEGORIES) {
+      expanded.push(...exports.PLATFORM_CATEGORIES[name]);
+    } else {
+      expanded.push(name);
+    }
+  }
+  return expanded;
+}
+function matchesPlatformConstraint(constraint, target) {
+  if (!constraint) return true;
+  const targetPlatform = target.platform;
+  const targetCategory = target.formFactor;
+  if (constraint.exclude.length > 0) {
+    const expandedExcludes = expandPlatformNames(constraint.exclude);
+    if (expandedExcludes.includes(targetPlatform) || expandedExcludes.includes(targetCategory)) {
+      return false;
+    }
+  }
+  if (constraint.include.length > 0) {
+    const expandedIncludes = expandPlatformNames(constraint.include);
+    if (expandedIncludes.includes(targetPlatform) || expandedIncludes.includes(targetCategory)) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+function isValidPlatformName(name) {
+  return VALID_PLATFORM_NAMES.has(normalizePlatformName(name));
+}
+function validatePlatformConstraints(composition) {
+  const errors = [];
+  const check = (constraint, context) => {
+    if (!constraint) return;
+    if (constraint.include.length === 0 && constraint.exclude.length === 0) {
+      errors.push(
+        `${context}: Empty @platform() constraint \u2014 specify at least one platform or category`
+      );
+    }
+    for (const name of constraint.include) {
+      if (!isValidPlatformName(name)) {
+        errors.push(
+          `${context}: Unknown platform '${name}' in @platform() \u2014 not a recognized platform or category`
+        );
+      }
+    }
+    for (const name of constraint.exclude) {
+      if (!isValidPlatformName(name)) {
+        errors.push(
+          `${context}: Unknown platform '${name}' in @platform(not: ...) \u2014 not a recognized platform or category`
+        );
+      }
+    }
+  };
+  const checkObject = (obj, contextPrefix = "object") => {
+    check(obj.platformConstraint, `${contextPrefix} "${obj.name}"`);
+    for (const trait of obj.traits || []) {
+      check(trait.platformConstraint, `trait "@${trait.name}" on ${contextPrefix} "${obj.name}"`);
+    }
+    for (const child of obj.children || []) {
+      checkObject(child, `child object of ${obj.name}`);
+    }
+  };
+  const checkGroup = (grp) => {
+    check(grp.platformConstraint, `spatial group "${grp.name}"`);
+    for (const obj of grp.objects || []) {
+      checkObject(obj, `object in spatial group "${grp.name}"`);
+    }
+    for (const childGroup of grp.groups || []) {
+      checkGroup(childGroup);
+    }
+  };
+  for (const obj of composition.objects || []) checkObject(obj);
+  for (const tmpl of composition.templates || []) check(tmpl.platformConstraint, `template "${tmpl.name}"`);
+  for (const tmpl of composition.templates || []) {
+    for (const trait of tmpl.traits || []) {
+      check(trait.platformConstraint, `trait "@${trait.name}" on template "${tmpl.name}"`);
+    }
+  }
+  for (const norm of composition.norms || []) check(norm.platformConstraint, `norm "${norm.name}"`);
+  for (const grp of composition.spatialGroups || []) checkGroup(grp);
+  for (const light of composition.lights || []) check(light.platformConstraint, `light "${light.name}"`);
+  return errors;
+}
+function filterCompositionForPlatform(composition, platform) {
+  const errors = validatePlatformConstraints(composition);
+  if (errors.length > 0) {
+    throw new Error(`Invalid @platform() constraints:
+${errors.join("\n")}`);
+  }
+  const normalized = normalizePlatformName(platform);
+  return new exports.PlatformConditionalCompilerMixin().filterForPlatform(
+    composition,
+    createPlatformTarget(normalized)
+  );
+}
+var PLATFORM_ALIASES; exports.PlatformConditionalCompilerMixin = void 0; var VALID_PLATFORM_NAMES;
+var init_PlatformConditionalCompilerMixin = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/PlatformConditionalCompilerMixin.ts"() {
+    init_PlatformConditional();
+    PLATFORM_ALIASES = {
+      phone: "mobile",
+      car: "automotive",
+      androidxr: "android-xr",
+      android_xr: "android-xr",
+      visionosar: "visionos-ar",
+      visionos_ar: "visionos-ar",
+      androidxrar: "android-xr-ar",
+      android_xr_ar: "android-xr-ar"
+    };
+    exports.PlatformConditionalCompilerMixin = class {
+      /**
+       * Filter a composition's blocks based on the target platform.
+       * Returns a new HoloComposition with non-matching blocks removed.
+       *
+       * Blocks without a `@platform()` constraint are always included.
+       */
+      filterForPlatform(composition, target) {
+        return {
+          ...composition,
+          objects: this.filterObjects(composition.objects || [], target),
+          templates: this.filterTemplates(composition.templates || [], target),
+          spatialGroups: this.filterSpatialGroups(composition.spatialGroups || [], target),
+          lights: this.filterBlocks(composition.lights || [], target),
+          norms: composition.norms ? this.filterBlocks(composition.norms, target) : void 0
+        };
+      }
+      /**
+       * Check if a platform constraint matches a target.
+       */
+      matchesPlatform(constraint, target) {
+        return matchesPlatformConstraint(constraint, target);
+      }
+      /**
+       * Generic filter for arrays of blocks that have an optional platformConstraint.
+       */
+      filterBlocks(blocks, target) {
+        return blocks.filter((block) => matchesPlatformConstraint(block.platformConstraint, target));
+      }
+      filterTraits(traits, target) {
+        return this.filterBlocks(traits || [], target);
+      }
+      filterObjects(objects, target) {
+        return this.filterBlocks(objects || [], target).map((obj) => ({
+          ...obj,
+          traits: this.filterTraits(obj.traits, target),
+          children: obj.children ? this.filterObjects(obj.children, target) : obj.children
+        }));
+      }
+      filterTemplates(templates, target) {
+        return this.filterBlocks(templates || [], target).map((template) => ({
+          ...template,
+          traits: this.filterTraits(template.traits, target)
+        }));
+      }
+      filterSpatialGroups(groups, target) {
+        return this.filterBlocks(groups || [], target).map((group) => ({
+          ...group,
+          objects: this.filterObjects(group.objects, target),
+          groups: group.groups ? this.filterSpatialGroups(group.groups, target) : group.groups
+        }));
+      }
+    };
+    VALID_PLATFORM_NAMES = /* @__PURE__ */ new Set([
+      ...exports.ALL_PLATFORMS,
+      ...Object.keys(exports.PLATFORM_CATEGORIES),
+      ...Object.keys(PLATFORM_ALIASES)
+    ]);
+  }
+});
+
+exports.agentBudgetFor = agentBudgetFor;
+exports.createPlatformTarget = createPlatformTarget;
+exports.embodimentFor = embodimentFor;
+exports.filterCompositionForPlatform = filterCompositionForPlatform;
+exports.hasCapability = hasCapability;
+exports.init_PlatformConditional = init_PlatformConditional;
+exports.init_PlatformConditionalCompilerMixin = init_PlatformConditionalCompilerMixin;
+exports.matchesPlatform = matchesPlatform;
+exports.matchesPlatformConstraint = matchesPlatformConstraint;
+exports.normalizePlatformName = normalizePlatformName;
+exports.platformCategory = platformCategory;
+exports.resolvePlatforms = resolvePlatforms;
+exports.selectBlock = selectBlock;
+//# sourceMappingURL=chunk-AIA52I7T.cjs.map
+//# sourceMappingURL=chunk-AIA52I7T.cjs.map