@jgengine/core 0.11.0 → 0.13.0

package/dist/world/environmentSummary.js

@@ -1,7 +1,11 @@
-import { generateBuildingDistrict, resolveBuildingPalette, } from "./buildings.js";
+import { DEFAULT_BUILDING_CONFIG, generateBuilding, generateBuildingDistrict, resolveBuildingPalette, } from "./buildings.js";
+import { deriveBuildingLots } from "./buildingLots.js";
 import { pathLength } from "./roads.js";
 import { resolveTerrainField, resolveTerrainPalette } from "./terrain.js";
 export function resolveStructureBuildings(descriptor) {
+    if (descriptor.along !== undefined) {
+        return resolveFrontageBuildings(descriptor, descriptor.along);
+    }
     const columns = Math.max(1, Math.ceil(Math.sqrt(descriptor.count)));
     const rows = Math.max(1, Math.ceil(descriptor.count / columns));
     const spacing = descriptor.spacing;
@@ -21,6 +25,58 @@ export function resolveStructureBuildings(descriptor) {
         ...(descriptor.seed === undefined ? {} : { seed: descriptor.seed }),
     }).slice(0, descriptor.count);
 }
+function hashU32(input) {
+    let hash = 2166136261;
+    for (let i = 0; i < input.length; i += 1) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    hash ^= hash >>> 16;
+    hash = Math.imul(hash, 2246822507);
+    hash ^= hash >>> 13;
+    hash = Math.imul(hash, 3266489909);
+    hash ^= hash >>> 16;
+    return hash >>> 0;
+}
+/**
+ * Build one street-aware building per road-frontage lot: massed at the lot center, its `rotationY`
+ * set so the front faces the road (the renderer turns the whole building about `center`), floors
+ * rolled deterministically from the descriptor's `stories` and the lot's road/side/index.
+ */
+function resolveFrontageBuildings(descriptor, along) {
+    const seed = descriptor.seed ?? "buildings";
+    const lots = deriveBuildingLots({
+        roads: along.roads,
+        footprint: descriptor.footprint,
+        spacing: descriptor.spacing,
+        maxLots: descriptor.count,
+        seed: `${seed}:lots`,
+        ...(along.setback === undefined ? {} : { setback: along.setback }),
+        ...(along.bothSides === undefined ? {} : { bothSides: along.bothSides }),
+        ...(along.area === undefined ? {} : { area: along.area }),
+    });
+    const [floorsMin, floorsMax] = descriptor.stories;
+    const bayWidth = DEFAULT_BUILDING_CONFIG.bayWidth;
+    return lots.map((lot, index) => buildLot(lot, index, seed, floorsMin, floorsMax, bayWidth, descriptor.storyHeight));
+}
+function buildLot(lot, index, seed, floorsMin, floorsMax, bayWidth, storyHeight) {
+    const lo = Math.min(floorsMin, floorsMax);
+    const hi = Math.max(floorsMin, floorsMax);
+    const floors = lo + Math.floor((hashU32(`${seed}:floors:${index}`) / 4294967296) * (hi - lo + 1));
+    const baysWide = Math.max(1, Math.floor(lot.footprint.w / bayWidth));
+    const baysDeep = Math.max(1, Math.floor(lot.footprint.d / bayWidth));
+    const building = generateBuilding({
+        id: `frontage-${index}`,
+        seed: `${seed}:${index}`,
+        center: lot.center,
+        floors,
+        baysWide,
+        baysDeep,
+        bayWidth,
+        floorHeight: storyHeight,
+    });
+    return { ...building, rotationY: lot.rotationY };
+}
 const TERRAIN_SAMPLE_RESOLUTION = 16;
 function sampleTerrainHeights(descriptor) {
     const field = resolveTerrainField(descriptor);

package/dist/world/features.d.ts

@@ -1,6 +1,7 @@
 import type { BuildingPaletteOverrides, BuildingStyle } from "./buildings.js";
 import type { AvoidZone } from "./geometry.js";
 import type { TerrainPathProfile } from "./pathTerrain.js";
+import type { PlaceWorldFeature } from "./place.js";
 import type { TerraformSnapshot } from "./terraform.js";
 import type { VolumetricCloudsConfig } from "./volumetricClouds.js";
 export interface WorldBounds {
@@ -290,6 +291,34 @@ export interface SkyEnvironmentConfig {
     /** Raymarched volumetric cloud layer over the sky dome. Off by default — omit for no clouds. */
     volumetricClouds?: VolumetricCloudsConfig;
 }
+/** One road a `building({ along })` frontage lines with buildings: centerline + full width. */
+export interface BuildingFrontageRoad {
+    /** Road centerline vertices in world XZ; at least two points. */
+    path: readonly EnvironmentVec2[];
+    /** Road full width in world units; lots set back from `width / 2`. */
+    width: number;
+}
+/**
+ * Street-aware placement for `building()`: instead of a grid scattered around `position`, lots are
+ * stepped along each road's frontage, offset by a consistent setback (a curb + sidewalk strip), and
+ * turned so every building FRONT faces its road. `footprint` (`w` = frontage width, `d` = depth) and
+ * `spacing` (along-road gap) are shared with the grid mode. Deterministic and bounded by `maxLots`.
+ */
+export interface BuildingFrontageConfig {
+    /** Roads whose frontage is lined with lots. */
+    roads: readonly BuildingFrontageRoad[];
+    /** Sidewalk strip between the curb (`width / 2`) and the building front, world units. Default 3. */
+    setback?: number;
+    /** Place lots on both sides of each road. Default true. */
+    bothSides?: boolean;
+    /** Clip region; lots whose center falls outside are dropped. Omit to keep every lot. */
+    area?: {
+        center?: EnvironmentVec2;
+        halfExtents: EnvironmentVec2;
+    };
+    /** Hard cap on emitted lots so a long network stays bounded. Default 400. */
+    maxLots?: number;
+}
 export interface BuildingEnvironmentConfig {
     count?: number;
     position?: EnvironmentVec2;
@@ -302,6 +331,11 @@ export interface BuildingEnvironmentConfig {
     /** Explicit per-part-kind hex colors; any part left unset falls back to the resolved `style` palette. */
     palette?: BuildingPaletteOverrides;
     seed?: string;
+    /**
+     * Street-aware placement: derive lots along the given roads' frontage (facing each street, set
+     * back by a sidewalk strip) instead of the grid around `position`. See {@link BuildingFrontageConfig}.
+     */
+    along?: BuildingFrontageConfig;
 }
 export type PadSize = readonly [number, number] | {
     radius: number;
@@ -343,7 +377,7 @@ export type OceanEnvironmentDescriptor = {
 } & Required<Pick<OceanEnvironmentConfig, "bounds" | "level" | "waveHeight" | "waveScale" | "waveSpeed" | "color">> & Pick<OceanEnvironmentConfig, "position" | "levelAt">;
 export type BuildingEnvironmentDescriptor = {
     kind: "building";
-} & Required<Pick<BuildingEnvironmentConfig, "count" | "footprint" | "stories" | "storyHeight" | "spacing" | "style">> & Pick<BuildingEnvironmentConfig, "seed" | "position" | "palette">;
+} & Required<Pick<BuildingEnvironmentConfig, "count" | "footprint" | "stories" | "storyHeight" | "spacing" | "style">> & Pick<BuildingEnvironmentConfig, "seed" | "position" | "palette" | "along">;
 export type PadEnvironmentDescriptor = {
     kind: "pad";
 } & Required<Pick<PadEnvironmentConfig, "center" | "size" | "height" | "color">> & Pick<PadEnvironmentConfig, "rotationY" | "elevation">;
@@ -464,8 +498,13 @@ export interface PlotsWorldConfig extends WorldGridConfig {
 export interface TilemapWorldConfig extends WorldGridConfig {
     map: string;
 }
-/** A declared world shape — biomes, voxel grid, plots, tilemap, environment, or flat — passed to `defineGame`. */
-export type WorldFeature = ({
+/**
+ * A declared world shape passed to `defineGame`. The preferred model is the place feature from
+ * `world()` (`@jgengine/core/world/place`): substrate + laws, with all dressing authored in the
+ * editor. The remaining members — biomes, voxel grid, plots, tilemap, environment, flat — are the
+ * legacy code-declared shapes kept for existing games.
+ */
+export type WorldFeature = PlaceWorldFeature | ({
     kind: "biomes";
 } & BiomesWorldConfig) | ({
     kind: "voxel";
@@ -478,7 +517,16 @@ export type WorldFeature = ({
 };
 /** Derives implicit `TerrainFlattenMask`s carving each pad's footprint into the terrain beneath it. Elevated pads (absolute `elevation`) float free and carve nothing. */
 export declare function padFlattenMasks(pads: readonly PadEnvironmentDescriptor[]): readonly TerrainFlattenMask[];
-/** Composes an `environment()` world feature from terrain, sky, weather, vegetation, water, structures, roads, and pads. */
+/** Composes an `environment()` feature from terrain, sky, weather, vegetation, water, structures, roads, and pads.
+ *
+ * Legacy dressing-in-code path — not how a world is defined. A world is the place you play in
+ * (`world()` from `world/place`: ground + laws); sky look, foliage scatter, props, and sculpt are
+ * scene content authored in the editor. Reach for `environment()` only when consuming
+ * editor/preset-written scene data (`environmentContentFromDocument`) or maintaining an existing
+ * game; never scaffold new worlds from it.
+ *
+ * @capability world-environment compose editor/preset-derived outdoor dressing — terrain, weather, water, structures — into a legacy environment feature
+ */
 export declare function environment(config?: EnvironmentWorldConfig): EnvironmentWorldFeature;
 /** Declares a heightfield terrain patch for `environment()` — bounds, noise, materials, and flatten masks. */
 export declare function terrain(config?: TerrainEnvironmentConfig): TerrainEnvironmentDescriptor;
@@ -494,7 +542,7 @@ export declare function ocean(config?: OceanEnvironmentConfig): OceanEnvironment
 /** Declare a road ribbon for an `environment()` world; the shell drapes and renders it over the terrain. */
 export declare function road(config: RoadEnvironmentConfig): RoadEnvironmentDescriptor;
 export declare function island(config: TerrainIslandConfig): TerrainIslandDescriptor;
-/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. */
+/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. Pass `along` to line road frontage instead of gridding around `position`. */
 export declare function building(config?: BuildingEnvironmentConfig): BuildingEnvironmentDescriptor;
 export declare function pad(config: PadEnvironmentConfig): PadEnvironmentDescriptor;
 /** Declares a biome-painted world — the whole-world alternative to a single `environment()` terrain. */

package/dist/world/features.js

@@ -43,7 +43,16 @@ function bandWeatherDescriptors(terrainDescriptor) {
     }
     return out;
 }
-/** Composes an `environment()` world feature from terrain, sky, weather, vegetation, water, structures, roads, and pads. */
+/** Composes an `environment()` feature from terrain, sky, weather, vegetation, water, structures, roads, and pads.
+ *
+ * Legacy dressing-in-code path — not how a world is defined. A world is the place you play in
+ * (`world()` from `world/place`: ground + laws); sky look, foliage scatter, props, and sculpt are
+ * scene content authored in the editor. Reach for `environment()` only when consuming
+ * editor/preset-written scene data (`environmentContentFromDocument`) or maintaining an existing
+ * game; never scaffold new worlds from it.
+ *
+ * @capability world-environment compose editor/preset-derived outdoor dressing — terrain, weather, water, structures — into a legacy environment feature
+ */
 export function environment(config = {}) {
     const explicitWeather = list(config.weather);
     const bandWeather = bandWeatherDescriptors(config.terrain);
@@ -219,11 +228,13 @@ export function island(config) {
     const { kind: _kind, ...descriptor } = terrain(terrainConfig);
     return { ...descriptor, kind: "island", origin };
 }
-/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. */
+/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. Pass `along` to line road frontage instead of gridding around `position`. */
 export function building(config = {}) {
     return withOptional({
         kind: "building",
-        count: config.count ?? 1,
+        // In frontage mode the road network sizes the district; `count` becomes an upper bound, so a
+        // caller that just says `along` gets a filled street rather than a single grid building.
+        count: config.count ?? (config.along === undefined ? 1 : config.along.maxLots ?? 400),
         footprint: config.footprint ?? { w: 8, d: 8 },
         stories: config.stories ?? [1, 4],
         storyHeight: config.storyHeight ?? 3,
@@ -233,6 +244,7 @@ export function building(config = {}) {
         ...(config.seed === undefined ? {} : { seed: config.seed }),
         ...(config.position === undefined ? {} : { position: config.position }),
         ...(config.palette === undefined ? {} : { palette: config.palette }),
+        ...(config.along === undefined ? {} : { along: config.along }),
     });
 }
 export function pad(config) {

package/dist/world/grassKind.js

@@ -12,7 +12,7 @@ import { registerSceneKind } from "../scene/sceneKinds.js";
 export const GRASS_FIELD_KIND = "grass_field";
 /** Grass defaults: a lush, lightly-swaying meadow. */
 export const GRASS_DEFAULTS = {
-    density: 4,
+    density: 12,
     bladeHeight: 0.6,
     colorBase: "#3f6f37",
     colorTip: "#9ac25a",
@@ -26,7 +26,7 @@ export const GRASS_DEFAULTS = {
 /** 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: 16, step: 0.5, default: GRASS_DEFAULTS.density, unit: "/m²" },
+        { 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 },

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;
+};