incanto 0.1.0

package/dist/heightmap-CroQPEER.js

@@ -0,0 +1,185 @@
+import { t as createNoise2D } from "./noise-CGUMx44x.js";
+//#region src/3d/terrain/heightmap.ts
+/**
+* Pure heightfield + splat-weight math for `Terrain3D` — NO three imports, so
+* physics and headless verification can use it without a renderer. The
+* pipeline is a faithful port of the agent8 `vibe-starter-3d-environment`
+* terrain generator (seeded simplex octaves → pow redistribution → flat snap
+* → quarter-circle island edge wrap).
+*/
+/** Fixed noise-domain scale of the ported pipeline (world meters per noise unit). */
+const TERRAIN_SCALE = 256;
+/** Low-base flatten knee and factor (ported constants). */
+const FLATNESS = .3;
+/** Flat-snap half-band in meters around maxHeight·flatThreshold. */
+const FLAT_RANGE = .6;
+/** Edge wrap radius hard cap (meters). */
+const MAX_EDGE_WRAP_RADIUS = 45;
+/**
+* Build the deterministic heightfield. Heavy (one noise eval per vertex) —
+* call once and keep the result.
+*/
+function buildHeightmap(opts) {
+	const { width, depth, segsX, segsZ, maxHeight, seed } = opts;
+	const roughness = opts.roughness ?? .5;
+	const detail = opts.detail ?? 4;
+	const flatThreshold = opts.flatThreshold ?? .95;
+	const islandEdge = opts.islandEdge ?? false;
+	const edgeWrapRadius = Math.max(0, Math.min(opts.edgeWrapRadius ?? 20, MAX_EDGE_WRAP_RADIUS));
+	const edgeBottom = opts.edgeBottom ?? -50;
+	const edgeCornerSmoothness = opts.edgeCornerSmoothness ?? 1;
+	const basins = (opts.basins ?? []).map((b) => ({
+		cx: b.x + width / 2,
+		cz: b.z + depth / 2,
+		radius: b.radius,
+		depth: b.depth
+	}));
+	const simplex = createNoise2D(seed);
+	/** Ported: noise remapped from [-1,1] to [0,1]. */
+	const noise01 = (x, y) => (simplex(x, y) + 1) * .5;
+	/** The full pipeline EXCEPT edge wrap. x ∈ [0..width], z ∈ [0..depth]. */
+	const generate = (x, z) => {
+		const normX = x / TERRAIN_SCALE;
+		const normZ = z / TERRAIN_SCALE;
+		let base = 0;
+		let frequency = .2;
+		let amplitude = 5;
+		for (let i = 0; i < 5; i++) {
+			base += noise01(normX * frequency, normZ * frequency) * amplitude;
+			amplitude *= .5;
+			frequency *= 2;
+		}
+		let detailHeight = 0;
+		frequency = .5;
+		amplitude = .1;
+		for (let i = 0; i < detail; i++) {
+			detailHeight += noise01(normX * frequency, normZ * frequency) * amplitude;
+			amplitude *= roughness;
+			frequency *= 2;
+		}
+		base = Math.abs(base) ** 1.5 * Math.sign(base);
+		if (base < FLATNESS) base *= .3;
+		let final = maxHeight * (base + detailHeight * (base * .5 + .5) + 1) / 2;
+		const flatHeight = maxHeight * flatThreshold;
+		if (Math.abs(final - flatHeight) < FLAT_RANGE) final = flatHeight;
+		if (basins.length > 0) {
+			let carve = 0;
+			for (const b of basins) {
+				const d = Math.hypot(x - b.cx, z - b.cz);
+				if (d < b.radius) {
+					const t = d / b.radius;
+					carve = Math.max(carve, b.depth * (1 - t * t * (3 - 2 * t)));
+				}
+			}
+			final -= carve;
+		}
+		return final;
+	};
+	/** Quarter-circle edge wrap: drop = R − √(R²−s²), p-norm corner rounding. */
+	const applyEdgeWrap = (x, z, height) => {
+		if (!islandEdge || edgeWrapRadius <= 0) return height;
+		const R = edgeWrapRadius;
+		const dX = Math.min(x, width - x);
+		const dZ = Math.min(z, depth - z);
+		const jitter = (width / segsX + depth / segsZ) * .002;
+		const sX = Math.max(0, R - dX + jitter);
+		const sZ = Math.max(0, R - dZ + jitter);
+		if (sX <= 0 && sZ <= 0) return height;
+		const p = 2 + (1 - Math.min(1, Math.max(0, edgeCornerSmoothness))) * 30;
+		const sCombined = (sX ** p + sZ ** p) ** (1 / p);
+		let final = height - (R - Math.sqrt(Math.max(0, R * R - sCombined * sCombined)));
+		if (sCombined >= R) final = Math.min(final, edgeBottom);
+		return final;
+	};
+	const nx = segsX + 1;
+	const nz = segsZ + 1;
+	const heights = new Float32Array(nx * nz);
+	let minHeight = Number.POSITIVE_INFINITY;
+	let maxRealized = Number.NEGATIVE_INFINITY;
+	for (let iz = 0; iz < nz; iz++) {
+		const z = iz / segsZ * depth;
+		for (let ix = 0; ix < nx; ix++) {
+			const x = ix / segsX * width;
+			const raw = generate(x, z);
+			if (raw < minHeight) minHeight = raw;
+			if (raw > maxRealized) maxRealized = raw;
+			heights[iz * nx + ix] = applyEdgeWrap(x, z, raw);
+		}
+	}
+	const heightAt = (x, z) => {
+		const gx = Math.min(Math.max((x + width / 2) / width * segsX, 0), segsX);
+		const gz = Math.min(Math.max((z + depth / 2) / depth * segsZ, 0), segsZ);
+		const ix = Math.min(Math.floor(gx), segsX - 1);
+		const iz = Math.min(Math.floor(gz), segsZ - 1);
+		const fx = gx - ix;
+		const fz = gz - iz;
+		const i00 = heights[iz * nx + ix];
+		const i10 = heights[iz * nx + ix + 1];
+		const i01 = heights[(iz + 1) * nx + ix];
+		const i11 = heights[(iz + 1) * nx + ix + 1];
+		return (i00 * (1 - fx) + i10 * fx) * (1 - fz) + (i01 * (1 - fx) + i11 * fx) * fz;
+	};
+	const baseHeight = (x, z) => generate(x + width / 2, z + depth / 2);
+	const slopeAt = (x, z) => {
+		const eps = 1;
+		const dhdx = (baseHeight(x + eps, z) - baseHeight(x - eps, z)) / (2 * eps);
+		const dhdz = (baseHeight(x, z + eps) - baseHeight(x, z - eps)) / (2 * eps);
+		return Math.atan(Math.sqrt(dhdx * dhdx + dhdz * dhdz));
+	};
+	return {
+		width,
+		depth,
+		segsX,
+		segsZ,
+		heights,
+		minHeight,
+		maxHeight: maxRealized,
+		heightAt,
+		baseHeight,
+		slopeAt
+	};
+}
+/** Trapezoid weight: 1 inside [min,max], linear falloff over blendRange outside. */
+function trapezoid(value, min, max, blendRange) {
+	if (value < min - blendRange || value > max + blendRange) return 0;
+	if (value >= min && value <= max) return 1;
+	if (value < min) return (value - (min - blendRange)) / blendRange;
+	return (max + blendRange - value) / blendRange;
+}
+/**
+* Per-vertex splat weights for up to 4 layers. `height01` is the vertex
+* height normalized over the heightmap's realized (no-wrap) span, `slopeRad`
+* is `atan(|∇h|)`. Weight = heightTrapezoid · slopeTrapezoid, sharpened by
+* `pow(w, 1/blendingStrength)`, then normalized to sum 1 — when nothing
+* matches, layer 0 takes everything. Always returns exactly 4 entries
+* (missing layers weigh 0).
+*/
+function splatWeights(height01, slopeRad, layers, blendingStrength = 1.2) {
+	const out = [
+		0,
+		0,
+		0,
+		0
+	];
+	const n = Math.min(layers.length, 4);
+	let sum = 0;
+	for (let i = 0; i < n; i++) {
+		const layer = layers[i];
+		const [hMin, hMax] = layer.heightRange ?? [0, 1];
+		const [sMin, sMax] = layer.slopeRange ?? [0, Math.PI / 2];
+		let w = trapezoid(height01, hMin, hMax, layer.heightBlendRange ?? .1) * trapezoid(slopeRad, sMin, sMax, layer.slopeBlendRange ?? .1);
+		w = w ** (1 / blendingStrength);
+		out[i] = w;
+		sum += w;
+	}
+	if (sum === 0) return [
+		1,
+		0,
+		0,
+		0
+	];
+	for (let i = 0; i < 4; i++) out[i] = out[i] / sum;
+	return out;
+}
+//#endregion
+export { splatWeights as n, buildHeightmap as t };

package/dist/index.d.ts

@@ -0,0 +1,305 @@
+import { a as Rng, c as JsonValue, d as jsonKind, i as SceneJson, l as jsonClone, n as NodeJson, o as JsonKind, r as SCENE_FORMAT, s as JsonObject, t as ConnectionJson, u as jsonEquals } from "./schema-CcoWb32N.js";
+import { $ as BusName, A as LogManager, B as spatialGain, C as RendererStats, D as SceneTree, E as NodeLifecycle, F as Listener, G as SfxWave, H as SFX_PRESETS, I as ROLLOFF_MODELS, J as MusicBackend, K as SynthOptions, L as RolloffModel, M as SfxEngine, N as SfxPlayOptions, O as LogEntry, P as isAudioContextAvailable, Q as AudioBuses, R as SpatialParams, S as GameStats, T as Node, U as SFX_PRESET_NAMES, V as spatialPan, W as SfxParams, X as MusicTrack, Y as MusicManager, Z as PlayMusicOptions, _ as registeredTypes, a as registerBehavior, b as Scheduler, c as PropDef, d as createNode, et as Signal, f as getNodeSchema, g as registerNode, h as mergeStaticSignals, i as getBehavior, j as InputMap, k as LogLevel, l as PropSchema, m as getNodeType, n as BehaviorCtor, o as registeredBehaviors, p as getNodeSignals, q as synthSfx, r as clearBehaviors, s as NodeCtor, t as Behavior, tt as SignalListener, u as clearRegistry, v as Engine, w as Scene, x as EngineStats, y as EngineOptions, z as Vec3 } from "./behavior-BAQq7HGM.js";
+import { n as loadScene, t as LoadSceneOptions } from "./loader-Mo0KghCv.js";
+import { n as ParticleSimConfig, r as ParticleView, t as ParticleSim } from "./particle-sim-CbN4YUuH.js";
+import { n as AudioPlayer, t as AudioElementLike } from "./audio-player-DqUR3XFs.js";
+import { n as IncantoErrorCode, r as IncantoErrorDetails, t as IncantoError } from "./errors-BMFaY68Q.js";
+
+//#region src/core/audio/crossfade.d.ts
+/**
+* PURE crossfade / fade envelope math for the music manager. No WebAudio: just
+* the gain curves over time, so the loudness behaviour is unit-testable in
+* `node` and the headless music state machine can be validated without a backend.
+* The adapter applies these gains to real GainNodes / element volumes each frame.
+*/
+/** Linear 0→1 (`in`) or 1→0 (`out`) over `duration` seconds at elapsed `t`. */
+declare function fadeGain(t: number, duration: number, dir: "in" | "out"): number;
+interface CrossfadeGains {
+  /** Gain for the outgoing (old) track. */
+  out: number;
+  /** Gain for the incoming (new) track. */
+  in: number;
+}
+/**
+* Equal-power crossfade gains at elapsed `t` over `seconds`. The outgoing track
+* fades cos(¼π·p) and the incoming sin(¼π·p) so `out² + in² ≈ 1` throughout —
+* constant perceived loudness, no mid-fade dip (the classic equal-power law).
+* `p` is `t/seconds` clamped to [0,1]; a zero-second fade swaps instantly.
+*/
+declare function crossfadeGains(t: number, seconds: number): CrossfadeGains;
+//#endregion
+//#region src/core/audio/webaudio-music.d.ts
+declare class WebAudioMusicBackend implements MusicBackend {
+  private ctx;
+  private resolved;
+  /** True once a backend is present (lazily created on first use). */
+  get available(): boolean;
+  private ensure;
+  createTrack(src: string): MusicTrack;
+  unlock(): void;
+}
+//#endregion
+//#region src/core/debug-draw.d.ts
+/**
+* Renderer-agnostic physics debug drawing: physics runtimes register here as
+* line sources; renderers of the matching dimension pull vertices each frame
+* when `debugDraw` is on. Default OFF — a release game never pays for it.
+*/
+interface DebugLineSource {
+  readonly dimension: "2d" | "3d";
+  /** Toggle at runtime: `physics.debugDraw = true`. */
+  debugDraw: boolean;
+  /** Flat segment vertices (xy pairs in 2D px, xyz triples in 3D meters), or null while off. */
+  debugLines(): Float32Array | null;
+}
+//#endregion
+//#region src/core/node-path.d.ts
+/**
+* Godot-style NodePath grammar:
+*
+* - `'Child/Grand'`  relative descent
+* - `'.'`            self
+* - `'..'`           parent (may repeat: `'../../Other'`)
+* - `'/Level/Player'` absolute from the tree root
+* - `'%Player'`      unique-name lookup across the whole tree
+*/
+type ParsedNodePath = {
+  kind: "relative" | "absolute";
+  segments: string[];
+} | {
+  kind: "unique";
+  name: string;
+};
+declare function parseNodePath(path: string): ParsedNodePath;
+//#endregion
+//#region src/core/nodes/timer.d.ts
+/**
+* The canonical serializable game clock — never `setTimeout` in game logic.
+* Emits `timeout` every `waitTime` seconds (once with `oneShot`).
+*/
+declare class Timer extends Node {
+  static override readonly typeName: string;
+  static override readonly signals: readonly string[];
+  static readonly props: PropSchema;
+  /** Seconds between timeouts. */
+  waitTime: number;
+  oneShot: boolean;
+  autostart: boolean;
+  running: boolean;
+  private remaining;
+  start(time?: number): void;
+  stop(): void;
+  override onReady(): void;
+  override update(dt: number): void;
+}
+//#endregion
+//#region src/core/noise.d.ts
+/**
+* Seeded 2D simplex noise (Ken Perlin's simplex, Gustavson's reference
+* implementation) returning values in [-1, 1]. The permutation table is a
+* Fisher–Yates shuffle drawn from our deterministic {@link Rng}, so an
+* integer seed reproduces the identical field on every machine — the same
+* contract as every other seeded generator in the engine. Pure math, no deps.
+*/
+declare function createNoise2D(seed: number): (x: number, y: number) => number;
+//#endregion
+//#region src/core/particle-presets.d.ts
+/**
+* Predefined particle looks. A node's `preset` seeds these values UNDER its
+* explicit props: schema default < preset < anything the scene JSON wrote.
+* Values are 2D px-space; Particles3D rescales distances to meters.
+*/
+interface ParticlePresetValues {
+  rate?: number;
+  burst?: number;
+  lifetime?: [number, number];
+  speed?: [number, number];
+  directionDeg?: number;
+  spreadDeg?: number;
+  gravity?: [number, number];
+  drag?: number;
+  sizeStart?: number;
+  sizeEnd?: number;
+  colorStart?: string;
+  colorEnd?: string;
+  alphaStart?: number;
+  alphaEnd?: number;
+  blend?: "add" | "normal";
+}
+declare const PARTICLE_PRESETS: Record<string, ParticlePresetValues>;
+declare const PARTICLE_PRESET_NAMES: readonly string[];
+/**
+* Apply the delta rule across three layers: schema default < preset < the
+* scene's explicit props. A prop still equal to its SCHEMA default is
+* considered "unset" and takes the preset value.
+*/
+declare function applyParticlePreset(target: Record<string, unknown>, presetName: string, schema: PropSchema): void;
+//#endregion
+//#region src/core/preload.d.ts
+interface PreloadResult {
+  /** Urls whose fetch failed — show an error UI instead of pretending success. */
+  failed: string[];
+}
+/**
+* Warm the HTTP cache for a list of asset urls with a progress callback —
+* the loading-bar pattern every template ships. Failures only warn and still
+* count toward progress (a broken url must not block the game), but they are
+* reported in the result so callers can tell success from 100%-with-holes.
+*/
+declare function preloadUrls(urls: string[], onProgress?: (loaded: number, total: number) => void): Promise<PreloadResult>;
+/** Every url found in a scene's `assets` block (preload helper). */
+declare function assetUrls(assets: Record<string, {
+  url?: string;
+}> | undefined): string[];
+//#endregion
+//#region src/core/register.d.ts
+/**
+* Register the core node types. Call once in your game entry before loading
+* scenes. Registration is explicit — never an import-time side effect — so
+* bundler tree-shaking can never silently drop node types.
+*/
+declare function registerCoreNodes(): void;
+//#endregion
+//#region src/core/rendering-options.d.ts
+/**
+* Scene-declared rendering settings (`environment.rendering`): the scene JSON
+* carries them, so a loaded scene LOOKS the way it was authored everywhere —
+* the editor's play mode included.
+*
+* Precedence: explicit renderer constructor options > scene > renderer
+* fallback. `pixelRatio: "device"` resolves to the device pixel ratio.
+*/
+interface ResolvedRendering {
+  antialias: boolean;
+  pixelRatio: number;
+}
+declare function resolveRendering(environment: JsonObject | undefined, fallback: ResolvedRendering, devicePixelRatio: number, explicit?: {
+  antialias?: boolean;
+  pixelRatio?: number;
+}): ResolvedRendering;
+//#endregion
+//#region src/core/scene/constants.d.ts
+/** The single reserved key marking a prop value as a constant reference. */
+declare const CONST_REF_KEY = "@const";
+/** A `{"@const": "NAME"}` reference — exactly that one string key, nothing else. */
+declare function isConstRef(value: JsonValue | undefined): value is {
+  "@const": string;
+};
+/**
+* Deep-resolve every `{"@const": "NAME"}` reference in `value` to its literal
+* from `constants` (cloned, so the table is never aliased into node state).
+* Unknown names hard-fail — agents self-correct on hard errors.
+*/
+declare function resolveConstants<T extends JsonValue | undefined>(value: T, constants: Record<string, JsonValue> | undefined): T;
+//#endregion
+//#region src/core/scene/duplicate.d.ts
+/**
+* Deep-clone a node subtree (detached — add it wherever you like; sibling
+* auto-rename applies on attach). Implemented as serialize → rebuild so a
+* duplicate is exactly what would survive a save/load round-trip — EXCEPT
+* uids: clones are new entities and get a fresh identity (no uid), so
+* duplicating a uid'd template can never mint colliding ids. Names ARE
+* kept — rename clones you need to look up individually.
+*/
+declare function duplicateNode(node: Node): Node;
+//#endregion
+//#region src/core/scene/serializer.d.ts
+/**
+* Serialize a node subtree to scene JSON with delta-only props: values equal
+* to the type's schema defaults are omitted (Godot PackedScene behavior —
+* files stay tiny and AI-readable).
+*/
+declare function serializeNode(node: Node): NodeJson;
+//#endregion
+//#region src/core/touch.d.ts
+/**
+* Pure joystick math: drag offset (px) → normalized direction, deadzoned at
+* the center and clamped to unit length at the rim.
+*/
+declare function joystickVector(dx: number, dy: number, radius: number): {
+  x: number;
+  y: number;
+};
+interface DocumentLike {
+  createElement(tag: string): HTMLElement;
+}
+interface TouchControlsOptions {
+  /** Show even on non-touch environments (demos, tests). */
+  force?: boolean;
+  /** @internal Test seam — replaces `document`. */
+  doc?: DocumentLike;
+}
+/**
+* On-screen touch controls driven by the scene's own input map: every action
+* declared with `"touch": "joystick"` gets a left-side virtual stick feeding
+* `setActionVector`, every `"touch": "button"` a right-side button feeding
+* `pressAction`/`releaseAction`. The game never knows the difference between
+* touch and keyboard — both arrive as actions.
+*
+* `attachTouchControls(engine, container)` shows them automatically on
+* coarse-pointer devices ('auto' in createGame); `force` shows them anywhere.
+* The container should be `position: relative/absolute` over the canvas.
+*/
+declare function attachTouchControls(engine: Engine, container: HTMLElement, opts?: TouchControlsOptions): TouchControls | null;
+declare class TouchControls {
+  private readonly elements;
+  private readonly detachers;
+  constructor(engine: Engine, container: HTMLElement, controls: Array<{
+    action: string;
+    kind: "joystick" | "button";
+  }>, doc: DocumentLike);
+  dispose(): void;
+  private buildJoystick;
+  private buildButton;
+}
+//#endregion
+//#region src/core/uid-gen.d.ts
+/**
+* The ONE way to mint a node uid: crypto-strength, `n_` + 16 base36 chars
+* (~82 bits). Hand-written uids are forbidden by convention — they break the
+* collision-strength contract and read as fakes next to generated ones.
+*/
+declare function newUid(): string;
+//#endregion
+//#region src/core/viewport.d.ts
+type ViewportFit = "expand" | "letterbox" | "integer";
+interface ResolvedViewport {
+  /** Design resolution [width, height] — the world space the game is authored in. */
+  design: [number, number];
+  fit: ViewportFit;
+}
+/**
+* Parse + hard-validate a scene's `viewport` header. With a design resolution,
+* scene JSON owns layout again: the game is authored in fixed design pixels
+* and the renderer maps them onto whatever canvas size the page provides.
+*/
+declare function resolveViewport(viewport: JsonObject | undefined): ResolvedViewport | null;
+interface ComputedViewport {
+  /** Design-px → canvas-px scale factor. */
+  scale: number;
+  /** World pixels visible horizontally/vertically. */
+  viewW: number;
+  viewH: number;
+  /** Letterbox bar offsets in canvas px (0 for expand/integer). */
+  offsetX: number;
+  offsetY: number;
+  /** Canvas px actually covered by game content. */
+  contentW: number;
+  contentH: number;
+}
+/**
+* Pure viewport math (headless-testable):
+* - expand:    the design rect is always fully visible; extra world shows beyond it
+* - letterbox: EXACTLY the design rect, centered, bars elsewhere
+* - integer:   expand with whole-number scaling (pixel art), floored, min 1
+*/
+declare function computeViewport(canvasW: number, canvasH: number, viewport: {
+  design: [number, number] | readonly number[];
+  fit: ViewportFit;
+}): ComputedViewport;
+//#endregion
+//#region src/index.d.ts
+/** Engine version. Kept in sync with package.json by the release pipeline. */
+declare const VERSION: string;
+//#endregion
+export { AudioBuses, type AudioElementLike, AudioPlayer, Behavior, type BehaviorCtor, type BusName, CONST_REF_KEY, type ComputedViewport, type ConnectionJson, type CrossfadeGains, type DebugLineSource, Engine, type EngineOptions, type EngineStats, type GameStats, IncantoError, type IncantoErrorCode, type IncantoErrorDetails, InputMap, type JsonKind, type JsonObject, type JsonValue, type Listener, type LoadSceneOptions, type LogEntry, type LogLevel, LogManager, type MusicBackend, MusicManager, type MusicTrack, Node, type NodeCtor, type NodeJson, type NodeLifecycle, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, type ParsedNodePath, type ParticlePresetValues, ParticleSim, type ParticleSimConfig, type ParticleView, type PlayMusicOptions, type PreloadResult, type PropDef, type PropSchema, ROLLOFF_MODELS, type RendererStats, type ResolvedRendering, type ResolvedViewport, Rng, type RolloffModel, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, Scene, type SceneJson, SceneTree, type Scheduler, SfxEngine, type SfxParams, type SfxPlayOptions, type SfxWave, Signal, type SignalListener, type SpatialParams, type SynthOptions, Timer, TouchControls, type TouchControlsOptions, VERSION, type Vec3, type ViewportFit, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, crossfadeGains, duplicateNode, fadeGain, getBehavior, getNodeSchema, getNodeSignals, getNodeType, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, resolveConstants, resolveRendering, resolveViewport, serializeNode, spatialGain, spatialPan, synthSfx };

package/dist/index.js

@@ -0,0 +1,62 @@
+import { _ as registerBehavior, a as SCENE_FORMAT, c as SceneTree, d as resolveConstants, f as Node, g as getBehavior, h as clearBehaviors, i as serializeNode, l as CONST_REF_KEY, m as Behavior, n as loadScene, o as computeViewport, p as parseNodePath, r as Scene, s as resolveViewport, u as isConstRef, v as registeredBehaviors, y as Signal } from "./loader-CGs_G-r0.js";
+import { a as Engine, c as SfxEngine, d as WebAudioMusicBackend, f as crossfadeGains, i as applyParticlePreset, l as isAudioContextAvailable, m as AudioBuses, n as PARTICLE_PRESETS, o as LogManager, p as fadeGain, r as PARTICLE_PRESET_NAMES, s as InputMap, t as ParticleSim, u as MusicManager } from "./particle-sim-DYuSUxvK.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { t as Rng } from "./rng-DP-SR7eg.js";
+import { a as spatialGain, c as SFX_PRESET_NAMES, i as ROLLOFF_MODELS, l as synthSfx, n as Timer, o as spatialPan, r as AudioPlayer, s as SFX_PRESETS, t as registerCoreNodes } from "./register-BuUV1_KB.js";
+import { n as jsonEquals, r as jsonKind, t as jsonClone } from "./json-BLk7H2Qa.js";
+import { a as getNodeSignals, c as mergeStaticSignals, i as getNodeSchema, l as registerNode, n as clearRegistry, o as getNodeType, r as createNode, u as registeredTypes } from "./registry-BVJ2HbCn.js";
+import { t as createNoise2D } from "./noise-CGUMx44x.js";
+import { i as resolveRendering, n as attachTouchControls, r as joystickVector, t as TouchControls } from "./touch-031PxtCR.js";
+import { t as duplicateNode } from "./duplicate-DP2WPYom.js";
+//#region src/core/preload.ts
+/**
+* Warm the HTTP cache for a list of asset urls with a progress callback —
+* the loading-bar pattern every template ships. Failures only warn and still
+* count toward progress (a broken url must not block the game), but they are
+* reported in the result so callers can tell success from 100%-with-holes.
+*/
+async function preloadUrls(urls, onProgress) {
+	let loaded = 0;
+	const failed = [];
+	const total = urls.length;
+	if (total === 0) {
+		onProgress?.(0, 0);
+		return { failed };
+	}
+	await Promise.all(urls.map(async (url) => {
+		try {
+			await (await fetch(url)).arrayBuffer();
+		} catch (error) {
+			failed.push(url);
+			console.warn(`[incanto] preload failed for ${url}:`, error);
+		}
+		loaded += 1;
+		onProgress?.(loaded, total);
+	}));
+	return { failed };
+}
+/** Every url found in a scene's `assets` block (preload helper). */
+function assetUrls(assets) {
+	return Object.values(assets ?? {}).map((a) => a.url).filter((u) => typeof u === "string" && !u.startsWith("data:"));
+}
+//#endregion
+//#region src/core/uid-gen.ts
+/**
+* The ONE way to mint a node uid: crypto-strength, `n_` + 16 base36 chars
+* (~82 bits). Hand-written uids are forbidden by convention — they break the
+* collision-strength contract and read as fakes next to generated ones.
+*/
+function newUid() {
+	const bytes = new Uint8Array(16);
+	if (globalThis.crypto?.getRandomValues) globalThis.crypto.getRandomValues(bytes);
+	else for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+	let id = "";
+	for (const b of bytes) id += (b % 36).toString(36);
+	return `n_${id.slice(0, 16)}`;
+}
+//#endregion
+//#region src/index.ts
+/** Engine version. Kept in sync with package.json by the release pipeline. */
+const VERSION = "0.1.0";
+//#endregion
+export { AudioBuses, AudioPlayer, Behavior, CONST_REF_KEY, Engine, IncantoError, InputMap, LogManager, MusicManager, Node, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, ParticleSim, ROLLOFF_MODELS, Rng, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, Scene, SceneTree, SfxEngine, Signal, Timer, TouchControls, VERSION, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, crossfadeGains, duplicateNode, fadeGain, getBehavior, getNodeSchema, getNodeSignals, getNodeType, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, resolveConstants, resolveRendering, resolveViewport, serializeNode, spatialGain, spatialPan, synthSfx };

package/dist/json-BLk7H2Qa.js

@@ -0,0 +1,30 @@
+//#region src/core/json.ts
+function jsonKind(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean") return t;
+	return "object";
+}
+/** Deep structural equality over JSON values (used for delta-only serialization). */
+function jsonEquals(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => jsonEquals(v, b[i]));
+	if (a !== null && b !== null && typeof a === "object" && typeof b === "object") {
+		if (Array.isArray(a) || Array.isArray(b)) return false;
+		const ka = Object.keys(a);
+		const kb = Object.keys(b);
+		return ka.length === kb.length && ka.every((k) => k in b && jsonEquals(a[k], b[k]));
+	}
+	return false;
+}
+/**
+* Deep clone of JSON-safe data (defaults must never be shared between
+* instances). The value must contain only JSON types.
+*/
+function jsonClone(value) {
+	if (value === null || typeof value !== "object") return value;
+	return JSON.parse(JSON.stringify(value));
+}
+//#endregion
+export { jsonEquals as n, jsonKind as r, jsonClone as t };