@vgai/engine 0.5.11 → 0.5.13

package/src/pixi/ingest-iframe.ts

@@ -1,255 +0,0 @@
-/**
- * Pixi iframe ingest tiers — the PixiJS analogs of the 3D ingest-iframe adapters.
- *
- *  - OPAQUE EMBED (tier 0-1): a prebuilt/self-contained bundle runs in a sandboxed
- *    iframe; hosted + sized + disposed, NOT introspectable.
- *  - IFRAME-REACHABLE (tier 2-3): a bundle runs in its own iframe realm, but its
- *    `import 'pixi.js'` is wired (via an importmap) to a blob module re-exporting the
- *    HOST's pixi instance, so every Application/Sprite it creates is a HOST-realm
- *    object → the host `Application.prototype.render` trap fires and capture works.
- */
-import {
-  type CapturedRuntime2D,
-  installSceneCapture2D,
-  type SceneCapture2DHandle,
-} from './scene-capture';
-
-export interface EmbedMount2D {
-  iframe: HTMLIFrameElement;
-  dispose: () => void;
-}
-
-/** OPAQUE EMBED: sandboxed iframe, no scene introspection (tier 0-1). */
-export function mountIngestGame2DEmbed(html: string, container: HTMLElement): EmbedMount2D {
-  const iframe = document.createElement('iframe');
-  iframe.setAttribute('sandbox', 'allow-scripts');
-  iframe.style.border = '0';
-  iframe.style.width = '100%';
-  iframe.style.height = '100%';
-  iframe.srcdoc = html;
-  container.appendChild(iframe);
-  return { iframe, dispose: () => iframe.remove() };
-}
-
-const HOST_PIXI_KEY = '__vgaiHostPixi';
-
-/** Build a blob module that re-exports the host's pixi namespace (for the importmap). */
-function makeHostPixiReexportUrl(pixiNamespace: Record<string, unknown>): string {
-  (window as unknown as Record<string, unknown>)[HOST_PIXI_KEY] = pixiNamespace;
-  const ident = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-  const keys = Object.keys(pixiNamespace).filter((k) => k !== 'default' && ident.test(k));
-  const body =
-    `const T = window.parent[${JSON.stringify(HOST_PIXI_KEY)}];\n` +
-    `export default T;\n` +
-    keys.map((k) => `export const ${k} = T[${JSON.stringify(k)}];`).join('\n');
-  return URL.createObjectURL(new Blob([body], { type: 'text/javascript' }));
-}
-
-let _reexportKeySeq = 0;
-
-/**
- * Generalized host-namespace re-export (the multi-dep analog of {@link makeHostPixiReexportUrl}).
- * Stashes `ns` (an ES module namespace object, e.g. `import * as ns from 'gsap'`) on a unique
- * window key and builds a blob module re-exporting it, so the iframe's importmap can map a bare
- * specifier (pixi.js, @pixi/sound, @pixi/ui, gsap, …) to the HOST's single instance. Default-export
- * handling: `export default T.default ?? T` so `import gsap from 'gsap'` gets gsap, while a
- * default-less namespace (pixi.js) re-exports the namespace itself for `import * as`.
- */
-function makeHostNamespaceReexportUrl(ns: Record<string, unknown>): string {
-  const key = `__vgaiHostNs_${_reexportKeySeq++}`;
-  (window as unknown as Record<string, unknown>)[key] = ns;
-  const ident = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-  const keys = Object.keys(ns).filter((k) => k !== 'default' && ident.test(k));
-  const body =
-    `const T = window.parent[${JSON.stringify(key)}];\n` +
-    `export default (T && T.default !== undefined ? T.default : T);\n` +
-    keys.map((k) => `export const ${k} = T[${JSON.stringify(k)}];`).join('\n');
-  return URL.createObjectURL(new Blob([body], { type: 'text/javascript' }));
-}
-
-export interface IframeReachableMultiOpts {
-  captureTimeoutMs?: number;
-  /**
-   * Bare-specifier → host module-namespace map. MUST include the pixi.js instance the trap is
-   * installed on (passed separately as `pixiNamespace`); list the game's OTHER shared bare deps
-   * here (@pixi/sound, @pixi/ui, gsap, pixi-filters) so they resolve to host instances and their
-   * extension side-effects register on the host pixi (the trapped instance).
-   */
-  extraDeps?: Record<string, Record<string, unknown>>;
-  /**
-   * Bare-specifier -> VERBATIM URL importmap entries (the
-   * project-node_modules fallback for a specifier that isn't in the
-   * host-namespace registry but IS installed in the open project's own
-   * `node_modules`). Written into the importmap DIRECTLY alongside the
-   * `extraDeps` blob-namespace entries — no host-side import, no blob
-   * wrapping, no decision logic here: this function just merges whatever
-   * `Record<specifier, url>` the caller (editor-side
-   * `host-namespace-registry.ts`) already decided. The URL's own transitive
-   * `import 'pixi.js'` resolves through this SAME importmap back to the host
-   * pixi trap (§0.3), keeping module identity converged without a second pixi
-   * instance.
-   */
-  extraDepUrls?: Record<string, string>;
-  /** <base href> for the iframe so the game's relative asset URLs (Assets basePath) resolve. */
-  baseHref?: string;
-  /**
-   * HOST-SIDE asset URL remap (the Pixi analog of the three.js DefaultLoadingManager.setURLModifier
-   * asset adapter). A document.write iframe keeps the PARENT's window.location, so PixiJS's Assets
-   * resolver (which builds absolute URLs from window.location, not document.baseURI) would resolve
-   * the game's relative `basePath:'assets'` against the parent page. Wrapping the host pixi's
-   * Assets.init to force this ABSOLUTE basePath fixes resolution without touching the game source —
-   * pure host library configuration, restored on dispose.
-   */
-  assetBaseUrl?: string;
-  /** Load the game bundle from this absolute URL (a built multi-file game). */
-  bundleUrl?: string;
-  /** …or run this inline module source (a single-file game). One of bundleUrl/inlineSrc required. */
-  inlineSrc?: string;
-  /** DOM the game expects to find before it boots (e.g. a `<div id="game-root">` it appends to). */
-  bodyHtml?: string;
-}
-
-/**
- * IFRAME-REACHABLE for REAL MULTI-FILE GAMES (cov2d-bundled-dedupe): run a built game bundle
- * (its OWN unaltered source, externalized against pixi at build time) in its own iframe realm
- * whose importmap maps EVERY shared bare dep — pixi.js + @pixi/sound/@pixi/ui/gsap/… — to the
- * HOST instances, and (optionally) a <base href> so its AssetPack/manifest URLs resolve. The
- * host `Application.prototype.render` trap then captures the live stage IN-REALM. The game's
- * source is never touched; all of this is host-side wiring.
- */
-export async function mountIngestGame2DIframeReachableMulti(
-  pixiNamespace: unknown,
-  container: HTMLElement,
-  opts: IframeReachableMultiOpts,
-): Promise<IframeReachableMount2D> {
-  const capture = installSceneCapture2D(pixiNamespace);
-  const created: string[] = [];
-  const mkUrl = (ns: Record<string, unknown>): string => {
-    const u = makeHostNamespaceReexportUrl(ns);
-    created.push(u);
-    return u;
-  };
-
-  const imports: Record<string, string> = {
-    'pixi.js': mkUrl(pixiNamespace as Record<string, unknown>),
-  };
-  for (const [spec, ns] of Object.entries(opts.extraDeps ?? {})) imports[spec] = mkUrl(ns);
-  // D-Z3 fallback: verbatim URL entries, no blob wrapping, merged in beside
-  // the host-namespace ones — decision-free (see `extraDepUrls`'s doc comment).
-  for (const [spec, url] of Object.entries(opts.extraDepUrls ?? {})) imports[spec] = url;
-
-  // Host-side asset URL remap (asset adapter): force the game's Assets.init basePath to an
-  // absolute URL so its assets resolve to the served bundle dir, not the parent page path.
-  let restoreInit: (() => void) | undefined;
-  if (opts.assetBaseUrl) {
-    const assetsApi = (
-      pixiNamespace as { Assets?: { init?: (o?: Record<string, unknown>) => unknown } }
-    ).Assets;
-    if (assetsApi?.init) {
-      const orig = assetsApi.init.bind(assetsApi);
-      assetsApi.init = (o: Record<string, unknown> = {}) =>
-        orig({ ...o, basePath: opts.assetBaseUrl });
-      restoreInit = () => {
-        assetsApi.init = orig;
-      };
-    }
-  }
-
-  const iframe = document.createElement('iframe');
-  iframe.style.border = '0';
-  iframe.style.width = '100%';
-  iframe.style.height = '100%';
-  container.appendChild(iframe);
-
-  // Split the closing script token so this module's own bundling never sees a literal
-  // </script> (defensive; matches the single-dep mount's convention).
-  const close = `</${'scr'}ipt>`;
-  const baseTag = opts.baseHref ? `<base href="${opts.baseHref}">` : '';
-  const scriptTag = opts.bundleUrl
-    ? `<script type="module" src="${opts.bundleUrl}">${close}`
-    : `<script type="module">${opts.inlineSrc ?? ''}${close}`;
-  const importmapTag = `<script type="importmap">${JSON.stringify({ imports })}${close}`;
-  const bodyHtml = opts.bodyHtml ?? '';
-
-  const doc = iframe.contentDocument!;
-  doc.open();
-  doc.write(
-    `<!doctype html><html><head><meta charset="utf-8">${baseTag}${importmapTag}</head><body>${bodyHtml}${scriptTag}</body></html>`,
-  );
-  doc.close();
-
-  let captured: CapturedRuntime2D | null = null;
-  try {
-    captured = await capture.waitForCapture(opts.captureTimeoutMs ?? 12_000);
-  } catch {
-    captured = null;
-  }
-
-  return {
-    iframe,
-    capture,
-    captured,
-    dispose: () => {
-      capture.uninstall();
-      restoreInit?.();
-      for (const u of created) URL.revokeObjectURL(u);
-      iframe.remove();
-    },
-  };
-}
-
-export interface IframeReachableMount2D {
-  iframe: HTMLIFrameElement;
-  capture: SceneCapture2DHandle;
-  captured: CapturedRuntime2D | null;
-  dispose: () => void;
-}
-
-/**
- * IFRAME-REACHABLE (tier 2-3): run `gameModuleSrc` in an iframe whose importmap maps
- * `pixi.js` to a host-pixi re-export blob, and trap the host `Application.prototype`
- * so the bundle's render is captured in-realm.
- */
-export async function mountIngestGame2DIframeReachable(
-  pixiNamespace: unknown,
-  gameModuleSrc: string,
-  container: HTMLElement,
-  opts: { captureTimeoutMs?: number } = {},
-): Promise<IframeReachableMount2D> {
-  const capture = installSceneCapture2D(pixiNamespace);
-  const reexportUrl = makeHostPixiReexportUrl(pixiNamespace as Record<string, unknown>);
-
-  const iframe = document.createElement('iframe');
-  iframe.style.border = '0';
-  iframe.style.width = '100%';
-  iframe.style.height = '100%';
-  container.appendChild(iframe);
-
-  const doc = iframe.contentDocument!;
-  doc.open();
-  doc.write(
-    `<!doctype html><html><head><meta charset="utf-8">` +
-      `<script type="importmap">${JSON.stringify({ imports: { 'pixi.js': reexportUrl } })}</scr` +
-      `ipt></head><body><script type="module">${gameModuleSrc}</scr` +
-      `ipt></body></html>`,
-  );
-  doc.close();
-
-  let captured: CapturedRuntime2D | null = null;
-  try {
-    captured = await capture.waitForCapture(opts.captureTimeoutMs ?? 8000);
-  } catch {
-    captured = null;
-  }
-
-  return {
-    iframe,
-    capture,
-    captured,
-    dispose: () => {
-      capture.uninstall();
-      URL.revokeObjectURL(reexportUrl);
-      iframe.remove();
-    },
-  };
-}

package/src/render/instance-mesh.ts

@@ -1,25 +0,0 @@
-import * as THREE from 'three';
-import type { InstancesFile } from '../asset-formats/instances';
-
-/** Build one native InstancedMesh from a parsed `.instances.json` tuple array. */
-export function buildInstancedMeshFromTuples(
-  geometry: THREE.BufferGeometry,
-  material: THREE.Material,
-  tuples: InstancesFile,
-): THREE.InstancedMesh {
-  const mesh = new THREE.InstancedMesh(geometry, material, tuples.length);
-  const position = new THREE.Vector3();
-  const quaternion = new THREE.Quaternion();
-  const scale = new THREE.Vector3();
-  const matrix = new THREE.Matrix4();
-  for (let index = 0; index < tuples.length; index += 1) {
-    const tuple = tuples[index]!;
-    position.set(tuple[0], tuple[1], tuple[2]);
-    quaternion.set(tuple[3], tuple[4], tuple[5], tuple[6]);
-    scale.set(tuple[7], tuple[8], tuple[9]);
-    matrix.compose(position, quaternion, scale);
-    mesh.setMatrixAt(index, matrix);
-  }
-  mesh.instanceMatrix.needsUpdate = true;
-  return mesh;
-}