@jgengine/core 0.10.0 → 0.12.0

package/dist/world/geometry.js

@@ -1,8 +1,61 @@
+function bandInfluence(dist, radius, feather) {
+    if (dist >= radius)
+        return 0;
+    const inner = radius - Math.max(0, feather);
+    return dist <= inner || feather <= 0 ? 1 : (radius - dist) / feather;
+}
+/** Perpendicular distance from a point to a polyline segment [a,b] on the XZ plane. */
+function distanceToSegment(px, pz, a, b) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    const lenSq = dx * dx + dz * dz || 1;
+    let t = ((px - a[0]) * dx + (pz - a[1]) * dz) / lenSq;
+    t = t < 0 ? 0 : t > 1 ? 1 : t;
+    return Math.hypot(px - (a[0] + dx * t), pz - (a[1] + dz * t));
+}
+/**
+ * How strongly a point falls inside a clearance zone: 1 at/inside the solid core, ramping to 0 at
+ * the zone's outer `radius` across its `feather` band, 0 outside. The max over all zones.
+ * @internal — the falloff math behind scatter avoid and terrain flatten.
+ */
+export function zoneInfluence(x, z, zones) {
+    let best = 0;
+    for (const zone of zones) {
+        const t = bandInfluence(Math.hypot(x - zone.x, z - zone.z), zone.radius, zone.feather ?? 0);
+        if (t > best)
+            best = t;
+    }
+    return best;
+}
+/** Clearance influence of a corridor: nearest-segment distance vs `halfWidth`, feathered. @internal */
+export function corridorInfluence(x, z, corridor) {
+    const { points, halfWidth } = corridor;
+    const feather = corridor.feather ?? 0;
+    let best = 0;
+    for (let i = 1; i < points.length; i += 1) {
+        const t = bandInfluence(distanceToSegment(x, z, points[i - 1], points[i]), halfWidth, feather);
+        if (t > best)
+            best = t;
+    }
+    return best;
+}
+/** Combined clearance influence of discs + corridors — the max over every mask. @internal */
+export function masksInfluence(x, z, masks) {
+    let best = zoneInfluence(x, z, masks.discs);
+    for (const corridor of masks.corridors) {
+        const t = corridorInfluence(x, z, corridor);
+        if (t > best)
+            best = t;
+    }
+    return best;
+}
+/** @internal */
 export function snapToGrid(point, size) {
     if (!(size > 0))
         return point;
     return [Math.round(point[0] / size) * size, Math.round(point[1] / size) * size];
 }
+/** @internal */
 export function footprintAabb(center, footprint, quarterTurns = 0) {
     const turned = ((quarterTurns % 2) + 2) % 2 === 1;
     const halfW = (turned ? footprint.d : footprint.w) / 2;
@@ -14,6 +67,7 @@ export function footprintAabb(center, footprint, quarterTurns = 0) {
         maxZ: center[1] + halfD,
     };
 }
+/** @internal */
 export function expandAabb(aabb, margin) {
     return {
         minX: aabb.minX - margin,
@@ -22,18 +76,22 @@ export function expandAabb(aabb, margin) {
         maxZ: aabb.maxZ + margin,
     };
 }
+/** @internal */
 export function aabbOverlap(a, b) {
     return a.minX < b.maxX && a.maxX > b.minX && a.minZ < b.maxZ && a.maxZ > b.minZ;
 }
+/** @internal */
 export function aabbContains(outer, inner) {
     return (inner.minX >= outer.minX &&
         inner.maxX <= outer.maxX &&
         inner.minZ >= outer.minZ &&
         inner.maxZ <= outer.maxZ);
 }
+/** @internal */
 export function pointInAabb(point, aabb) {
     return point[0] >= aabb.minX && point[0] <= aabb.maxX && point[1] >= aabb.minZ && point[1] <= aabb.maxZ;
 }
+/** @internal */
 export function clampToAabb(point, aabb) {
     return [
         Math.min(Math.max(point[0], aabb.minX), aabb.maxX),
@@ -62,6 +120,7 @@ function resolveAxis(main, cross, delta, blockers, axisX) {
     }
     return next;
 }
+/** @internal */
 export function resolveMove(from, delta, blockers, options = {}) {
     const radius = options.radius ?? 0;
     const expanded = radius === 0 ? blockers : blockers.map((blocker) => expandAabb(blocker, radius));
@@ -73,3 +132,38 @@ export function resolveMove(from, delta, blockers, options = {}) {
         z = Math.min(Math.max(z, options.bounds.minZ + radius), options.bounds.maxZ - radius);
     return [x, z];
 }
+function normalizedRadius2(point, ellipse) {
+    const nx = ellipse.radiusX > 0 ? (point[0] - ellipse.center[0]) / ellipse.radiusX : 0;
+    const ny = ellipse.radiusY > 0 ? (point[1] - ellipse.center[1]) / ellipse.radiusY : 0;
+    return nx * nx + ny * ny;
+}
+/** True when `point` sits inside (or on) the ellipse — the oval-arena containment test.
+ * @internal
+ */
+export function pointInEllipse(point, ellipse) {
+    return normalizedRadius2(point, ellipse) <= 1;
+}
+/** Clamp `point` to the ellipse boundary when it strays outside, else return it unchanged.
+ * @internal
+ */
+export function clampToEllipse(point, ellipse) {
+    const r2 = normalizedRadius2(point, ellipse);
+    if (r2 <= 1)
+        return point;
+    const scale = 1 / Math.sqrt(r2);
+    return [
+        ellipse.center[0] + (point[0] - ellipse.center[0]) * scale,
+        ellipse.center[1] + (point[1] - ellipse.center[1]) * scale,
+    ];
+}
+/** Outward unit normal of the ellipse at the point nearest `point` — the boundary bounce direction.
+ * @internal
+ */
+export function ellipseNormal(point, ellipse) {
+    const nx = ellipse.radiusX > 0 ? (point[0] - ellipse.center[0]) / (ellipse.radiusX * ellipse.radiusX) : 0;
+    const ny = ellipse.radiusY > 0 ? (point[1] - ellipse.center[1]) / (ellipse.radiusY * ellipse.radiusY) : 0;
+    const len = Math.hypot(nx, ny);
+    if (len < 1e-6)
+        return [1, 0];
+    return [nx / len, ny / len];
+}

package/dist/world/grassKind.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `grass_field` studio: a GPU grass patch authored as a box volume — its XZ footprint is the grass
+ * area, its top the ground height. Pure config here (blade/wind/color params + a footprint resolver);
+ * the instanced vertex-wind grass mesh lives in the `shell` renderer, which drives the existing
+ * `GrassField`. An engine environment kind (like water/scatter) so grass wind and colours are
+ * slider-authorable in the editor and persisted in `editor.scene.json` — the #813 grass studio.
+ *
+ * @capability grass-field editor-authorable GPU grass patch
+ */
+import { type ParamSchema, type SceneKindObject } from "../scene/sceneKinds.js";
+/** The editor volume kind marking a box as a GPU grass patch. */
+export declare const GRASS_FIELD_KIND = "grass_field";
+/** Fully-defaulted grass params parsed from a volume's `meta`. */
+export interface GrassRules {
+    /** Blades per square meter (the shell caps by an instance budget). */
+    density: number;
+    /** Blade height in meters. */
+    bladeHeight: number;
+    /** Base (root) color, hex. */
+    colorBase: string;
+    /** Tip color, hex. */
+    colorTip: string;
+    /** Per-blade color jitter, 0..1. */
+    colorVariation: number;
+    /** Vertex-wind sway strength, 0..1. */
+    windStrength: number;
+    /** Wind animation speed. */
+    windSpeed: number;
+    /** Gust patch scale (spatial frequency of gusts). */
+    windGust: number;
+    /** Blade material roughness, 0..1. */
+    roughness: number;
+    /** Seed string; same seed reproduces the same blade layout. */
+    seed: string;
+}
+/** Grass defaults: a lush, lightly-swaying meadow. */
+export declare const GRASS_DEFAULTS: GrassRules;
+/** The grass parameter schema — drives the inspector and `meta` parse via the studio seam. */
+export declare const GRASS_SCHEMA: ParamSchema;
+/** Parse a volume's `meta` into fully-defaulted grass rules. @internal */
+export declare function readGrassRules(meta: Record<string, unknown> | undefined): GrassRules;
+/** A resolved grass patch: world-space area center at ground height, footprint size (XZ), and rules. */
+export interface ResolvedGrass {
+    center: readonly [number, number, number];
+    size: readonly [number, number];
+    rules: GrassRules;
+}
+/** Resolve a grass volume into an area footprint (from box half-extents / radius) at the box base. @internal */
+export declare function resolveGrassObject(object: SceneKindObject): ResolvedGrass | null;
+/** Registers the `grass_field` scene kind (schema + resolver). Called by {@link registerBuiltinSceneKinds}. @internal */
+export declare function registerGrassKind(): void;

package/dist/world/grassKind.js

@@ -0,0 +1,101 @@
+/**
+ * `grass_field` studio: a GPU grass patch authored as a box volume — its XZ footprint is the grass
+ * area, its top the ground height. Pure config here (blade/wind/color params + a footprint resolver);
+ * the instanced vertex-wind grass mesh lives in the `shell` renderer, which drives the existing
+ * `GrassField`. An engine environment kind (like water/scatter) so grass wind and colours are
+ * slider-authorable in the editor and persisted in `editor.scene.json` — the #813 grass studio.
+ *
+ * @capability grass-field editor-authorable GPU grass patch
+ */
+import { registerSceneKind } from "../scene/sceneKinds.js";
+/** The editor volume kind marking a box as a GPU grass patch. */
+export const GRASS_FIELD_KIND = "grass_field";
+/** Grass defaults: a lush, lightly-swaying meadow. */
+export const GRASS_DEFAULTS = {
+    density: 12,
+    bladeHeight: 0.6,
+    colorBase: "#3f6f37",
+    colorTip: "#9ac25a",
+    colorVariation: 0.35,
+    windStrength: 0.22,
+    windSpeed: 1.6,
+    windGust: 0.16,
+    roughness: 0.85,
+    seed: "",
+};
+/** The grass parameter schema — drives the inspector and `meta` parse via the studio seam. */
+export const GRASS_SCHEMA = {
+    fields: [
+        { type: "range", key: "density", label: "density", min: 0.5, max: 160, step: 0.5, default: GRASS_DEFAULTS.density, unit: "/m²" },
+        { type: "range", key: "bladeHeight", label: "blade height", min: 0.1, max: 2, step: 0.05, default: GRASS_DEFAULTS.bladeHeight, unit: "m" },
+        { type: "color", key: "colorBase", label: "base color", default: GRASS_DEFAULTS.colorBase },
+        { type: "color", key: "colorTip", label: "tip color", default: GRASS_DEFAULTS.colorTip },
+        { type: "range", key: "colorVariation", label: "color variation", min: 0, max: 1, step: 0.02, default: GRASS_DEFAULTS.colorVariation },
+        { type: "range", key: "windStrength", label: "wind strength", min: 0, max: 1, step: 0.01, default: GRASS_DEFAULTS.windStrength },
+        { type: "range", key: "windSpeed", label: "wind speed", min: 0, max: 4, step: 0.05, default: GRASS_DEFAULTS.windSpeed },
+        { type: "range", key: "windGust", label: "gust scale", min: 0, max: 1, step: 0.02, default: GRASS_DEFAULTS.windGust },
+        { type: "range", key: "roughness", label: "roughness", min: 0, max: 1, step: 0.02, default: GRASS_DEFAULTS.roughness },
+        { type: "seed", key: "seed", label: "seed", default: "" },
+    ],
+};
+function metaNumber(meta, key, fallback) {
+    const value = meta?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function metaString(meta, key, fallback) {
+    const value = meta?.[key];
+    return typeof value === "string" ? value : fallback;
+}
+/** Parse a volume's `meta` into fully-defaulted grass rules. @internal */
+export function readGrassRules(meta) {
+    return {
+        density: Math.max(0, metaNumber(meta, "density", GRASS_DEFAULTS.density)),
+        bladeHeight: Math.max(0.05, metaNumber(meta, "bladeHeight", GRASS_DEFAULTS.bladeHeight)),
+        colorBase: metaString(meta, "colorBase", GRASS_DEFAULTS.colorBase),
+        colorTip: metaString(meta, "colorTip", GRASS_DEFAULTS.colorTip),
+        colorVariation: metaNumber(meta, "colorVariation", GRASS_DEFAULTS.colorVariation),
+        windStrength: metaNumber(meta, "windStrength", GRASS_DEFAULTS.windStrength),
+        windSpeed: metaNumber(meta, "windSpeed", GRASS_DEFAULTS.windSpeed),
+        windGust: metaNumber(meta, "windGust", GRASS_DEFAULTS.windGust),
+        roughness: metaNumber(meta, "roughness", GRASS_DEFAULTS.roughness),
+        seed: metaString(meta, "seed", GRASS_DEFAULTS.seed),
+    };
+}
+function axis(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Resolve a grass volume into an area footprint (from box half-extents / radius) at the box base. @internal */
+export function resolveGrassObject(object) {
+    const center = object.center ?? object.position;
+    if (center === undefined)
+        return null;
+    const he = object.halfExtents;
+    const radius = object.radius;
+    const halfX = axis(he?.x) ?? radius ?? 10;
+    const halfZ = axis(he?.z) ?? radius ?? 10;
+    const halfY = axis(he?.y) ?? 0;
+    return {
+        center: [center.x, center.y - halfY, center.z],
+        size: [Math.max(0.5, halfX * 2), Math.max(0.5, halfZ * 2)],
+        rules: readGrassRules(object.meta),
+    };
+}
+/** Registers the `grass_field` scene kind (schema + resolver). Called by {@link registerBuiltinSceneKinds}. @internal */
+export function registerGrassKind() {
+    registerSceneKind({
+        kind: GRASS_FIELD_KIND,
+        target: "volume",
+        label: "Grass field",
+        addCategory: "Studios",
+        accent: "#7fbf4d",
+        schema: GRASS_SCHEMA,
+        resolve: (object) => resolveGrassObject(object),
+        note: (object) => {
+            const resolved = resolveGrassObject(object);
+            if (resolved === null)
+                return "Give the volume a box footprint.";
+            const area = resolved.size[0] * resolved.size[1];
+            return `${Math.round(resolved.size[0])}×${Math.round(resolved.size[1])} m · ≈${Math.round(area * resolved.rules.density).toLocaleString()} blades`;
+        },
+    });
+}

package/dist/world/markers.d.ts

@@ -1,19 +1,32 @@
 export type MarkerPosition = readonly [number, number, number];
-export interface MapMarker<TMeta = unknown> {
+/**
+ * Small, display-only marker shape consumed by map renderers. Existing games
+ * can project their own entities to this view without adopting marker
+ * lifecycle storage or duplicating them into a {@link MarkerSet}.
+ */
+export interface MarkerView<TMeta = unknown> {
     id: string;
-    kind: string;
     position: MarkerPosition;
+    kind?: string;
     label?: string;
+    /** Optional world heading in radians for presentations that draw directional markers. */
+    heading?: number;
+    meta?: TMeta;
+}
+/** A marker owned by {@link MarkerSet}, including its lifecycle and query fields. */
+export interface MapMarker<TMeta = unknown> extends MarkerView<TMeta> {
+    kind: string;
     owner?: string;
     createdAt: number;
     expiresAt?: number;
-    meta?: TMeta;
 }
 export interface MarkerInput<TMeta = unknown> {
     id?: string;
     kind: string;
     position: MarkerPosition;
     label?: string;
+    /** Optional world heading in radians for directional map presentations. */
+    heading?: number;
     owner?: string;
     createdAt?: number;
     expiresAt?: number;
@@ -37,7 +50,7 @@ export interface MarkerKindStyle {
     priority: number;
 }
 export declare const DEFAULT_MARKER_KINDS: Record<string, MarkerKindStyle>;
-export declare function markerKindStyle(kind: string, styles?: Record<string, MarkerKindStyle>): MarkerKindStyle;
+export declare function markerKindStyle(kind: string | undefined, styles?: Record<string, MarkerKindStyle>): MarkerKindStyle;
 export interface MarkerSet<TMeta = unknown> {
     add(marker: MarkerInput<TMeta>): string;
     remove(id: string): boolean;
@@ -49,4 +62,37 @@ export interface MarkerSet<TMeta = unknown> {
     subscribe(listener: () => void): () => void;
     snapshot(): readonly MapMarker<TMeta>[];
 }
+/**
+ * Observable marker snapshots owned by an external project. `getSnapshot`
+ * must return the same array identity until the source changes and calls its
+ * subscribers, matching React's external-store contract.
+ */
+export interface MarkerSource<TMarker extends MarkerView = MarkerView> {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): readonly TMarker[];
+    /** Optional hydration snapshot; omit when the client snapshot is also valid during SSR. */
+    getServerSnapshot?: () => readonly TMarker[];
+}
+/** Marker data accepted by portable consumers: static views, an external source, or a native set. */
+export type MarkerCollection<TMarker extends MarkerView = MarkerView> = readonly TMarker[] | MarkerSource<TMarker> | MarkerSet;
+/** Configuration for projecting a caller-owned collection into display-only markers. */
+export interface MarkerSourceOptions<TEntity, TMarker extends MarkerView = MarkerView> {
+    /** Subscribe to changes in the caller-owned collection. Static collections may omit this. */
+    subscribe?: (listener: () => void) => () => void;
+    /** Read the current caller-owned collection. Keep its identity stable between changes. */
+    getSnapshot: () => readonly TEntity[];
+    /** Optional server collection used to keep hydration output deterministic. */
+    getServerSnapshot?: () => readonly TEntity[];
+    /** Project one caller-owned record into the minimal marker view. */
+    project: (value: TEntity, index: number) => TMarker;
+}
+/**
+ * Adapt a caller-owned array/store to an observable marker source. Projection
+ * is cached between source changes, so React reads do not copy the collection
+ * per frame. The caller retains ownership of entities, updates, persistence,
+ * and subscription scheduling.
+ *
+ * @capability portable-marker-source project caller-owned arrays or subscribable stores into cached minimap marker snapshots without a MarkerSet
+ */
+export declare function createMarkerSource<TEntity, TMarker extends MarkerView = MarkerView>(options: MarkerSourceOptions<TEntity, TMarker>): MarkerSource<TMarker>;
 export declare function createMarkerSet<TMeta = unknown>(now?: () => number): MarkerSet<TMeta>;

package/dist/world/markers.js

@@ -10,8 +10,55 @@ export const DEFAULT_MARKER_KINDS = {
     ping: { id: "ping", color: "#22d3ee", glyph: "◎", priority: 65 },
 };
 export function markerKindStyle(kind, styles = DEFAULT_MARKER_KINDS) {
+    if (kind === undefined)
+        return { id: "marker", color: "#e2e8f0", glyph: "\u2022", priority: 30 };
     return styles[kind] ?? { id: kind, color: "#e2e8f0", glyph: "•", priority: 30 };
 }
+function projectedSnapshot(readSource, project) {
+    let dirty = true;
+    let source;
+    let snapshot = [];
+    return {
+        invalidate() {
+            dirty = true;
+        },
+        read() {
+            const next = readSource();
+            if (dirty || next !== source) {
+                source = next;
+                snapshot = next.map(project);
+                dirty = false;
+            }
+            return snapshot;
+        },
+    };
+}
+/**
+ * Adapt a caller-owned array/store to an observable marker source. Projection
+ * is cached between source changes, so React reads do not copy the collection
+ * per frame. The caller retains ownership of entities, updates, persistence,
+ * and subscription scheduling.
+ *
+ * @capability portable-marker-source project caller-owned arrays or subscribable stores into cached minimap marker snapshots without a MarkerSet
+ */
+export function createMarkerSource(options) {
+    const client = projectedSnapshot(options.getSnapshot, options.project);
+    const server = options.getServerSnapshot === undefined
+        ? client
+        : projectedSnapshot(options.getServerSnapshot, options.project);
+    return {
+        subscribe(listener) {
+            if (options.subscribe === undefined)
+                return () => undefined;
+            return options.subscribe(() => {
+                client.invalidate();
+                listener();
+            });
+        },
+        getSnapshot: client.read,
+        getServerSnapshot: server.read,
+    };
+}
 function distanceXZ(a, b) {
     return Math.hypot(a[0] - b[0], a[2] - b[2]);
 }
@@ -38,6 +85,8 @@ export function createMarkerSet(now = Date.now) {
             };
             if (input.label !== undefined)
                 marker.label = input.label;
+            if (input.heading !== undefined)
+                marker.heading = input.heading;
             if (input.owner !== undefined)
                 marker.owner = input.owner;
             if (input.expiresAt !== undefined)

package/dist/world/massing.js

@@ -1,3 +1,4 @@
+import { clamp } from "../math/scalar.js";
 export const MASSING_COMPOSITIONS = [
     "bar",
     "split",
@@ -17,7 +18,6 @@ export const MASSING_PROFILES = [
     "offset",
     "twisted",
 ];
-const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
 export const hashMassingSeed = (text) => [...text].reduce((sum, ch) => sum + ch.charCodeAt(0), 0);
 export const massingBase = (spec, cap = 0.28) => Math.min(Math.max(0, spec.pilotis), Math.max(0, spec.height) * cap);
 export const isVillageMassing = (spec) => spec.composition === "cluster" && spec.height < 36 && spec.articulation > 56 && spec.moduleDensity > 2;

package/dist/world/minimapBake.d.ts

@@ -0,0 +1,78 @@
+import type { Vec2 } from "./geometry.js";
+/**
+ * Deterministic minimap terrain bake (#1036): rasterize an authored world's terrain (plus optional
+ * biome zones and water) into a top-down RGBA image and a matching world-bounds rectangle, then
+ * encode it as a PNG data URI. The editor runs this as a bake action and stores the result on the
+ * scene document; runtime feeds it straight into the existing `Minimap` / `WorldMap` `background` +
+ * `mapBounds` props — no new runtime render path, and the same authored world always bakes the same
+ * image (safe for verify/CI). Pure: no canvas, no DOM, `core` still imports nothing external.
+ */
+/** World-space rectangle the bake spans (matches the react `MapBounds` shape structurally). */
+export interface MinimapBakeBounds {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+}
+/** One biome/region tint painted over the terrain shade where the ground falls inside its polygon. */
+export interface MinimapBakeZone {
+    /** Closed XZ polygon in world space. */
+    polygon: readonly Vec2[];
+    /** `#rgb` / `#rrggbb` tint. */
+    color: string;
+    /** Blend strength 0..1. Default 0.5. */
+    alpha?: number;
+}
+/** The authored world a bake reads — a height sampler, its bounds, and optional zones/water. */
+export interface MinimapBakeSource {
+    bounds: MinimapBakeBounds;
+    sampleHeight(x: number, z: number): number;
+    /** Optional surface normal for slope shading; flat shading when omitted. */
+    sampleNormal?(x: number, z: number): readonly [number, number, number];
+    zones?: readonly MinimapBakeZone[];
+    /** Ground at or below this height renders as water. */
+    waterLevel?: number;
+}
+/** The height→color ramp and water color used by the bake. */
+export interface MinimapBakePalette {
+    low: string;
+    high: string;
+    water: string;
+}
+/** The built-in height→color ramp and water color a bake uses when no palette override is given. */
+export declare const DEFAULT_MINIMAP_PALETTE: MinimapBakePalette;
+/** Options for {@link bakeMinimapImage}. */
+export interface MinimapBakeOptions {
+    /** Pixel resolution of the longer axis; the shorter axis keeps world aspect. Default 128. */
+    resolution?: number;
+    palette?: Partial<MinimapBakePalette>;
+}
+/** A baked minimap image: RGBA pixels plus the world bounds they span. */
+export interface MinimapBake {
+    width: number;
+    height: number;
+    /** Row-major RGBA, length `width * height * 4`. */
+    pixels: Uint8ClampedArray;
+    bounds: MinimapBakeBounds;
+}
+/**
+ * Rasterizes a top-down terrain image: height maps onto a low→high color ramp (normalized over the
+ * sampled height range), slope darkens the shade, water fills below `waterLevel`, and each zone
+ * polygon tints the ground it covers. Deterministic for a fixed source. The bounds are preserved so
+ * a player-centered minimap pans the image correctly.
+ * @capability minimap-bake rasterize authored terrain + zones into a top-down minimap image
+ */
+export declare function bakeMinimapImage(source: MinimapBakeSource, options?: MinimapBakeOptions): MinimapBake;
+/** Encodes an RGBA bake to raw PNG bytes (pure; stored DEFLATE, valid for any decoder). */
+export declare function encodeBakePng(bake: MinimapBake): Uint8Array;
+/**
+ * Encodes a bake as a `data:image/png;base64,...` URI — the exact string the `Minimap` /
+ * `WorldMap` `background` prop takes. Deterministic for a fixed bake.
+ * @capability minimap-bake encode a baked minimap as a PNG data URI for the Minimap background
+ */
+export declare function minimapBakeToPngDataUri(bake: MinimapBake): string;
+/** One-call convenience: rasterize a source and return `{ background, mapBounds }` for a minimap. */
+export declare function bakeMinimapBackground(source: MinimapBakeSource, options?: MinimapBakeOptions): {
+    background: string;
+    mapBounds: MinimapBakeBounds;
+};