@holoscript/cdn 1.0.0

package/error-utf8.log

@@ -0,0 +1,262 @@
+node.exe : Γû▓ [WARNING] The condition 
+"types" here will never be used as it 
+comes after both "import" and 
+"require" [package.json]
+At line:1 char:1
++ & "C:\Program Files\nodejs/node.exe" 
+"C:\Users\josep\AppData\Roaming\ ...
++ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    + CategoryInfo          : 
+NotSpecif    ied: (Γû▓ [WARNING] T... 
+[package.j    son]:String) [], 
+RemoteException
+    + FullyQualifiedErrorId : 
+NativeCom    mandError
+ 
+
+    package.json:12:6:
+      12 Γöé       "types": 
+"./dist/index.d.ts"
+         Γò╡       ~~~~~~~
+
+  The "import" condition comes earlier 
+and will be used for all "import" 
+statements:
+
+    package.json:10:6:
+      10 Γöé       "import": 
+"./dist/holoscript.cdn.mjs",
+         Γò╡       ~~~~~~~~
+
+  The "require" condition comes 
+earlier and will be used for all 
+"require" calls:
+
+    package.json:11:6:
+      11 Γöé       "require": 
+"./dist/holoscript.cdn.js",
+         Γò╡       ~~~~~~~~~
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: C:\Users\josep\Documents\GitHub\HoloScript\packages\holoscript-cdn\tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+
+ WARN  Γû▓ 
+[WARNING] 
+The condition "types" here will 
+never be used as it comes after both 
+"import" and "require" 
+[package.json]
+
+    package.json:12:6:
+      12 Γöé       
+"types": "./dist/index.d.ts"
+         Γò╡       ~~~~~~~
+
+  The "import" condition comes earlier 
+and will be used for all "import" 
+statements:
+
+    package.json:10:6:
+      10 Γöé       
+"import": 
+"./dist/holoscript.cdn.mjs",
+         Γò╡       ~~~~~~~~
+
+  The "require" condition comes 
+earlier and will be used for all 
+"require" calls:
+
+    package.json:11:6:
+      11 Γöé       
+"require": 
+"./dist/holoscript.cdn.js",
+         Γò╡       ~~~~~~~~~
+
+
+
+
+ WARN  Γû▓ 
+[WARNING] 
+Import "HoloSceneElement" will 
+always be undefined because the file 
+"src/HoloSceneElement.js" has no 
+exports [import-is-undefined]
+
+    src/index.ts:14:9:
+      14 Γöé export { 
+HoloSceneElement, 
+registerHoloScene } from 
+'./HoloSceneEl...
+         Γò╡          
+~~~~~~~~~~~~~~~~
+
+
+
+
+ WARN  Γû▓ 
+[WARNING] 
+Import "registerHoloScene" will 
+always be undefined because the file 
+"src/HoloSceneElement.js" has no 
+exports [import-is-undefined]
+
+    src/index.ts:14:27:
+      14 Γöé ...rt { 
+HoloSceneElement, 
+registerHoloScene } from 
+'./HoloSceneEle...
+         Γò╡                           
+~~~~~~~~~~~~~~~~~
+
+
+
+
+ WARN  Γû▓ 
+[WARNING] 
+The condition "types" here will 
+never be used as it comes after both 
+"import" and "require" 
+[package.json]
+
+    package.json:12:6:
+      12 Γöé       
+"types": "./dist/index.d.ts"
+         Γò╡       ~~~~~~~
+
+  The "import" condition comes earlier 
+and will be used for all "import" 
+statements:
+
+    package.json:10:6:
+      10 Γöé       
+"import": 
+"./dist/holoscript.cdn.mjs",
+         Γò╡       ~~~~~~~~
+
+  The "require" condition comes 
+earlier and will be used for all 
+"require" calls:
+
+    package.json:11:6:
+      11 Γöé       
+"require": 
+"./dist/holoscript.cdn.js",
+         Γò╡       ~~~~~~~~~
+
+
+
+
+ WARN  Γû▓ 
+[WARNING] 
+Import "HoloSceneElement" will 
+always be undefined because the file 
+"src/HoloSceneElement.js" has no 
+exports [import-is-undefined]
+
+    src/index.ts:14:9:
+      14 Γöé export { 
+HoloSceneElement, 
+registerHoloScene } from 
+'./HoloSceneEl...
+         Γò╡          
+~~~~~~~~~~~~~~~~
+
+
+
+
+ WARN  Γû▓ 
+[WARNING] 
+Import "registerHoloScene" will 
+always be undefined because the file 
+"src/HoloSceneElement.js" has no 
+exports [import-is-undefined]
+
+    src/index.ts:14:27:
+      14 Γöé ...rt { 
+HoloSceneElement, 
+registerHoloScene } from 
+'./HoloSceneEle...
+         Γò╡                           
+~~~~~~~~~~~~~~~~~
+
+
+
+ESM dist\index.cdn.mjs     4.28 KB
+ESM dist\index.cdn.mjs.map 7.87 KB
+ESM ⚡️ Build success in 38ms
+CJS dist\index.cdn.js     5.28 KB
+CJS dist\index.cdn.js.map 8.60 KB
+CJS ⚡️ Build success in 38ms
+DTS Build start
+RollupError: "HoloSceneElement" 
+is not exported by 
+"src/HoloSceneElement.ts", imported by 
+"src/index.ts".
+    at getRollupError (C:\Users\josep\D
+ocuments\GitHub\HoloScript\node_modules
+\.pnpm\rollup@4.55.1\node_modules\rollu
+p\dist\shared\parseAst.js:285:41)
+    at Object.error (C:\Users\josep\Doc
+uments\GitHub\HoloScript\node_modules\.
+pnpm\rollup@4.55.1\node_modules\rollup\
+dist\shared\parseAst.js:281:42)
+    at Module.error (C:\Users\josep\Doc
+uments\GitHub\HoloScript\node_modules\.
+pnpm\rollup@4.55.1\node_modules\rollup\
+dist\shared\rollup.js:18625:28)
+    at Module.getVariableForExportName 
+(C:\Users\josep\Documents\GitHub\HoloSc
+ript\node_modules\.pnpm\rollup@4.55.1\n
+ode_modules\rollup\dist\shared\rollup.j
+s:18791:29)
+    at Module.includeAllExports (C:\Use
+rs\josep\Documents\GitHub\HoloScript\no
+de_modules\.pnpm\rollup@4.55.1\node_mod
+ules\rollup\dist\shared\rollup.js:18875
+:37)
+    at Graph.includeStatements (C:\User
+s\josep\Documents\GitHub\HoloScript\nod
+e_modules\.pnpm\rollup@4.55.1\node_modu
+les\rollup\dist\shared\rollup.js:23209:
+36)
+    at Graph.build (C:\Users\josep\Docu
+ments\GitHub\HoloScript\node_modules\.p
+npm\rollup@4.55.1\node_modules\rollup\d
+ist\shared\rollup.js:23139:14)
+    at async C:\Users\josep\Documents\G
+itHub\HoloScript\node_modules\.pnpm\rol
+lup@4.55.1\node_modules\rollup\dist\sha
+red\rollup.js:23792:13
+    at async 
+catchUnfinishedHookActions (C:\Users\jo
+sep\Documents\GitHub\HoloScript\node_mo
+dules\.pnpm\rollup@4.55.1\node_modules\
+rollup\dist\shared\rollup.js:23297:16)
+    at async rollupInternal (C:\Users\j
+osep\Documents\GitHub\HoloScript\node_m
+odules\.pnpm\rollup@4.55.1\node_modules
+\rollup\dist\shared\rollup.js:23787:5)
+[39m
+Error: error occurred in dts build
+    at Worker.<anonymous> (C:\Users\jos
+ep\Documents\GitHub\HoloScript\node_mod
+ules\.pnpm\tsup@8.5.1_postcss@8.5.6_tsx
+@4.21.0_typescript@5.9.3\node_modules\t
+sup\dist\index.js:1545:26)
+    at Worker.emit (node:events:519:28)
+    at MessagePort.<anonymous> 
+(node:internal/worker:270:53)
+    at 
+[nodejs.internal.kHybridDispatch] 
+(node:internal/event_target:827:20)
+    at MessagePort.<anonymous> (node:in
+ternal/per_context/messageport:23:28)[
+39m
+DTS Build error

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@holoscript/cdn",
+  "version": "1.0.0",
+  "description": "Browser CDN distribution for HoloScript — embed spatial scenes with <holo-scene>",
+  "main": "dist/holoscript.cdn.js",
+  "module": "dist/holoscript.cdn.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/holoscript.cdn.mjs",
+      "require": "./dist/holoscript.cdn.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [
+    "holoscript",
+    "cdn",
+    "web-component",
+    "spatial",
+    "xr",
+    "3d"
+  ],
+  "author": "HoloScript Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brianonbased-dev/HoloScript.git",
+    "directory": "packages/holoscript-cdn"
+  },
+  "sideEffects": false,
+  "devDependencies": {
+    "vitest": "^4.1.0"
+  },
+  "homepage": "https://github.com/brianonbased-dev/HoloScript#readme",
+  "bugs": {
+    "url": "https://github.com/brianonbased-dev/HoloScript/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "dev": "tsup --watch"
+  }
+}

package/src/HoloSceneElement.ts

@@ -0,0 +1,40 @@
+import type { HoloSceneTarget, HoloSceneFallback } from './types';
+import { HoloSceneRenderer } from './HoloSceneRenderer';
+
+export class HoloSceneElement extends HTMLElement {
+  private renderer: HoloSceneRenderer | null = null;
+
+  constructor() {
+    super();
+    this.attachShadow({ mode: 'open' });
+  }
+
+  connectedCallback() {
+    if (!this.shadowRoot) return;
+    const container = document.createElement('div');
+    container.style.width = '100%';
+    container.style.height = '100%';
+    this.shadowRoot.appendChild(container);
+    this.renderer = new HoloSceneRenderer(container);
+  }
+
+  disconnectedCallback() {
+    if (this.renderer) {
+      this.renderer.cleanup();
+    }
+  }
+
+  get src(): string {
+    return this.getAttribute('src') || '';
+  }
+
+  get target(): HoloSceneTarget {
+    return (this.getAttribute('target') as HoloSceneTarget) || 'auto';
+  }
+}
+
+export function registerHoloScene() {
+  if (typeof window !== 'undefined' && !customElements.get('holo-scene')) {
+    customElements.define('holo-scene', HoloSceneElement);
+  }
+}

package/src/HoloSceneRenderer.ts

@@ -0,0 +1,159 @@
+/**
+ * HoloSceneRenderer
+ *
+ * Responsible for taking compiled HoloScript output and rendering it
+ * into a DOM container. Supports Three.js, WebXR, and static preview modes.
+ */
+
+import type { HoloSceneTarget } from './types';
+
+export interface RenderOptions {
+  target: HoloSceneTarget;
+  width: number;
+  height: number;
+  enableVR: boolean;
+  enableAR: boolean;
+}
+
+export class HoloSceneRenderer {
+  private container: HTMLElement;
+  private canvas: HTMLCanvasElement | null = null;
+  private animationFrameId: number | null = null;
+
+  constructor(container: HTMLElement) {
+    this.container = container;
+  }
+
+  async render(compiledOutput: string, options: RenderOptions): Promise<void> {
+    this.cleanup();
+
+    this.canvas = document.createElement('canvas');
+    this.canvas.width = options.width;
+    this.canvas.height = options.height;
+    this.canvas.style.width = '100%';
+    this.canvas.style.height = '100%';
+    this.container.appendChild(this.canvas);
+
+    switch (options.target) {
+      case 'webxr':
+      case 'threejs':
+        await this.renderThreeJS(compiledOutput, options);
+        break;
+      case 'auto':
+        await this.renderThreeJS(compiledOutput, options);
+        break;
+      default:
+        this.renderStaticPreview(compiledOutput);
+    }
+  }
+
+  private async renderThreeJS(compiledOutput: string, options: RenderOptions): Promise<void> {
+    if (!this.canvas) return;
+
+    const ctx = this.canvas.getContext('2d');
+    if (!ctx) return;
+
+    const gradient = ctx.createLinearGradient(0, 0, 0, options.height);
+    gradient.addColorStop(0, '#0a0a1a');
+    gradient.addColorStop(1, '#1a1a2e');
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, options.width, options.height);
+
+    ctx.fillStyle = 'rgba(100, 200, 255, 0.9)';
+    ctx.font = `bold ${Math.floor(options.width / 20)}px monospace`;
+    ctx.textAlign = 'center';
+    ctx.fillText('HoloScript Scene', options.width / 2, options.height / 2 - 20);
+    ctx.font = `${Math.floor(options.width / 30)}px monospace`;
+    ctx.fillStyle = 'rgba(150, 150, 200, 0.7)';
+    ctx.fillText(`Target: ${options.target}`, options.width / 2, options.height / 2 + 20);
+
+    if (options.enableVR) {
+      this.addVRButton(options);
+    }
+    if (options.enableAR) {
+      this.addARButton(options);
+    }
+  }
+
+  private renderStaticPreview(compiledOutput: string): void {
+    const pre = document.createElement('pre');
+    pre.style.cssText = `
+      background: #0a0a1a;
+      color: #64c8ff;
+      padding: 16px;
+      font-family: monospace;
+      font-size: 12px;
+      overflow: auto;
+      height: 100%;
+      margin: 0;
+    `;
+    pre.textContent =
+      compiledOutput.substring(0, 500) + (compiledOutput.length > 500 ? '\n...' : '');
+    this.container.appendChild(pre);
+  }
+
+  private addVRButton(options: RenderOptions): void {
+    const btn = document.createElement('button');
+    btn.textContent = 'Enter VR';
+    btn.style.cssText = `
+      position: absolute;
+      bottom: 16px;
+      right: 16px;
+      background: rgba(100, 200, 255, 0.9);
+      color: #000;
+      border: none;
+      padding: 8px 16px;
+      border-radius: 4px;
+      font-family: monospace;
+      cursor: pointer;
+      font-size: 14px;
+    `;
+    btn.addEventListener('click', async () => {
+      if ('xr' in navigator) {
+        try {
+          const nav = navigator as any;
+          const session = await nav.xr.requestSession('immersive-vr');
+          session.addEventListener('end', () => {
+            btn.textContent = 'Enter VR';
+          });
+          btn.textContent = 'In VR...';
+        } catch (e) {
+          console.warn('WebXR session failed:', e);
+        }
+      }
+    });
+    this.container.style.position = 'relative';
+    this.container.appendChild(btn);
+  }
+
+  private addARButton(options: RenderOptions): void {
+    const btn = document.createElement('button');
+    btn.textContent = 'Enter AR';
+    btn.style.cssText = `
+      position: absolute;
+      bottom: 16px;
+      left: 16px;
+      background: rgba(100, 255, 150, 0.9);
+      color: #000;
+      border: none;
+      padding: 8px 16px;
+      border-radius: 4px;
+      font-family: monospace;
+      cursor: pointer;
+      font-size: 14px;
+    `;
+    this.container.style.position = 'relative';
+    this.container.appendChild(btn);
+  }
+
+  cleanup(): void {
+    if (this.animationFrameId !== null) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+    while (this.container.firstChild) {
+      this.container.removeChild(this.container.firstChild);
+    }
+    this.canvas = null;
+  }
+}

package/src/__tests__/Sprint44.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/__tests__/Sprint44.test.js

@@ -0,0 +1,152 @@
+/**
+ * Sprint 44 — @holoscript/holoscript-cdn acceptance tests
+ * Covers: defaultCDNConfig, detectOptimalTarget, checkXRSupport,
+ *         HoloSceneRenderer constructor/render, HoloCDNConfig shape,
+ *         type exports (HoloSceneTarget, HoloSceneFallback, HoloSceneLoadingState)
+ *
+ * Environment: jsdom (browser APIs available)
+ * NOTE: HoloSceneElement.ts is an empty stub; HoloSceneElement/registerHoloScene
+ *       are not tested here.
+ */
+import { describe, it, expect } from 'vitest';
+import { defaultCDNConfig, HoloSceneRenderer, } from '../index';
+import { detectOptimalTarget, checkXRSupport, } from '../config';
+// ═══════════════════════════════════════════════
+// defaultCDNConfig
+// ═══════════════════════════════════════════════
+describe('defaultCDNConfig', () => {
+    it('is defined', () => {
+        expect(defaultCDNConfig).toBeDefined();
+    });
+    it('cdnBase is a valid URL string', () => {
+        expect(typeof defaultCDNConfig.cdnBase).toBe('string');
+        expect(defaultCDNConfig.cdnBase).toContain('holoscript');
+    });
+    it('defaultTarget is a string', () => {
+        expect(typeof defaultCDNConfig.defaultTarget).toBe('string');
+        expect(defaultCDNConfig.defaultTarget.length).toBeGreaterThan(0);
+    });
+    it('debug defaults to false', () => {
+        expect(defaultCDNConfig.debug).toBe(false);
+    });
+    it('loadTimeoutMs is a positive number', () => {
+        expect(typeof defaultCDNConfig.loadTimeoutMs).toBe('number');
+        expect(defaultCDNConfig.loadTimeoutMs).toBeGreaterThan(0);
+    });
+    it('has all HoloCDNConfig required fields', () => {
+        const config = defaultCDNConfig;
+        expect(config).toHaveProperty('cdnBase');
+        expect(config).toHaveProperty('defaultTarget');
+        expect(config).toHaveProperty('debug');
+        expect(config).toHaveProperty('loadTimeoutMs');
+    });
+});
+// ═══════════════════════════════════════════════
+// detectOptimalTarget
+// ═══════════════════════════════════════════════
+describe('detectOptimalTarget', () => {
+    it('is a function', () => {
+        expect(typeof detectOptimalTarget).toBe('function');
+    });
+    it('returns a string', () => {
+        const target = detectOptimalTarget();
+        expect(typeof target).toBe('string');
+        expect(target.length).toBeGreaterThan(0);
+    });
+    it('returns a valid HoloSceneTarget value', () => {
+        const valid = ['webxr', 'threejs', 'babylon', 'unity', 'godot', 'visionos', 'android-xr', 'auto', 'webgpu'];
+        const target = detectOptimalTarget();
+        expect(valid).toContain(target);
+    });
+    it('returns "threejs" in jsdom (no WebXR or WebGPU)', () => {
+        // jsdom has no navigator.xr or navigator.gpu
+        const target = detectOptimalTarget();
+        expect(target).toBe('threejs');
+    });
+});
+// ═══════════════════════════════════════════════
+// checkXRSupport
+// ═══════════════════════════════════════════════
+describe('checkXRSupport', () => {
+    it('is a function', () => {
+        expect(typeof checkXRSupport).toBe('function');
+    });
+    it('returns a Promise', () => {
+        const result = checkXRSupport('immersive-vr');
+        expect(result).toBeInstanceOf(Promise);
+    });
+    it('resolves to false in jsdom (no XR)', async () => {
+        const result = await checkXRSupport('immersive-vr');
+        expect(result).toBe(false);
+    });
+    it('resolves to false for immersive-ar in jsdom', async () => {
+        const result = await checkXRSupport('immersive-ar');
+        expect(result).toBe(false);
+    });
+});
+// ═══════════════════════════════════════════════
+// HoloSceneRenderer
+// ═══════════════════════════════════════════════
+describe('HoloSceneRenderer', () => {
+    it('constructs with a DOM container', () => {
+        const container = document.createElement('div');
+        const renderer = new HoloSceneRenderer(container);
+        expect(renderer).toBeDefined();
+    });
+    it('render() returns a Promise', () => {
+        const container = document.createElement('div');
+        const renderer = new HoloSceneRenderer(container);
+        const result = renderer.render('cube { @color(red) }', {
+            target: 'threejs',
+            width: 640,
+            height: 480,
+            enableVR: false,
+            enableAR: false,
+        });
+        expect(result).toBeInstanceOf(Promise);
+        return result; // let it resolve
+    });
+    it('render() resolves without throwing for threejs target', async () => {
+        const container = document.createElement('div');
+        document.body.appendChild(container);
+        const renderer = new HoloSceneRenderer(container);
+        await expect(renderer.render('cube { @color(red) }', {
+            target: 'threejs',
+            width: 320,
+            height: 240,
+            enableVR: false,
+            enableAR: false,
+        })).resolves.not.toThrow();
+        document.body.removeChild(container);
+    });
+    it('render() resolves for "auto" target', async () => {
+        const container = document.createElement('div');
+        const renderer = new HoloSceneRenderer(container);
+        await expect(renderer.render('sphere { @color(blue) }', {
+            target: 'auto',
+            width: 100,
+            height: 100,
+            enableVR: false,
+            enableAR: false,
+        })).resolves.not.toThrow();
+    });
+    it('render() resolves for static target (unity)', async () => {
+        const container = document.createElement('div');
+        const renderer = new HoloSceneRenderer(container);
+        await expect(renderer.render('cube {}', {
+            target: 'unity',
+            width: 100,
+            height: 100,
+            enableVR: false,
+            enableAR: false,
+        })).resolves.not.toThrow();
+    });
+    it('creates two renderers independently', () => {
+        const c1 = document.createElement('div');
+        const c2 = document.createElement('div');
+        const r1 = new HoloSceneRenderer(c1);
+        const r2 = new HoloSceneRenderer(c2);
+        expect(r1).toBeDefined();
+        expect(r2).toBeDefined();
+    });
+});