incanto 0.1.0

package/dist/3d.js

@@ -0,0 +1,5 @@
+import { a as Environment3D, c as sunDirectionFromElevationAzimuth, i as syncTree, l as sunDirectionFromSky, o as horizonColorFromSky, r as Renderer3D, s as parseEnvironment3D, t as createGame3D, u as AssetStore3D } from "./create-game-BdjpTHrW.js";
+import { A as QUARTER_PITCH, C as Area3D, D as StaticBody3D, E as RigidBody3D, M as keyboardIntensity, N as movementState, O as Node3D, P as rigPose, S as terrainThemeLayers, T as PhysicsBody3D, _ as CharacterController3D, a as VoxelGrid3D, b as DEFAULT_TERRAIN_TEXTURE_BASE, c as ModelInstance3D, d as OmniLight3D, f as Foliage3D, g as FLOWER_VARIETIES, h as resolveFlowerDensity, i as VOXEL_PALETTE, j as cameraRelative, l as MeshInstance3D, m as Flowers3D, n as Water3D, o as Tree3D, p as DENSITY_PRESETS, r as WATER_MAX_RIPPLES, s as Particles3D, t as registerNodes3D, u as DirectionalLight3D, v as Camera3D, w as CharacterBody3D, x as TERRAIN_THEMES, y as Terrain3D } from "./register-CNlYAS1_.js";
+import { n as splatWeights, t as buildHeightmap } from "./heightmap-CroQPEER.js";
+import { n as enablePhysics3D, t as Physics3D } from "./physics-3d-Dl67vOLT.js";
+export { Area3D, AssetStore3D, Camera3D, CharacterBody3D, CharacterController3D, DEFAULT_TERRAIN_TEXTURE_BASE, DirectionalLight3D, Environment3D, DENSITY_PRESETS as FLOWER_DENSITY_PRESETS, FLOWER_VARIETIES, Flowers3D, Foliage3D, MeshInstance3D, ModelInstance3D, Node3D, OmniLight3D, Particles3D, Physics3D, PhysicsBody3D, QUARTER_PITCH, Renderer3D, RigidBody3D, StaticBody3D, TERRAIN_THEMES, Terrain3D, Tree3D, VOXEL_PALETTE, VoxelGrid3D, WATER_MAX_RIPPLES, Water3D, buildHeightmap, cameraRelative, createGame3D, enablePhysics3D, horizonColorFromSky, keyboardIntensity, movementState, parseEnvironment3D, registerNodes3D, resolveFlowerDensity, rigPose, splatWeights, sunDirectionFromElevationAzimuth, sunDirectionFromSky, syncTree, terrainThemeLayers };

package/dist/agent8-DzU2fFyH.js

@@ -0,0 +1,129 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+//#region src/net/agent8.ts
+var agent8_exports = /* @__PURE__ */ __exportAll({
+	Agent8TransportForTest: () => Agent8Transport,
+	createAgent8Server: () => createAgent8Server
+});
+/**
+* The real transport: wraps `@agent8/gameserver`'s framework-free GameServer
+* class via a DEEP dynamic import (the package index re-exports React hooks
+* and zustand stores we must never pull in). The SDK is an optional peer dep —
+* games without multiplayer never load (or need) it.
+*
+* Adapter responsibilities beyond pass-through:
+* 1. allUserStates shape conversion: v2 delivers a fully delta-merged ARRAY of
+*    `{...state, account, __updated}` (left users already removed from it). We
+*    convert that to incanto's account-keyed Record, stripping the v2-internal
+*    `account`/`__updated`/`__leaved` markers, and emit it as a full snapshot.
+* 2. collection shape conversion: v2 delivers `{items: [{__id, …}], changes}`;
+*    we convert the merged `items` array to incanto's `__id`-keyed Record.
+* 3. Reconnect: the SDK clears pending subscriptions on disconnect and never
+*    restores them — we re-issue every active subscription after reconnect.
+*/
+async function createAgent8Server(config) {
+	return new Agent8Transport((await import("@agent8/gameserver/dist/src/server/GameServer.js")).GameServer, config);
+}
+var Agent8Transport = class {
+	raw;
+	active = /* @__PURE__ */ new Map();
+	constructor(GameServer, config) {
+		this.raw = new GameServer({ ...config });
+	}
+	get account() {
+		return this.raw.account;
+	}
+	get connected() {
+		return this.raw.connected;
+	}
+	connect() {
+		return this.rawConnect();
+	}
+	/** Connect WITH the onDisconnect hook the SDK honors (its connect-config param). */
+	rawConnect() {
+		return this.raw.connect({ onDisconnect: () => void this.reconnect() });
+	}
+	disconnect() {
+		for (const entry of this.active.values()) entry.off();
+		this.active.clear();
+		return this.raw.disconnect();
+	}
+	remoteFunction(fn, args, opts) {
+		return this.raw.remoteFunction(fn, args, opts);
+	}
+	track(make) {
+		const key = Symbol("sub");
+		const entry = {
+			make,
+			off: make()
+		};
+		this.active.set(key, entry);
+		return () => {
+			entry.off();
+			this.active.delete(key);
+		};
+	}
+	async reconnect() {
+		await this.rawConnect();
+		for (const entry of this.active.values()) {
+			entry.off();
+			entry.off = entry.make();
+		}
+	}
+	subscribeRoomState(roomId, cb) {
+		return this.track(() => this.raw.subscribeRoomState(roomId, cb));
+	}
+	subscribeRoomMyState(roomId, cb) {
+		return this.track(() => this.raw.subscribeRoomMyState(roomId, cb));
+	}
+	subscribeRoomAllUserStates(roomId, cb) {
+		return this.track(() => this.raw.subscribeRoomAllUserStates(roomId, (incoming) => {
+			const out = {};
+			for (const entry of incoming ?? []) {
+				if (!entry || typeof entry.account !== "string" || entry.__leaved) continue;
+				const { account, __updated, __leaved, ...state } = entry;
+				out[account] = state;
+			}
+			cb(out);
+		}));
+	}
+	subscribeRoomCollection(roomId, collectionId, cb) {
+		return this.track(() => this.raw.subscribeRoomCollection(roomId, collectionId, ({ items }) => {
+			const out = {};
+			for (const item of items ?? []) if (item && typeof item.__id === "string") out[item.__id] = item;
+			cb(out);
+		}));
+	}
+	onRoomMessage(roomId, type, cb) {
+		return this.track(() => this.raw.onRoomMessage(roomId, type, cb));
+	}
+	onRoomUserJoin(roomId, cb) {
+		return this.track(() => this.raw.onRoomUserJoin(roomId, cb));
+	}
+	onRoomUserLeave(roomId, cb) {
+		return this.track(() => this.raw.onRoomUserLeave(roomId, cb));
+	}
+	subscribeGlobalState(cb) {
+		return this.track(() => this.raw.subscribeGlobalState(cb));
+	}
+	subscribeGlobalMyState(cb) {
+		return this.track(() => this.raw.subscribeGlobalMyState(cb));
+	}
+	subscribeGlobalUserState(account, cb) {
+		return this.track(() => this.raw.subscribeGlobalUserState(account, cb));
+	}
+	subscribeGlobalCollection(collectionId, cb) {
+		return this.track(() => this.raw.subscribeGlobalCollection(collectionId, ({ items }) => {
+			const out = {};
+			for (const item of items ?? []) if (item && typeof item.__id === "string") out[item.__id] = item;
+			cb(out);
+		}));
+	}
+	subscribeAsset(account, cb) {
+		return this.track(() => this.raw.subscribeAsset(account, cb));
+	}
+	onGlobalMessage(type, cb) {
+		return this.track(() => this.raw.onGlobalMessage(type, cb));
+	}
+};
+//#endregion
+export { createAgent8Server as n, agent8_exports as t };

package/dist/audio-player-DqUR3XFs.d.ts

@@ -0,0 +1,110 @@
+import { F as Listener, T as Node, l as PropSchema } from "./behavior-BAQq7HGM.js";
+
+//#region src/core/nodes/audio-player.d.ts
+/**
+* The per-frame spatial feed the 3D adapter pushes onto a spatial AudioPlayer:
+* the emitter's world position + the active listener (Camera3D) pose. Detected
+* structurally by `syncTree` (like `_applySunDirection`), so headless trees pay
+* nothing.
+*/
+interface SpatialPose {
+  position: [number, number, number];
+  listener: Listener;
+}
+/** The slice of HTMLAudioElement the node drives (injectable for tests). */
+interface AudioElementLike {
+  src: string;
+  volume: number;
+  loop: boolean;
+  currentTime: number;
+  play(): Promise<void>;
+  pause(): void;
+  addEventListener(type: string, cb: () => void): void;
+}
+/**
+* One sound. `play()` (or `autoplay: true`) starts it; `finished` fires when
+* it ends. Browsers block audio before the first user gesture — a blocked
+* play marks `pendingGesture`; `createGame` retries pending players on the
+* first pointer/key gesture automatically.
+*
+* Two playback modes:
+* - `preset: 'custom'` (default) → plays the audio file at `src` via an HTMLAudio
+*   element (good for music / long clips; supports `loop`).
+* - `preset: 'coin' | 'jump' | …` (a procedural SFX preset) → synthesizes a
+*   zero-asset sound through WebAudio: instant, deterministic, overlap-friendly
+*   for rapid-fire SFX. `pitch`/`seed` vary it. The art-free audio analog of the
+*   particle presets. See `incanto-audio.md` for the full preset list.
+*
+* Volume routes through the engine's buses: `engine.audio.master × bus(sfx|music)
+* × volume`. Set `engine.audio.master`/`sfx`/`music`/`muted` for global control.
+*/
+declare class AudioPlayer extends Node {
+  static override readonly typeName: string;
+  static override readonly signals: readonly string[];
+  static readonly props: PropSchema;
+  /** Audio file url (same resolution rules as scene asset urls). Used when
+  *  `preset === 'custom'`; ignored for procedural presets. */
+  src: string;
+  /** A procedural SFX preset name (zero-asset), or 'custom' to use `src`. */
+  preset: string;
+  volume: number;
+  /** Pitch multiplier for procedural presets (1 = unchanged). */
+  pitch: number;
+  /** Variation seed for noisy presets (e.g. explosion/hit/step). */
+  seed: number;
+  /** Which volume bus this routes through. */
+  bus: string;
+  loop: boolean;
+  /** Start on the first frame in the tree (subject to the gesture policy). */
+  autoplay: boolean;
+  /**
+  * 3D positional audio: in a 3D scene the sound pans + attenuates by the
+  * emitter's world position relative to the active Camera3D (the listener).
+  * Default false → identical non-spatial behavior (back-compat). In a 2D scene
+  * spatial is currently ignored (the adapter feeds no pose) — see incanto-audio.
+  */
+  spatial: boolean;
+  /** Distance at which spatial gain is full; closer never gets louder. */
+  refDistance: number;
+  /** Distance past which spatial gain stops falling. */
+  maxDistance: number;
+  /** Spatial attenuation curve: 'inverse' | 'linear' | 'exponential'. */
+  rolloff: string;
+  /** Loader hook: unknown presets / buses fail at LOAD (agents self-correct). */
+  static validateJson(node: Node): void;
+  /** A play() was blocked by the browser's autoplay policy. */
+  pendingGesture: boolean;
+  private element;
+  private _playing;
+  private autoplayed;
+  /** Last spatial pose pushed by the 3D adapter (null until/unless spatial). */
+  private _spatialPose;
+  get playing(): boolean;
+  /**
+  * @internal Per-frame spatial feed from the 3D adapter (detected structurally
+  * by syncTree). Stores the emitter world position + listener pose; ignored
+  * unless `spatial` is on. Headless / 2D scenes never call this.
+  */
+  _setSpatialPose(pose: SpatialPose): void;
+  /** Final gain = engine buses × this volume (1 when not in a tree). */
+  private gain;
+  /** Distance gain for the src/element path (1 when not spatial / no pose). */
+  private spatialElementGain;
+  /** The `spatial` option for the SFX path, or undefined when not spatial. */
+  private spatialPlay;
+  play(): void;
+  /**
+  * Procedural-SFX path: synthesize the preset and fire it through WebAudio
+  * (low-latency, overlap-friendly). Fire-and-forget — no `finished`/`playing`
+  * tracking (these are short one-shots, not the element-driven `src` clip).
+  * Headless (no AudioContext) → silent no-op. WebAudio also needs a gesture;
+  * a suspended context is resumed by the same unlock listener as `src` players.
+  */
+  private playPreset;
+  stop(): void;
+  /** Replay a gesture-blocked play (wired to the first user gesture). */
+  retryPending(): void;
+  override update(_dt: number): void;
+}
+//#endregion
+export { AudioPlayer as n, SpatialPose as r, AudioElementLike as t };