@babylonjs/lite-compat 0.0.1-preview.54961

package/navigation.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { createNavigationPluginAsync, updateNavCrowd, getAgentPosition, addAgent, agentGoto, createNavMesh, addCylinderObstacle, addBoxObstacle, removeObstacle, updateNavMeshObstacles, createDebugNavMeshGeometry, createMeshFromData, addToScene, getClosestPoint, computePath, raycast, createNavCrowd } from "@babylonjs/lite";
+import { V as Vector3, a as Mesh } from "./meshes-BQZyNGmT.js";
+class RecastJSCrowd {
+  constructor(lite, plugin, scene) {
+    /** @internal */
+    __publicField(this, "_lite");
+    __publicField(this, "_transforms", /* @__PURE__ */ new Map());
+    __publicField(this, "_plugin");
+    this._lite = lite;
+    this._plugin = plugin;
+    scene.onBeforeRenderObservable.add(() => {
+      updateNavCrowd(this._lite, 1 / 60 * this._plugin.timeFactor);
+      for (const [index, transform] of this._transforms) {
+        const p = getAgentPosition(this._lite, index);
+        transform.position.set(p.x, p.y, p.z);
+      }
+    });
+  }
+  /** Babylon.js `crowd.addAgent(pos, parameters, transform)` — returns the agent index. */
+  addAgent(pos, parameters, transform) {
+    const index = addAgent(this._lite, { x: pos.x, y: pos.y, z: pos.z }, parameters);
+    this._transforms.set(index, transform);
+    return index;
+  }
+  /** Babylon.js `crowd.getAgentPosition(index)`. */
+  getAgentPosition(index) {
+    const p = getAgentPosition(this._lite, index);
+    return new Vector3(p.x, p.y, p.z);
+  }
+  /** Babylon.js `crowd.agentGoto(index, destination)` — request the agent to move toward a target. */
+  agentGoto(index, destination) {
+    agentGoto(this._lite, index, { x: destination.x, y: destination.y, z: destination.z });
+  }
+}
+class RecastNavigationJSPluginV2 {
+  constructor(lite) {
+    /** @internal */
+    __publicField(this, "_lite");
+    /**
+     * Babylon.js `plugin.timeFactor` — multiplier applied to each crowd update step.
+     * `0` pauses crowd movement (used by parity tests); default `1`.
+     */
+    __publicField(this, "timeFactor", 1);
+    this._lite = lite;
+  }
+  /**
+   * Babylon.js `plugin.createNavMesh(meshes, parameters)`. Returns a
+   * `{ navMesh, tileCache }` handle (both reference this plugin) so scenes using
+   * the tile-cache obstacle API can pass them to {@link WaitForFullTileCacheUpdate}.
+   * Scenes that ignore the return (the non-obstacle navmesh scenes) are unaffected.
+   */
+  createNavMesh(meshes, parameters) {
+    createNavMesh(
+      this._lite,
+      meshes.map((m) => m._lite),
+      parameters
+    );
+    return { navMesh: this, tileCache: this };
+  }
+  /** Babylon.js `plugin.addCylinderObstacle(position, radius, height)` — tile-cache obstacle. */
+  addCylinderObstacle(position, radius, height) {
+    return addCylinderObstacle(this._lite, { x: position.x, y: position.y, z: position.z }, radius, height);
+  }
+  /** Babylon.js `plugin.addBoxObstacle(position, extent, angle)` — tile-cache obstacle (`extent` = half-extents). */
+  addBoxObstacle(position, extent, angle) {
+    return addBoxObstacle(this._lite, { x: position.x, y: position.y, z: position.z }, { x: extent.x, y: extent.y, z: extent.z }, angle);
+  }
+  /** Babylon.js `plugin.removeObstacle(obstacle)` — remove a previously-added tile-cache obstacle. */
+  removeObstacle(obstacle) {
+    removeObstacle(this._lite, obstacle);
+  }
+  /** @internal Apply pending tile-cache obstacle updates (drives {@link WaitForFullTileCacheUpdate}). */
+  _updateObstacles() {
+    updateNavMeshObstacles(this._lite);
+  }
+  /** Babylon.js `plugin.createDebugNavMesh(scene)` — builds a renderable debug mesh. */
+  createDebugNavMesh(scene) {
+    const geo = createDebugNavMeshGeometry(this._lite);
+    const engine = scene.getEngine()._lite;
+    const lite = createMeshFromData(engine, "navDebugMesh", geo.positions, geo.normals, geo.indices);
+    const mesh = new Mesh("navDebugMesh", lite, scene);
+    scene._deferAdd(() => {
+      const mat = mesh.material;
+      mat == null ? void 0 : mat._ensureRenderable(engine);
+      if (mat == null ? void 0 : mat._lite) {
+        mesh._lite.material = mat._lite;
+      }
+      addToScene(scene._lite, mesh._lite);
+    });
+    return mesh;
+  }
+  /** Babylon.js `plugin.getClosestPoint(position)` — snap to the navmesh. */
+  getClosestPoint(position) {
+    const p = getClosestPoint(this._lite, { x: position.x, y: position.y, z: position.z });
+    return new Vector3(p.x, p.y, p.z);
+  }
+  /** Babylon.js `plugin.computePath(start, end)` — navmesh-snapped path as world points. */
+  computePath(start, end) {
+    const points = computePath(this._lite, { x: start.x, y: start.y, z: start.z }, { x: end.x, y: end.y, z: end.z });
+    return points.map((p) => new Vector3(p.x, p.y, p.z));
+  }
+  /** Babylon.js `plugin.computePathSmooth(start, end)` — alias of {@link computePath} (Lite smooths internally). */
+  computePathSmooth(start, end) {
+    return this.computePath(start, end);
+  }
+  /**
+   * Babylon.js `plugin.raycast(start, end)` — walkability raycast on the navmesh.
+   * Returns `{ hit, hitPoint? }` (`hitPoint` is a `Vector3` when `hit`).
+   */
+  raycast(start, end) {
+    const r = raycast(this._lite, { x: start.x, y: start.y, z: start.z }, { x: end.x, y: end.y, z: end.z });
+    return r.hit && r.hitPoint ? { hit: true, hitPoint: new Vector3(r.hitPoint.x, r.hitPoint.y, r.hitPoint.z) } : { hit: false };
+  }
+  /** Babylon.js `plugin.createCrowd(maxAgents, maxAgentRadius, scene)`. */
+  createCrowd(maxAgents, maxAgentRadius, scene) {
+    const crowd = createNavCrowd(this._lite, maxAgents, maxAgentRadius);
+    return new RecastJSCrowd(crowd, this, scene);
+  }
+}
+async function CreateNavigationPluginAsync(_options) {
+  const lite = await createNavigationPluginAsync({ locateFile: () => "/recast-navigation.wasm" });
+  return new RecastNavigationJSPluginV2(lite);
+}
+function WaitForFullTileCacheUpdate(navMesh, _tileCache) {
+  const plugin = navMesh;
+  if (plugin && typeof plugin._updateObstacles === "function") {
+    plugin._updateObstacles();
+  }
+}
+export {
+  CreateNavigationPluginAsync,
+  RecastJSCrowd,
+  RecastNavigationJSPluginV2,
+  WaitForFullTileCacheUpdate
+};
+//# sourceMappingURL=navigation.js.map

package/navigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.js","sources":["../src/navigation/navigation.ts"],"sourcesContent":["/**\n * Babylon.js `@babylonjs/addons/navigation` compatibility wrapper over Babylon\n * Lite's native navigation API (`createNavigationPluginAsync` / `createNavMesh` /\n * `createDebugNavMeshGeometry` / `createNavCrowd` / …).\n *\n * The Babylon.js navigation addon (`RecastNavigationJSPluginV2`, created via\n * `CreateNavigationPluginAsync`) is a thin wrapper around `recast-navigation-js`.\n * Babylon Lite ships its own Recast V2 integration with the same capabilities, so\n * this module mirrors the addon's public plugin/crowd surface and delegates to\n * Lite. The Recast instance the scene injects via `{ instance }` is ignored —\n * Lite loads its own Recast wasm (served at `/recast-navigation.wasm`).\n *\n * Only the surface exercised by ported scenes is implemented (`createNavMesh`,\n * `createDebugNavMesh`, `getClosestPoint`, `createCrowd` + `addAgent`); the rest\n * of the addon API is intentionally omitted.\n */\n\nimport {\n    createNavigationPluginAsync as liteCreateNavigationPluginAsync,\n    createNavMesh as liteCreateNavMesh,\n    createDebugNavMeshGeometry as liteCreateDebugNavMeshGeometry,\n    getClosestPoint as liteGetClosestPoint,\n    computePath as liteComputePath,\n    raycast as liteRaycast,\n    createNavCrowd as liteCreateNavCrowd,\n    addAgent as liteAddAgent,\n    getAgentPosition as liteGetAgentPosition,\n    agentGoto as liteAgentGoto,\n    updateNavCrowd as liteUpdateNavCrowd,\n    addBoxObstacle as liteAddBoxObstacle,\n    addCylinderObstacle as liteAddCylinderObstacle,\n    removeObstacle as liteRemoveObstacle,\n    updateNavMeshObstacles as liteUpdateNavMeshObstacles,\n    createMeshFromData,\n    addToScene,\n    type NavigationPlugin as LiteNavigationPlugin,\n    type NavCrowd as LiteNavCrowd,\n    type Mesh as LiteMesh,\n    type ObstacleHandle as LiteObstacleHandle,\n} from \"babylon-lite\";\n\nimport { Mesh } from \"../meshes/meshes.js\";\nimport { Vector3 } from \"../math/vector.js\";\nimport type { Scene } from \"../scene/scene.js\";\n\ninterface Vec3Like {\n    x: number;\n    y: number;\n    z: number;\n}\n\ninterface AgentTransform {\n    position: { set(x: number, y: number, z: number): unknown };\n}\n\n/**\n * Result of {@link RecastNavigationJSPluginV2.createNavMesh}. Babylon.js's\n * tile-cache navmesh build returns `{ navMesh, tileCache }`; here both reference\n * the plugin so {@link WaitForFullTileCacheUpdate} can reach it.\n */\ninterface NavMeshResult {\n    navMesh: RecastNavigationJSPluginV2;\n    tileCache: RecastNavigationJSPluginV2;\n}\n\n/** Babylon.js `IAgentParameters` subset accepted by `RecastJSCrowd.addAgent`. */\ninterface AgentParameters {\n    radius: number;\n    height: number;\n    maxAcceleration: number;\n    maxSpeed: number;\n    collisionQueryRange: number;\n    pathOptimizationRange: number;\n    separationWeight: number;\n    reachRadius?: number;\n}\n\n/**\n * Babylon.js `RecastJSCrowd` (subset) — owns crowd agents and syncs each agent's\n * Babylon transform to the simulated position every frame, exactly like the addon.\n */\nclass RecastJSCrowd {\n    /** @internal */ public readonly _lite: LiteNavCrowd;\n    private readonly _transforms = new Map<number, AgentTransform>();\n    private readonly _plugin: RecastNavigationJSPluginV2;\n\n    public constructor(lite: LiteNavCrowd, plugin: RecastNavigationJSPluginV2, scene: Scene) {\n        this._lite = lite;\n        this._plugin = plugin;\n        // Babylon.js' crowd advances the simulation and writes back agent transforms\n        // on the scene's before-render tick; mirror that over Lite's manual crowd update.\n        // The plugin's `timeFactor` scales the step (0 freezes the crowd — used by parity\n        // tests via `?freeze=1`).\n        scene.onBeforeRenderObservable.add(() => {\n            liteUpdateNavCrowd(this._lite, (1 / 60) * this._plugin.timeFactor);\n            for (const [index, transform] of this._transforms) {\n                const p = liteGetAgentPosition(this._lite, index);\n                transform.position.set(p.x, p.y, p.z);\n            }\n        });\n    }\n\n    /** Babylon.js `crowd.addAgent(pos, parameters, transform)` — returns the agent index. */\n    public addAgent(pos: Vec3Like, parameters: AgentParameters, transform: AgentTransform): number {\n        const index = liteAddAgent(this._lite, { x: pos.x, y: pos.y, z: pos.z }, parameters);\n        this._transforms.set(index, transform);\n        return index;\n    }\n\n    /** Babylon.js `crowd.getAgentPosition(index)`. */\n    public getAgentPosition(index: number): Vector3 {\n        const p = liteGetAgentPosition(this._lite, index);\n        return new Vector3(p.x, p.y, p.z);\n    }\n\n    /** Babylon.js `crowd.agentGoto(index, destination)` — request the agent to move toward a target. */\n    public agentGoto(index: number, destination: Vec3Like): void {\n        liteAgentGoto(this._lite, index, { x: destination.x, y: destination.y, z: destination.z });\n    }\n}\n\n/**\n * Babylon.js `RecastNavigationJSPluginV2` (subset) over Babylon Lite navigation.\n */\nclass RecastNavigationJSPluginV2 {\n    /** @internal */ public readonly _lite: LiteNavigationPlugin;\n    /**\n     * Babylon.js `plugin.timeFactor` — multiplier applied to each crowd update step.\n     * `0` pauses crowd movement (used by parity tests); default `1`.\n     */\n    public timeFactor = 1;\n\n    public constructor(lite: LiteNavigationPlugin) {\n        this._lite = lite;\n    }\n\n    /**\n     * Babylon.js `plugin.createNavMesh(meshes, parameters)`. Returns a\n     * `{ navMesh, tileCache }` handle (both reference this plugin) so scenes using\n     * the tile-cache obstacle API can pass them to {@link WaitForFullTileCacheUpdate}.\n     * Scenes that ignore the return (the non-obstacle navmesh scenes) are unaffected.\n     */\n    public createNavMesh(meshes: Array<{ _lite: LiteMesh }>, parameters: Record<string, unknown>): NavMeshResult {\n        liteCreateNavMesh(\n            this._lite,\n            meshes.map((m) => m._lite),\n            parameters as never\n        );\n        return { navMesh: this, tileCache: this };\n    }\n\n    /** Babylon.js `plugin.addCylinderObstacle(position, radius, height)` — tile-cache obstacle. */\n    public addCylinderObstacle(position: Vec3Like, radius: number, height: number): LiteObstacleHandle | null {\n        return liteAddCylinderObstacle(this._lite, { x: position.x, y: position.y, z: position.z }, radius, height);\n    }\n\n    /** Babylon.js `plugin.addBoxObstacle(position, extent, angle)` — tile-cache obstacle (`extent` = half-extents). */\n    public addBoxObstacle(position: Vec3Like, extent: Vec3Like, angle: number): LiteObstacleHandle | null {\n        return liteAddBoxObstacle(this._lite, { x: position.x, y: position.y, z: position.z }, { x: extent.x, y: extent.y, z: extent.z }, angle);\n    }\n\n    /** Babylon.js `plugin.removeObstacle(obstacle)` — remove a previously-added tile-cache obstacle. */\n    public removeObstacle(obstacle: LiteObstacleHandle): void {\n        liteRemoveObstacle(this._lite, obstacle);\n    }\n\n    /** @internal Apply pending tile-cache obstacle updates (drives {@link WaitForFullTileCacheUpdate}). */\n    public _updateObstacles(): void {\n        liteUpdateNavMeshObstacles(this._lite);\n    }\n\n    /** Babylon.js `plugin.createDebugNavMesh(scene)` — builds a renderable debug mesh. */\n    public createDebugNavMesh(scene: Scene): Mesh {\n        const geo = liteCreateDebugNavMeshGeometry(this._lite);\n        const engine = scene.getEngine()._lite;\n        const lite = createMeshFromData(engine, \"navDebugMesh\", geo.positions, geo.normals, geo.indices);\n        const mesh = new Mesh(\"navDebugMesh\", lite, scene);\n        scene._deferAdd(() => {\n            const mat = mesh.material;\n            mat?._ensureRenderable(engine);\n            if (mat?._lite) {\n                mesh._lite.material = mat._lite as never;\n            }\n            addToScene(scene._lite, mesh._lite);\n        });\n        return mesh;\n    }\n\n    /** Babylon.js `plugin.getClosestPoint(position)` — snap to the navmesh. */\n    public getClosestPoint(position: Vec3Like): Vector3 {\n        const p = liteGetClosestPoint(this._lite, { x: position.x, y: position.y, z: position.z });\n        return new Vector3(p.x, p.y, p.z);\n    }\n\n    /** Babylon.js `plugin.computePath(start, end)` — navmesh-snapped path as world points. */\n    public computePath(start: Vec3Like, end: Vec3Like): Vector3[] {\n        const points = liteComputePath(this._lite, { x: start.x, y: start.y, z: start.z }, { x: end.x, y: end.y, z: end.z });\n        return points.map((p) => new Vector3(p.x, p.y, p.z));\n    }\n\n    /** Babylon.js `plugin.computePathSmooth(start, end)` — alias of {@link computePath} (Lite smooths internally). */\n    public computePathSmooth(start: Vec3Like, end: Vec3Like): Vector3[] {\n        return this.computePath(start, end);\n    }\n\n    /**\n     * Babylon.js `plugin.raycast(start, end)` — walkability raycast on the navmesh.\n     * Returns `{ hit, hitPoint? }` (`hitPoint` is a `Vector3` when `hit`).\n     */\n    public raycast(start: Vec3Like, end: Vec3Like): { hit: boolean; hitPoint?: Vector3 } {\n        const r = liteRaycast(this._lite, { x: start.x, y: start.y, z: start.z }, { x: end.x, y: end.y, z: end.z });\n        return r.hit && r.hitPoint ? { hit: true, hitPoint: new Vector3(r.hitPoint.x, r.hitPoint.y, r.hitPoint.z) } : { hit: false };\n    }\n\n    /** Babylon.js `plugin.createCrowd(maxAgents, maxAgentRadius, scene)`. */\n    public createCrowd(maxAgents: number, maxAgentRadius: number, scene: Scene): RecastJSCrowd {\n        const crowd = liteCreateNavCrowd(this._lite, maxAgents, maxAgentRadius);\n        return new RecastJSCrowd(crowd, this, scene);\n    }\n}\n\n/**\n * Babylon.js `@babylonjs/addons/navigation` `CreateNavigationPluginAsync`. The\n * injected Recast `instance` (if any) is ignored — Babylon Lite loads its own\n * Recast wasm from `/recast-navigation.wasm`.\n */\nexport async function CreateNavigationPluginAsync(_options?: { version?: string; instance?: unknown }): Promise<RecastNavigationJSPluginV2> {\n    const lite = await liteCreateNavigationPluginAsync({ locateFile: () => \"/recast-navigation.wasm\" });\n    return new RecastNavigationJSPluginV2(lite);\n}\n\nexport { RecastNavigationJSPluginV2, RecastJSCrowd };\n\n/**\n * Babylon.js `@babylonjs/addons/navigation/common/tile-cache`\n * `WaitForFullTileCacheUpdate(navMesh, tileCache)` — block until pending\n * tile-cache obstacle updates are applied. The addon takes the raw navMesh /\n * tileCache; here `navMesh` is the compat plugin (returned from `createNavMesh`),\n * so this delegates to Babylon Lite's `updateNavMeshObstacles`.\n */\nexport function WaitForFullTileCacheUpdate(navMesh: unknown, _tileCache?: unknown): void {\n    const plugin = navMesh as RecastNavigationJSPluginV2 | undefined;\n    if (plugin && typeof plugin._updateObstacles === \"function\") {\n        plugin._updateObstacles();\n    }\n}\n"],"names":["liteUpdateNavCrowd","liteGetAgentPosition","liteAddAgent","liteAgentGoto","liteCreateNavMesh","liteAddCylinderObstacle","liteAddBoxObstacle","liteRemoveObstacle","liteUpdateNavMeshObstacles","liteCreateDebugNavMeshGeometry","liteGetClosestPoint","liteComputePath","liteRaycast","liteCreateNavCrowd","liteCreateNavigationPluginAsync"],"mappings":"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"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@babylonjs/lite-compat",
+  "version": "0.0.1-preview.54961",
+  "license": "Apache-2.0",
+  "type": "module",
+  "description": "Opt-in Babylon.js-shaped compatibility layer implemented on top of the Babylon Lite public API. Provides a migration runway from Babylon.js to Babylon Lite.",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./vite": {
+      "import": "./vite.js",
+      "types": "./vite.d.ts"
+    },
+    "./rollup": {
+      "import": "./rollup.js",
+      "types": "./rollup.d.ts"
+    },
+    "./webpack": {
+      "import": "./webpack.js",
+      "types": "./webpack.d.ts"
+    },
+    "./esbuild": {
+      "import": "./esbuild.js",
+      "types": "./esbuild.d.ts"
+    },
+    "./navigation": {
+      "import": "./navigation.js",
+      "types": "./navigation.d.ts"
+    },
+    "./recast-shim": {
+      "import": "./recast-shim.js",
+      "types": "./recast-shim.d.ts"
+    }
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "@babylonjs/lite": "*"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "babylonLiteRelease": {
+    "azureBuildId": "54961",
+    "sourceVersion": "fbf5a62071dc7fce7c0a00f3a16080f3f5932a91",
+    "builtAgainstLite": "1.1.0"
+  }
+}

package/recast-shim.d.ts

@@ -0,0 +1,16 @@
+/**
+ * No-op stand-in for `@recast-navigation/core` / `@recast-navigation/generators`
+ * inside the compat (`?compat`) subtree.
+ *
+ * Babylon.js navigation scenes import the raw `@recast-navigation` packages, call
+ * `init()`, and pass `{ ...RecastCore, ...RecastGenerators }` into
+ * `CreateNavigationPluginAsync({ instance })`. The compat navigation wrapper
+ * ([navigation/navigation.ts](navigation.ts)) ignores that injected instance and
+ * drives Babylon Lite's own navigation API (which loads its own Recast wasm), so
+ * the scene's direct Recast usage is reduced to a harmless no-op here — avoiding a
+ * second wasm download.
+ */
+/** Babylon.js scenes call `await RecastCore.init()`; Lite loads Recast itself, so no-op. */
+export declare function init(): Promise<void>;
+
+export { }

package/recast-shim.js

@@ -0,0 +1,6 @@
+async function init() {
+}
+export {
+  init
+};
+//# sourceMappingURL=recast-shim.js.map

package/recast-shim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recast-shim.js","sources":["../src/navigation/recast-shim.ts"],"sourcesContent":["/**\n * No-op stand-in for `@recast-navigation/core` / `@recast-navigation/generators`\n * inside the compat (`?compat`) subtree.\n *\n * Babylon.js navigation scenes import the raw `@recast-navigation` packages, call\n * `init()`, and pass `{ ...RecastCore, ...RecastGenerators }` into\n * `CreateNavigationPluginAsync({ instance })`. The compat navigation wrapper\n * ([navigation/navigation.ts](navigation.ts)) ignores that injected instance and\n * drives Babylon Lite's own navigation API (which loads its own Recast wasm), so\n * the scene's direct Recast usage is reduced to a harmless no-op here — avoiding a\n * second wasm download.\n */\n\n/** Babylon.js scenes call `await RecastCore.init()`; Lite loads Recast itself, so no-op. */\nexport async function init(): Promise<void> {\n    // Intentionally empty — Babylon Lite's navigation plugin loads Recast internally.\n}\n\n// `{ ...RecastCore }` / `{ ...RecastGenerators }` spreads collect nothing else of use;\n// the compat navigation wrapper does not read the injected instance.\n"],"names":[],"mappings":"AAcA,eAAsB,OAAsB;AAE5C;"}

package/rollup.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Create the Babylon Lite compat Rollup plugin. Add it to your config's
+ * `plugins` array and keep your Babylon.js imports exactly as they are.
+ */
+export declare function liteCompat(): RollupPlugin;
+
+/** Minimal structural type for the Rollup plugin object this adapter returns. */
+declare interface RollupPlugin {
+    name: string;
+    resolveId(this: RollupResolveContext, source: string, importer: string | undefined): Promise<string | null>;
+}
+
+/**
+ * A reusable Rollup plugin that lets an existing Babylon.js project run on
+ * Babylon Lite **without changing its import statements**. It rewrites
+ * `@babylonjs/core`, `@babylonjs/loaders`, `@babylonjs/addons`,
+ * `@babylonjs/materials`, and `@recast-navigation/*` imports
+ * onto the matching `@babylonjs/lite-compat` modules at resolve time.
+ *
+ * Usage (`rollup.config.js`):
+ *
+ * ```js
+ * import { liteCompat } from "@babylonjs/lite-compat/rollup";
+ *
+ * export default {
+ *     plugins: [liteCompat()],
+ * };
+ * ```
+ *
+ * Rolldown shares Rollup's plugin API, so this adapter works there too. The
+ * redirect table is shared with every other adapter via
+ * [bundler-resolve.ts](bundler-resolve.ts).
+ */
+/**
+ * Minimal structural type for the Rollup `PluginContext.resolve` available on
+ * `this` inside `resolveId`. Typed locally so the adapter carries no `rollup`
+ * dependency of its own.
+ */
+declare interface RollupResolveContext {
+    resolve(source: string, importer: string | undefined, options: {
+        skipSelf?: boolean;
+    }): Promise<{
+        id: string;
+        external: boolean | string;
+    } | null>;
+}
+
+export { }

package/rollup.js

@@ -0,0 +1,18 @@
+import { r as resolveCompatSpecifier } from "./bundler-resolve-0pEkTP9X.js";
+function liteCompat() {
+  return {
+    name: "babylonjs-lite-compat",
+    async resolveId(source, importer) {
+      const specifier = resolveCompatSpecifier(source);
+      if (!specifier) {
+        return null;
+      }
+      const resolved = await this.resolve(specifier, importer, { skipSelf: true });
+      return (resolved == null ? void 0 : resolved.id) ?? null;
+    }
+  };
+}
+export {
+  liteCompat
+};
+//# sourceMappingURL=rollup.js.map

package/rollup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.js","sources":["../src/rollup.ts"],"sourcesContent":["/**\n * A reusable Rollup plugin that lets an existing Babylon.js project run on\n * Babylon Lite **without changing its import statements**. It rewrites\n * `@babylonjs/core`, `@babylonjs/loaders`, `@babylonjs/addons`,\n * `@babylonjs/materials`, and `@recast-navigation/*` imports\n * onto the matching `@babylonjs/lite-compat` modules at resolve time.\n *\n * Usage (`rollup.config.js`):\n *\n * ```js\n * import { liteCompat } from \"@babylonjs/lite-compat/rollup\";\n *\n * export default {\n *     plugins: [liteCompat()],\n * };\n * ```\n *\n * Rolldown shares Rollup's plugin API, so this adapter works there too. The\n * redirect table is shared with every other adapter via\n * [bundler-resolve.ts](bundler-resolve.ts).\n */\n\nimport { resolveCompatSpecifier } from \"./bundler-resolve.js\";\n\n/**\n * Minimal structural type for the Rollup `PluginContext.resolve` available on\n * `this` inside `resolveId`. Typed locally so the adapter carries no `rollup`\n * dependency of its own.\n */\ninterface RollupResolveContext {\n    resolve(source: string, importer: string | undefined, options: { skipSelf?: boolean }): Promise<{ id: string; external: boolean | string } | null>;\n}\n\n/** Minimal structural type for the Rollup plugin object this adapter returns. */\ninterface RollupPlugin {\n    name: string;\n    resolveId(this: RollupResolveContext, source: string, importer: string | undefined): Promise<string | null>;\n}\n\n/**\n * Create the Babylon Lite compat Rollup plugin. Add it to your config's\n * `plugins` array and keep your Babylon.js imports exactly as they are.\n */\nexport function liteCompat(): RollupPlugin {\n    return {\n        name: \"babylonjs-lite-compat\",\n        async resolveId(source, importer) {\n            const specifier = resolveCompatSpecifier(source);\n            if (!specifier) {\n                return null;\n            }\n            // Re-run resolution on the compat specifier so the package's `exports`\n            // map (source vs. dist) is honored. `skipSelf` prevents re-entering\n            // this same plugin for the redirect target.\n            const resolved = await this.resolve(specifier, importer, { skipSelf: true });\n            return resolved?.id ?? null;\n        },\n    };\n}\n"],"names":[],"mappings":";AA2CO,SAAS,aAA2B;AACvC,SAAO;AAAA,IACH,MAAM;AAAA,IACN,MAAM,UAAU,QAAQ,UAAU;AAC9B,YAAM,YAAY,uBAAuB,MAAM;AAC/C,UAAI,CAAC,WAAW;AACZ,eAAO;AAAA,MACX;AAIA,YAAM,WAAW,MAAM,KAAK,QAAQ,WAAW,UAAU,EAAE,UAAU,MAAM;AAC3E,cAAO,qCAAU,OAAM;AAAA,IAC3B;AAAA,EAAA;AAER;"}

package/vite.d.ts

@@ -0,0 +1,10 @@
+import { Plugin as Plugin_2 } from 'vite';
+
+/**
+ * Create the Babylon Lite compat Vite plugin. Add it to your config's `plugins`
+ * array and keep your Babylon.js imports exactly as they are — they resolve to
+ * the compat layer instead of Babylon.js.
+ */
+export declare function liteCompat(): Plugin_2;
+
+export { }

package/vite.js

@@ -0,0 +1,24 @@
+import { r as resolveCompatSpecifier } from "./bundler-resolve-0pEkTP9X.js";
+function liteCompat() {
+  return {
+    name: "babylonjs-lite-compat",
+    // `pre` so the redirect happens before Vite's own resolver/optimizer sees
+    // the original Babylon.js specifier.
+    enforce: "pre",
+    async resolveId(source, importer, options) {
+      const specifier = resolveCompatSpecifier(source);
+      if (!specifier) {
+        return null;
+      }
+      const resolved = await this.resolve(specifier, importer, {
+        ...options,
+        skipSelf: true
+      });
+      return (resolved == null ? void 0 : resolved.id) ?? null;
+    }
+  };
+}
+export {
+  liteCompat
+};
+//# sourceMappingURL=vite.js.map

package/vite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.js","sources":["../src/vite.ts"],"sourcesContent":["/**\n * A reusable Vite plugin that lets an existing Babylon.js project run on Babylon\n * Lite **without changing its import statements**. It rewrites `@babylonjs/core`,\n * `@babylonjs/loaders`, `@babylonjs/addons`, `@babylonjs/materials`, and\n * `@recast-navigation/*` imports\n * onto the matching `@babylonjs/lite-compat` modules at resolve time, so the\n * compat layer (which runs on Babylon Lite's WebGPU renderer) is loaded in place\n * of Babylon.js.\n *\n * Usage (`vite.config.ts`):\n *\n * ```ts\n * import { defineConfig } from \"vite\";\n * import { liteCompat } from \"@babylonjs/lite-compat/vite\";\n *\n * export default defineConfig({\n *     plugins: [liteCompat()],\n * });\n * ```\n *\n * The redirect table is shared with the other bundler adapters and the lab\n * harness via [bundler-resolve.ts](bundler-resolve.ts) so they can never diverge.\n */\n\nimport type { Plugin } from \"vite\";\nimport { resolveCompatSpecifier } from \"./bundler-resolve.js\";\n\n/**\n * Create the Babylon Lite compat Vite plugin. Add it to your config's `plugins`\n * array and keep your Babylon.js imports exactly as they are — they resolve to\n * the compat layer instead of Babylon.js.\n */\nexport function liteCompat(): Plugin {\n    return {\n        name: \"babylonjs-lite-compat\",\n        // `pre` so the redirect happens before Vite's own resolver/optimizer sees\n        // the original Babylon.js specifier.\n        enforce: \"pre\",\n        async resolveId(source, importer, options) {\n            const specifier = resolveCompatSpecifier(source);\n            if (!specifier) {\n                return null;\n            }\n            // Re-run resolution on the compat specifier so the package's `exports`\n            // map (source vs. dist) is honored. `skipSelf` prevents re-entering\n            // this same plugin for the redirect target.\n            const resolved = await this.resolve(specifier, importer, {\n                ...options,\n                skipSelf: true,\n            });\n            return resolved?.id ?? null;\n        },\n    };\n}\n"],"names":[],"mappings":";AAgCO,SAAS,aAAqB;AACjC,SAAO;AAAA,IACH,MAAM;AAAA;AAAA;AAAA,IAGN,SAAS;AAAA,IACT,MAAM,UAAU,QAAQ,UAAU,SAAS;AACvC,YAAM,YAAY,uBAAuB,MAAM;AAC/C,UAAI,CAAC,WAAW;AACZ,eAAO;AAAA,MACX;AAIA,YAAM,WAAW,MAAM,KAAK,QAAQ,WAAW,UAAU;AAAA,QACrD,GAAG;AAAA,QACH,UAAU;AAAA,MAAA,CACb;AACD,cAAO,qCAAU,OAAM;AAAA,IAC3B;AAAA,EAAA;AAER;"}

package/webpack.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Webpack (and Rspack) plugin that redirects Babylon.js imports onto the
+ * `@babylonjs/lite-compat` layer. Add `new LiteCompatPlugin()` to your config's
+ * `plugins` array and keep your Babylon.js imports exactly as they are.
+ */
+export declare class LiteCompatPlugin {
+    apply(compiler: WebpackCompiler): void;
+}
+
+/** Minimal structural type for `compiler.webpack.NormalModuleReplacementPlugin`. */
+declare interface NormalModuleReplacementPluginCtor {
+    new (resourceRegExp: RegExp, newResource: (resource: WebpackResource) => void): {
+        apply(compiler: WebpackCompiler): void;
+    };
+}
+
+/** Minimal structural type for the Webpack 5 compiler this plugin needs. */
+declare interface WebpackCompiler {
+    webpack: {
+        NormalModuleReplacementPlugin: NormalModuleReplacementPluginCtor;
+    };
+}
+
+/**
+ * A reusable Webpack plugin that lets an existing Babylon.js project run on
+ * Babylon Lite **without changing its import statements**. It rewrites
+ * `@babylonjs/core`, `@babylonjs/loaders`, `@babylonjs/addons`,
+ * `@babylonjs/materials`, and `@recast-navigation/*` imports
+ * onto the matching `@babylonjs/lite-compat` modules before Webpack resolves
+ * them, by rewriting the request and letting Webpack's own resolver (and the
+ * package's `exports` map) take it from there.
+ *
+ * Usage (`webpack.config.js`):
+ *
+ * ```js
+ * const { LiteCompatPlugin } = require("@babylonjs/lite-compat/webpack");
+ *
+ * module.exports = {
+ *     plugins: [new LiteCompatPlugin()],
+ * };
+ * ```
+ *
+ * Built on Webpack 5's `NormalModuleReplacementPlugin` (reached via
+ * `compiler.webpack`), so the adapter needs no `webpack` dependency of its own.
+ * Rspack implements the same plugin interface, so this adapter works there too.
+ * The redirect table is shared with every other adapter via
+ * [bundler-resolve.ts](bundler-resolve.ts).
+ */
+/** Minimal structural type for the request object Webpack hands the replacer. */
+declare interface WebpackResource {
+    request: string;
+}
+
+export { }

package/webpack.js

@@ -0,0 +1,16 @@
+import { C as COMPAT_SOURCE_FILTER, r as resolveCompatSpecifier } from "./bundler-resolve-0pEkTP9X.js";
+class LiteCompatPlugin {
+  apply(compiler) {
+    const { NormalModuleReplacementPlugin } = compiler.webpack;
+    new NormalModuleReplacementPlugin(COMPAT_SOURCE_FILTER, (resource) => {
+      const specifier = resolveCompatSpecifier(resource.request);
+      if (specifier) {
+        resource.request = specifier;
+      }
+    }).apply(compiler);
+  }
+}
+export {
+  LiteCompatPlugin
+};
+//# sourceMappingURL=webpack.js.map

package/webpack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.js","sources":["../src/webpack.ts"],"sourcesContent":["/**\n * A reusable Webpack plugin that lets an existing Babylon.js project run on\n * Babylon Lite **without changing its import statements**. It rewrites\n * `@babylonjs/core`, `@babylonjs/loaders`, `@babylonjs/addons`,\n * `@babylonjs/materials`, and `@recast-navigation/*` imports\n * onto the matching `@babylonjs/lite-compat` modules before Webpack resolves\n * them, by rewriting the request and letting Webpack's own resolver (and the\n * package's `exports` map) take it from there.\n *\n * Usage (`webpack.config.js`):\n *\n * ```js\n * const { LiteCompatPlugin } = require(\"@babylonjs/lite-compat/webpack\");\n *\n * module.exports = {\n *     plugins: [new LiteCompatPlugin()],\n * };\n * ```\n *\n * Built on Webpack 5's `NormalModuleReplacementPlugin` (reached via\n * `compiler.webpack`), so the adapter needs no `webpack` dependency of its own.\n * Rspack implements the same plugin interface, so this adapter works there too.\n * The redirect table is shared with every other adapter via\n * [bundler-resolve.ts](bundler-resolve.ts).\n */\n\nimport { resolveCompatSpecifier, COMPAT_SOURCE_FILTER } from \"./bundler-resolve.js\";\n\n/** Minimal structural type for the request object Webpack hands the replacer. */\ninterface WebpackResource {\n    request: string;\n}\n\n/** Minimal structural type for `compiler.webpack.NormalModuleReplacementPlugin`. */\ninterface NormalModuleReplacementPluginCtor {\n    new (\n        resourceRegExp: RegExp,\n        newResource: (resource: WebpackResource) => void\n    ): {\n        apply(compiler: WebpackCompiler): void;\n    };\n}\n\n/** Minimal structural type for the Webpack 5 compiler this plugin needs. */\ninterface WebpackCompiler {\n    webpack: { NormalModuleReplacementPlugin: NormalModuleReplacementPluginCtor };\n}\n\n/**\n * Webpack (and Rspack) plugin that redirects Babylon.js imports onto the\n * `@babylonjs/lite-compat` layer. Add `new LiteCompatPlugin()` to your config's\n * `plugins` array and keep your Babylon.js imports exactly as they are.\n */\nexport class LiteCompatPlugin {\n    apply(compiler: WebpackCompiler): void {\n        const { NormalModuleReplacementPlugin } = compiler.webpack;\n        new NormalModuleReplacementPlugin(COMPAT_SOURCE_FILTER, (resource) => {\n            const specifier = resolveCompatSpecifier(resource.request);\n            if (specifier) {\n                resource.request = specifier;\n            }\n        }).apply(compiler);\n    }\n}\n"],"names":[],"mappings":";AAqDO,MAAM,iBAAiB;AAAA,EAC1B,MAAM,UAAiC;AACnC,UAAM,EAAE,kCAAkC,SAAS;AACnD,QAAI,8BAA8B,sBAAsB,CAAC,aAAa;AAClE,YAAM,YAAY,uBAAuB,SAAS,OAAO;AACzD,UAAI,WAAW;AACX,iBAAS,UAAU;AAAA,MACvB;AAAA,IACJ,CAAC,EAAE,MAAM,QAAQ;AAAA,EACrB;AACJ;"}