@nayan-ui/engine 0.0.0-stage → 1.0.0-beta.4

package/lib/module/world/effects.js

@@ -0,0 +1,463 @@
+"use strict";
+
+// Ready-made particle effects and the cleared-piece pop, built from `world.burst` and `world.animate`.
+//
+// A single burst gives every particle 50..100% of one top speed, so on its own it flies out as a
+// hollow shell of same-sized bits that pop out of existence. These effects mix a few bursts instead:
+// slow big pieces that fill the middle and fast small ones at the edge, an additive glow that flashes
+// at the source (visible on dark scenes, harmless on light ones), and soft puffs that linger and fade.
+// Every particle takes a world slot, out of the capacity shared with the game's own entities, so the
+// counts stay close to what was passed in. Effects run entirely in the Rust core after one call each.
+
+import { resolveColor, resolveColors } from "./color.js";
+
+/** Shared options of the layered effects (confetti, sparkle, shatter, splash, sparks, explosion). */
+
+/** A soft cloud of puffs that swell and fade: landing dust, kicked-up sand, sawdust, steam, muzzle smoke. */
+
+/** One glow that swells and fades at a point: a hit, a strike, a muzzle flash. */
+
+/** The cleared-piece pop: swell, flash white, settle, shrink away. */
+
+const rgba = input => {
+  const c = resolveColor(input);
+  return [c[0], c[1], c[2], c[3] ?? 1];
+};
+const list = colors => resolveColors(colors).map(rgba);
+const part = (count, share) => Math.max(1, Math.round(count * share));
+const fade = input => {
+  const c = resolveColor(input);
+  return [c[0], c[1], c[2], 0];
+};
+
+/** The colors' average. */
+function mean(colors) {
+  const sum = [0, 0, 0, 0];
+  for (const c of colors) for (let i = 0; i < 4; i++) sum[i] += c[i];
+  return sum.map(v => v / colors.length);
+}
+
+/** The same hue, self-lit: its brightest channel lifted to `peak` (above 1 glows, through light, shadow and fog). */
+function hot(input, peak = 2.2, alpha) {
+  const c = resolveColor(input);
+  alpha ??= c[3] ?? 1;
+  const k = peak / Math.max(c[0], c[1], c[2], 0.25);
+  return [c[0] * k, c[1] * k, c[2] * k, alpha];
+}
+
+/** Part way (`t`, 0..1) to white, with `alpha`. */
+function pale(input, t, alpha) {
+  const c = resolveColor(input);
+  alpha ??= c[3] ?? 1;
+  return [c[0] + (1 - c[0]) * t, c[1] + (1 - c[1]) * t, c[2] + (1 - c[2]) * t, alpha];
+}
+function aim(e) {
+  return {
+    position: e.position,
+    direction: e.direction ?? [0, 1, 0],
+    spread: e.spread ?? Math.PI
+  };
+}
+function flash(world, o) {
+  return world.burst({
+    position: o.position,
+    count: o.count ?? 1,
+    mesh: o.mesh ?? 'flame',
+    size: o.size,
+    speed: o.speed ?? 0,
+    lifetime: o.lifetime ?? 0.22,
+    gravity: 0,
+    color: o.color,
+    endSize: o.endSize ?? 2.2,
+    endColor: o.endColor ?? fade(o.color)
+  });
+}
+
+/** A glow that swells and fades at the source, in the effect's own hue. */
+function glowFlash(world, e, colors, size) {
+  flash(world, {
+    position: e.position,
+    color: hot(mean(colors), 2, 0.85),
+    size
+  });
+}
+function dust(world, o) {
+  const colors = resolveColors(o.color);
+  return world.burst({
+    position: o.position,
+    count: o.count,
+    mesh: o.mesh ?? 'puff',
+    size: o.size,
+    speed: o.speed,
+    lifetime: o.lifetime,
+    gravity: o.gravity ?? 0,
+    direction: o.direction,
+    spread: o.spread,
+    color: colors.length === 1 ? colors[0] : colors,
+    endSize: o.endSize ?? 2,
+    endColor: o.endColor ?? (colors.length === 1 ? fade(colors[0]) : undefined)
+  });
+}
+
+/** Celebration confetti: tumbling paper in two layers, a few glinting sparkles, and a pop of light. */
+function confetti(world, e) {
+  const colors = list(e.colors);
+  const g = (e.gravity ?? 0) * 0.65; // paper drifts down rather than dropping
+  const base = {
+    ...aim(e),
+    mesh: 'cube',
+    gravity: g,
+    color: colors,
+    endSize: 0.3
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.55),
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime * 1.15
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.3),
+    size: e.size * 0.7,
+    speed: e.speed * 0.5,
+    lifetime: e.lifetime
+  });
+  const glint = colors.slice(0, 4).map(c => hot(pale(c, 0.5, 1), 2.4));
+  world.burst({
+    ...aim(e),
+    count: part(e.count, 0.15),
+    mesh: 'flame',
+    size: e.size * 1.1,
+    speed: e.speed * 0.8,
+    lifetime: e.lifetime * 0.8,
+    gravity: g * 0.5,
+    color: glint,
+    endSize: 0
+  });
+  if (e.flash !== false) glowFlash(world, e, [[1, 0.95, 0.8, 1]], e.size * 7);
+}
+
+/** Glitter for a reward: solid bright beads (seen on any background) with additive glints around them. */
+function sparkle(world, e) {
+  const colors = list(e.colors);
+  const bright = colors.map(c => hot(c, 1.4));
+  const base = {
+    ...aim(e),
+    gravity: e.gravity ?? 0,
+    endSize: 0
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.35),
+    mesh: 'sphere',
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime,
+    color: bright
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.25),
+    mesh: 'sphere',
+    size: e.size * 1.3,
+    speed: e.speed * 0.45,
+    lifetime: e.lifetime * 0.85,
+    color: bright
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.4),
+    mesh: 'flame',
+    size: e.size * 1.6,
+    speed: e.speed * 0.8,
+    lifetime: e.lifetime * 0.9,
+    color: colors.map(c => hot(pale(c, 0.35, 1), 2.4))
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 6);
+}
+
+/**
+ * Something breaking apart: big slow chunks, small fast crumbs, a glow at the break and a puff of
+ * its dust. `mesh` is the chunks' shape.
+ */
+function shatter(world, e) {
+  const colors = list(e.colors);
+  const mesh = e.mesh ?? 'cube';
+  const base = {
+    ...aim(e),
+    gravity: e.gravity ?? 0,
+    color: colors
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.55),
+    mesh,
+    size: e.size * 1.1,
+    speed: e.speed * 0.65,
+    lifetime: e.lifetime,
+    endSize: 0.2
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.6),
+    mesh,
+    size: e.size * 0.5,
+    speed: e.speed * 1.1,
+    lifetime: e.lifetime * 0.85,
+    endSize: 0
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 3);
+  if (e.dust !== false) {
+    const c = pale(mean(colors), 0.45, 0.5);
+    world.burst({
+      ...aim(e),
+      count: 2,
+      mesh: 'puff',
+      size: e.size * 2,
+      speed: e.speed * 0.2,
+      lifetime: e.lifetime * 0.9,
+      gravity: 0,
+      color: c,
+      endSize: 2.4,
+      endColor: fade(c)
+    });
+  }
+}
+
+/** Liquid: droplets in two sizes thrown out of a fine mist of the same color. */
+function splash(world, e) {
+  const colors = list(e.colors);
+  const base = {
+    ...aim(e),
+    mesh: 'sphere',
+    gravity: e.gravity ?? 0,
+    color: colors
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.6),
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime,
+    endSize: 0.3
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.4),
+    size: e.size * 1.5,
+    speed: e.speed * 0.45,
+    lifetime: e.lifetime * 0.8,
+    endSize: 0.2
+  });
+  const mist = pale(mean(colors), 0.2, 0.55);
+  world.burst({
+    ...aim(e),
+    count: 3,
+    mesh: 'puff',
+    size: e.size * 3,
+    speed: e.speed * 0.25,
+    lifetime: e.lifetime * 0.7,
+    gravity: 0,
+    color: mist,
+    endSize: 2.2,
+    endColor: fade(mist)
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 4);
+}
+
+/** Hot metal sparks: additive streaks that burn out, with a few solid beads and a flash where they strike. */
+function sparks(world, e) {
+  const colors = list(e.colors).map(c => hot(c, 2.6));
+  const base = {
+    ...aim(e),
+    gravity: e.gravity ?? 0,
+    color: colors,
+    endSize: 0
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.7),
+    mesh: 'flame',
+    size: e.size * 1.6,
+    speed: e.speed,
+    lifetime: e.lifetime
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.3),
+    mesh: 'sphere',
+    size: e.size * 0.6,
+    speed: e.speed * 1.1,
+    lifetime: e.lifetime * 0.8
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 5);
+}
+const FIRE = [[2.6, 2.4, 1.8, 1], [2.4, 1.5, 0.45, 0.95], [2.2, 0.8, 0.2, 0.85]];
+const EMBERS = [[2.8, 2.2, 1, 1], [2.6, 1.3, 0.3, 1]];
+
+/**
+ * A fiery blast: a white-hot flash, a fireball that cools into smoke, embers thrown out and, given
+ * `debris` colors, chunks of whatever blew up. `size` is the fireball's puff size; `colors` its fire.
+ * The fire and smoke swell every way; `direction`, `spread` and `gravity` aim the embers and debris.
+ */
+function explosion(world, e) {
+  const fire = list(e.colors ?? FIRE);
+  const smoke = rgba(e.smoke ?? [0.28, 0.25, 0.24, 0.6]);
+  const g = e.gravity ?? 0;
+  const around = {
+    position: e.position,
+    spread: Math.PI,
+    gravity: 0
+  };
+  if (e.flash !== false) {
+    flash(world, {
+      position: e.position,
+      color: [3, 2.7, 2.1, 1],
+      size: e.size * 1.6,
+      lifetime: 0.2,
+      endSize: 2,
+      endColor: [2.4, 0.9, 0.2, 0]
+    });
+  }
+  world.burst({
+    ...around,
+    count: part(e.count, 0.5),
+    mesh: 'puff',
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime,
+    color: fire,
+    endSize: 2.2,
+    endColor: [smoke[0], smoke[1], smoke[2], 0]
+  });
+  world.burst({
+    ...around,
+    count: part(e.count, 0.2),
+    mesh: 'flame',
+    size: e.size * 0.8,
+    speed: e.speed * 0.5,
+    lifetime: e.lifetime * 0.6,
+    color: fire,
+    endSize: 1.8,
+    endColor: [2, 0.5, 0.1, 0]
+  });
+  world.burst({
+    ...around,
+    count: part(e.count, 0.25),
+    mesh: 'puff',
+    size: e.size * 0.9,
+    speed: e.speed * 0.6,
+    lifetime: e.lifetime * 1.7,
+    color: smoke,
+    endSize: 2.8,
+    endColor: fade(smoke)
+  });
+  world.burst({
+    ...aim(e),
+    count: part(e.count, 0.4),
+    mesh: 'flame',
+    size: e.size * 0.12,
+    speed: e.speed * 2.4,
+    lifetime: e.lifetime * 0.9,
+    gravity: g,
+    color: EMBERS,
+    endSize: 0
+  });
+  if (e.debris) {
+    world.burst({
+      ...aim(e),
+      count: part(e.count, 0.5),
+      mesh: 'cube',
+      size: e.size * 0.16,
+      speed: e.speed * 1.8,
+      lifetime: e.lifetime * 1.2,
+      gravity: g,
+      color: e.debris,
+      endSize: 0.3
+    });
+  }
+}
+const WHITE_HOT = [2, 2, 2, 1]; // above 1 glows
+const WHITE = [1, 1, 1, 1];
+const POP_TIME = 0.5;
+const times = (scale, k) => typeof scale === 'number' ? scale * k : [scale[0] * k, scale[1] * k, scale[2] * k];
+
+/** The piece swells, flashes white, settles and shrinks away. Resolves when it's gone (despawning it is the caller's). */
+function pop(world, entity, o) {
+  const delay = o.delay ?? 0;
+  const duration = o.duration ?? POP_TIME;
+  const flashFor = {
+    duration: duration * 0.3,
+    delay
+  };
+  world.stopAnimation(entity); // whatever it was doing (landing, falling, wobbling) gives way
+  if (o.color) world.animate(entity, [{
+    color: WHITE_HOT,
+    at: 0.33
+  }, {
+    color: o.color
+  }], flashFor);
+  if (o.flash?.length) world.animate(o.flash, [{
+    color: WHITE_HOT,
+    at: 0.33
+  }, {
+    color: WHITE
+  }], flashFor);
+  const s = o.scale;
+  return world.animate(entity, [{
+    scale: times(s, 1.35),
+    at: 0.15
+  }, {
+    scale: times(s, 0.9),
+    at: 0.25
+  }, {
+    scale: times(s, 1),
+    at: 0.35
+  }, {
+    scale: times(s, 0)
+  }], {
+    duration,
+    delay
+  });
+}
+
+/**
+ * Ready-made effects. Each is one call; particles then live, fall, shrink and recolor in Rust.
+ *
+ * ```ts
+ * effects.confetti(world, { position, colors: [RED, GOLD], size: 0.12, speed: 6, count: 40, lifetime: 1.2, gravity: -6 });
+ * effects.dust(world, { position: feet, color: [0.8, 0.75, 0.65, 0.6], size: 0.3, speed: 1.5, count: 6, lifetime: 0.5 });
+ * effects.flash(world, { position: hit, color: effects.hot(ORANGE), size: 0.8 });
+ * await effects.pop(world, candy, { scale: 1, color: RED });
+ * world.despawn(candy);
+ * ```
+ */
+export const effects = {
+  /** Celebration: tumbling paper, glints and a pop of light (wins, level-ups). */
+  confetti,
+  /** Reward glitter: bright beads and glints (pickups, perfect moves). */
+  sparkle,
+  /** Breaking apart: chunks, crumbs, a glow and dust (bricks, crates, glass). `mesh` shapes the chunks. */
+  shatter,
+  /** Liquid: droplets and mist (water, juice, paint). */
+  splash,
+  /** Hot metal: additive streaks and beads (scrapes, strikes, electricity). */
+  sparks,
+  /** Fiery blast: flash, fireball cooling to smoke, embers and optional debris. */
+  explosion,
+  /** Soft swelling puffs: dust, sand, sawdust, steam, smoke. */
+  dust,
+  /** One swelling glow: hits, strikes, muzzle flashes. */
+  flash,
+  /** The cleared-piece animation: swell, flash white, settle, shrink to nothing. */
+  pop,
+  /** Default `pop` duration in seconds. */
+  POP_TIME,
+  /** The same hue made self-lit (brightest channel lifted to `peak`), for glows. */
+  hot,
+  /** Part way (`t`, 0..1) to white. */
+  pale
+};
+//# sourceMappingURL=effects.js.map

package/lib/module/world/quat.js

@@ -0,0 +1,86 @@
+"use strict";
+
+/** A writable quaternion; pass one as `out` to reuse it instead of allocating. */
+
+const result = (out, x, y, z, w) => {
+  if (!out) return [x, y, z, w];
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+};
+
+/**
+ * Quaternion helpers for `rotation` options, keyframes and geometry parts ([x, y, z, w]). Every
+ * function takes an optional `out` so per-frame code can reuse one array instead of allocating.
+ *
+ * ```ts
+ * world.set(car, { rotation: quat.y(heading) });
+ * const spin = quat.multiply(quat.y(yaw), quat.x(pitch), scratch); // pitch first, then yaw
+ * ```
+ */
+export const quat = {
+  /** No rotation. */
+  identity: Object.freeze([0, 0, 0, 1]),
+  /** Rotation by `angle` radians around the unit axis (x, y, z). */
+  axisAngle(x, y, z, angle, out) {
+    const s = Math.sin(angle / 2);
+    return result(out, x * s, y * s, z * s, Math.cos(angle / 2));
+  },
+  /** Rotation around the x axis (pitch). */
+  x(angle, out) {
+    return result(out, Math.sin(angle / 2), 0, 0, Math.cos(angle / 2));
+  },
+  /** Rotation around the y axis (yaw, heading). */
+  y(angle, out) {
+    return result(out, 0, Math.sin(angle / 2), 0, Math.cos(angle / 2));
+  },
+  /** Rotation around the z axis (roll; spin for 2D games looking down -z). */
+  z(angle, out) {
+    return result(out, 0, 0, Math.sin(angle / 2), Math.cos(angle / 2));
+  },
+  /** `a` after `b`: `b` turns first. `out` may be `a` or `b`. */
+  multiply(a, b, out) {
+    const [ax, ay, az, aw] = a;
+    const [bx, by, bz, bw] = b;
+    return result(out, aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw, aw * bw - ax * bx - ay * by - az * bz);
+  },
+  /** Turns around x, then y, then z (radians): the same as `multiply(z(z), multiply(y(y), x(x)))`. */
+  fromEuler(x, y, z, out) {
+    const sx = Math.sin(x / 2);
+    const cx = Math.cos(x / 2);
+    const sy = Math.sin(y / 2);
+    const cy = Math.cos(y / 2);
+    const sz = Math.sin(z / 2);
+    const cz = Math.cos(z / 2);
+    return result(out, sx * cy * cz - cx * sy * sz, cx * sy * cz + sx * cy * sz, cx * cy * sz - sx * sy * cz, cx * cy * cz + sx * sy * sz);
+  },
+  /** Shortest-path interpolation from `a` (t = 0) to `b` (t = 1). */
+  slerp(a, b, t, out) {
+    let [bx, by, bz, bw] = b;
+    let cos = a[0] * bx + a[1] * by + a[2] * bz + a[3] * bw;
+    if (cos < 0) {
+      cos = -cos;
+      bx = -bx;
+      by = -by;
+      bz = -bz;
+      bw = -bw;
+    }
+    let k0 = 1 - t;
+    let k1 = t;
+    if (cos < 0.9995) {
+      const angle = Math.acos(cos);
+      const sin = Math.sin(angle);
+      k0 = Math.sin(k0 * angle) / sin;
+      k1 = Math.sin(k1 * angle) / sin;
+    }
+    const x = k0 * a[0] + k1 * bx;
+    const y = k0 * a[1] + k1 * by;
+    const z = k0 * a[2] + k1 * bz;
+    const w = k0 * a[3] + k1 * bw;
+    const length = Math.hypot(x, y, z, w) || 1;
+    return result(out, x / length, y / length, z / length, w / length);
+  }
+};
+//# sourceMappingURL=quat.js.map

package/lib/module/world/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/assets/AssetBytesCache.d.ts

@@ -0,0 +1,7 @@
+/** Share concurrent requests across loader variants; failed requests can always be retried. */
+export declare function assetBytes(key: string, load: () => Promise<ArrayBuffer>): Promise<ArrayBuffer>;
+/** A decoder rejected the payload: a later load must fetch fresh bytes, not replay bad data. */
+export declare function forgetAssetBytes(key: string | undefined): void;
+/** Clearing disk must also prevent an earlier request from retaining its old bytes. */
+export declare function clearAssetBytes(): void;
+//# sourceMappingURL=AssetBytesCache.d.ts.map

package/lib/typescript/src/assets/AssetCache.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Explicitly removes the engine's saved geometry and original model/texture/font/audio files.
+ * Also clears temporary download bytes. Existing worlds and loaded handles remain usable;
+ * registrations are session resources and will be rebuilt/reloaded on a future app launch.
+ * Custom ProceduralStorage adapters belong to their host and are not cleared by this function.
+ * Rejects if storage cannot be cleared, allowing a settings screen to report the failure.
+ */
+export declare function clearAssetCache(): Promise<void>;
+//# sourceMappingURL=AssetCache.d.ts.map

package/lib/typescript/src/assets/AssetLoader.d.ts

@@ -0,0 +1,11 @@
+import type { EngineBridge } from '../native/EngineBridge.js';
+import { type AssetSource } from './source';
+/** Shared session handles; source-byte persistence stays in AssetBytesCache and Rust. */
+export declare class AssetLoader<T> {
+    private readonly name;
+    private readonly loads;
+    constructor(name: string);
+    load(source: AssetSource, decode: (native: EngineBridge, bytes: ArrayBuffer) => T | Promise<T>, variant?: readonly (string | number | boolean)[]): Promise<T>;
+    private error;
+}
+//# sourceMappingURL=AssetLoader.d.ts.map

package/lib/typescript/src/assets/CacheGeneration.d.ts

@@ -0,0 +1,3 @@
+export declare const cacheGeneration: () => number;
+export declare const advanceCacheGeneration: () => number;
+//# sourceMappingURL=CacheGeneration.d.ts.map

package/lib/typescript/src/assets/IndexedDbCache.web.d.ts

@@ -0,0 +1,20 @@
+export declare class IndexedDbCache {
+    private readonly database;
+    private tail;
+    private pending;
+    private generation;
+    private clearOperation;
+    private constructor();
+    static open(): Promise<IndexedDbCache>;
+    private enqueue;
+    /** The Uint8Array is an owned copy made by Rust, never a view into growable WASM memory. */
+    write(name: string, bytes: Uint8Array, geometry: boolean): Promise<void>;
+    read(name: string): Promise<Uint8Array | undefined>;
+    remove(name: string): Promise<void>;
+    clear(): Promise<void>;
+    flush(): Promise<void>;
+    cleared(): Promise<void>;
+    /** Read recent geometry only. Large source files remain in IndexedDB until requested by a loader. */
+    warm(canFit: (size: number) => boolean, restore: (name: string, bytes: Uint8Array) => boolean): Promise<void>;
+}
+//# sourceMappingURL=IndexedDbCache.web.d.ts.map

package/lib/typescript/src/assets/ProceduralCache.d.ts

@@ -0,0 +1,45 @@
+/** Optional storage override. The engine selects a best-effort platform cache by default. */
+export interface ProceduralStorage {
+    read(key: string): Uint8Array | null;
+    write(key: string, bytes: Uint8Array): void | Promise<void>;
+    /**
+     * The store itself verifies every record's integrity (the engine's own Rust store checksums each
+     * one with SHA-256), so the cache needn't checksum and scan them again in JS. Geometry is still
+     * validated by the core when it's registered.
+     */
+    readonly verified?: boolean;
+}
+/**
+ * Persists the output of a deterministic model factory, including nested model arrays/objects.
+ * Hits register saved vertices directly: no procedural tessellation, painting or optimization.
+ * Imported/skinned/textured models are intentionally excluded; their own loaders retain their rigs.
+ */
+export declare class ProceduralCache {
+    readonly revision: string;
+    private storage;
+    private memory;
+    private hits;
+    private builds;
+    private invalid;
+    private failures;
+    private writes;
+    constructor(revision: string, storage?: ProceduralStorage | undefined);
+    get stats(): {
+        hits: number;
+        builds: number;
+        invalid: number;
+        failures: number;
+        pendingWrites: number;
+    };
+    flush(): Promise<void>;
+    /**
+     * A value already cached (in memory, or saved by an earlier launch), without building anything:
+     * undefined when there is none yet. Lets work that's spread over many frames (a level generated
+     * step by step) skip itself entirely when a saved result exists, then save with `get`.
+     */
+    peek<T>(key: string): T | undefined;
+    get<T>(key: string, build: () => T): T;
+    private encode;
+    private restore;
+}
+//# sourceMappingURL=ProceduralCache.d.ts.map