lecodes-sdk 2.4.8 → 2.4.10

package/dist/global.d.ts

@@ -390,6 +390,10 @@ declare global {
   type Light = SDK.Light
   type LightDef = SDK.LightDef
   type Lightmap = SDK.Lightmap
+  type LightmapDef = SDK.LightmapDef
+  type LightmapFiles = SDK.LightmapFiles
+  type LightmapOptions = SDK.LightmapOptions
+  type LightmapTransmit = SDK.LightmapTransmit
   type LineLayer = SDK.LineLayer
   type LineLayerOptions = SDK.LineLayerOptions
   type LitMaterialDef = SDK.LitMaterialDef

package/dist/host.d.ts

@@ -1,9 +1,11 @@
 // JS-runtime globals provided by the host engine (web viewer / desktop / iOS), NOT by the SDK.
 // Declared only so SDK and user code type-check — never bundled or injected.
 
-// The one SDK type the macros return: an SVG image source, the same `SvgSource` a project has as
-// a global (build-types.ts points this import into dist/types when it copies the file).
+// The SDK types the macros return: an SVG image source, the same `SvgSource` a project has as a
+// global, and the lightmap def `bake()` compiles to (build-types.ts points these imports into
+// dist/types when it copies the file).
 import type { SvgSource } from "./types/runtime/misc"
+import type { LightmapDef, LightmapOptions } from "./types/gl/Lightmap"
 
 declare global {
   /** As in the browser, but the delay is REQUIRED (the native runtime throws without it) and no
@@ -50,6 +52,15 @@ declare global {
    *  comments and string literals are text, not macros. */
   function asset(path: string): string
 
+  /** THE LEVEL'S BAKE: `lecodes lightmap bake` writes `<stem>.bake` (a JSON manifest) and the files it names next to
+   *  it. Compile-time macro: the manifest is read, every file it names is staged, and the call becomes the literal
+   *  `Lightmap.load` takes — `env: { lightmap: bake('./assets/lightmap/level.bake') }` in a scene file. The path is a
+   *  string literal, relative to the file that calls it (`./`, `../`), else to the project root. No file yet →
+   *  `{ data: null, path }`: the level runs unbaked and says so; under `lecodes lightmap bake` this is the target the
+   *  bake writes. A file the manifest names that is missing fails the compile. `options` (an object literal, copied
+   *  as written) are the level's bake / load options. */
+  function bake(path: `${string}.bake`, options?: LightmapOptions): LightmapDef
+
   /** Compile-time macro: installs a font and returns its family name — using a font IS declaring
    *  it. A registry id (`font("manrope")`) resolves against the font registry; a project path
    *  (`font("./fonts/Brand.ttf")`) reads family/weight/italic from the file itself. `opts`

package/dist/types/gl/Light.d.ts

@@ -92,6 +92,11 @@ export type SpotOptions = {
     innerAngle?: number;
     /** A spot's shadow is one 2D shadow map (a point light's is a cubemap); off by default. */
     castShadows?: boolean;
+    /**
+     * Where the cone points, as a sun's `direction`: it sets the node's rotation (live as `light.direction`). Default:
+     * the node's forward (-Z) - aim it later with `lookAt` / `eulerAngles`.
+     */
+    direction?: Vec3Like;
 };
 export declare class Light extends Node {
     private _intensity;
@@ -111,8 +116,8 @@ export declare class Light extends Node {
     _innerAngle: number;
     /**
      * A spot light — a flashlight, a headlight, a stage light. It shines along the node's forward (-Z): position
-     * it like any node and aim it with `lookAt`. Real time only: the lightmap bake takes no spot lights, so a spot
-     * lights the baked statics live too.
+     * it like any node and aim it with `direction` or `lookAt`. Real time only: the lightmap bake takes no spot lights,
+     * so a spot lights the baked statics live too.
      */
     static spot(options?: SpotOptions): Light;
     /** A spot's full cone angle in degrees — live (a flashlight's focus). */

package/dist/types/gl/Lightmap.d.ts

@@ -1,15 +1,21 @@
 import { Node } from "./Node";
 import type { Scene } from "./Scene";
-export type LightmapLoadOptions = {
+/** The level's bake / load options: `bake()`'s second argument (an object literal, copied into the def as written). */
+export type LightmapOptions = {
     /** A DEBUG multiplier on the atlas' lux (default 1): the atlas is physical, so this is a knob for looking,
      *  not a look. */
     lightScale?: number;
-    /** The level's own radiance of emission 1.0 for the BAKE (cd / m², `BakeConfig.emissiveNits`): an imported pack's
-     *  emissive values are tuned for a look, not for light - this is where the level says how much its panels really give.
-     *  The CLI's `--emissive-nits` wins over it; without either the camera's exposure decides. */
+    /** FOR THE BAKE: the radiance in cd / m² of emission 1.0 on this level (emissive factor x strength x map) - every lit
+     *  region of an emissive surface bakes as a rectangle lamp. An imported pack's emission is a LOOK, tuned for the eye;
+     *  this is where the level says what its panels really give: a 1.3 m ceiling panel of ~8000 lm is ~1600 nits. Default:
+     *  what the camera makes of 1.0 (`1.2 x 2^EV100`). 0 = emissive surfaces light nothing. The CLI's `--emissive-nits`
+     *  wins over it. A `Material.lit` glow with `emissiveNits` of its own emits those instead. */
     emissiveNits?: number;
-    /** `false` = the emissive surfaces light NOTHING in the bake (the level is lit by its lamps, the panels are decoration)
-     *  while `emissiveNits` still says how bright their glow is drawn. Default true. */
+    /** `false` = the emissive surfaces light NOTHING in the bake - the level is lit by its lamps (a `kind: 'point'` light
+     *  with a `bakeArea` next to every panel, the Unity packs' way) and the panels are decoration; `emissiveNits` then only
+     *  says how bright their glow is DRAWN (scene-referred: nits through the camera's exposure). Default true. The
+     *  OVERRIDE over every surface's own switch (`Material.lit`'s `emissiveBake`, a GLB material's extras
+     *  `{"lecodes":{"emissiveBake":false}}`), which vetoes one material while the rest still light the level. */
     emissiveBake?: boolean;
     /** FOR THE BAKE: materials that let light THROUGH them, by their glTF name (`"name*"` = every name with that start):
      *  the share of a shadow ray that passes, tinted by the material's base colour x map - an awning's warm, patterned light
@@ -24,7 +30,7 @@ export type LightmapLoadOptions = {
      *  or charts. Added to the CLI's `--cube` patterns (both apply). */
     cube?: string[];
 };
-/** one `transmit` entry (LightmapLoadOptions.transmit): the straight share, or both shares */
+/** one `transmit` entry (LightmapOptions.transmit): the straight share, or both shares */
 export type LightmapTransmit = number | {
     through?: number;
     diffuse?: number;
@@ -39,26 +45,34 @@ export type LightmapInfo = {
     total: number;
     missing: string[];
 };
+/** The bake's files as `bake()` reads them off the `.bake` manifest at compile time — each one staged like an asset()
+ *  (every name in the manifest is relative to the `.bake`'s folder). Written by the macro, never by hand. */
 export type LightmapFiles = {
-    data: string;
-    /** The irradiance atlas — one page, or every page in order for a bake that took several. */
-    light: string | string[];
-    /** The aux atlas (sun / sky visibility + light direction), pages like `light`. */
-    aux: string | string[];
+    /** The `.bake` (the manifest) — null until `lecodes lightmap bake` has written it: the level then runs unbaked. */
+    data: string | null;
+    /** Project-relative path of the `.bake`, always set: what the messages name, and where `lecodes lightmap bake` writes. */
+    path: string;
+    /** The irradiance atlas (`<stem>-light[_n].ktx2`), every page in order. */
+    light: string[];
+    /** The aux atlas (`<stem>-aux[_n].ktx2`: sun / sky visibility + light direction), pages like `light`. */
+    aux: string[];
     /** DEBUG: the direct-light-only pages a `--split` bake wrote (`<stem>-direct[_n].ktx2`), for the "direct" view. */
-    direct?: string | string[];
+    direct?: string[];
     /** DEBUG: the bounce-only pages of a `--split` bake (`<stem>-indirect[_n].ktx2`), for the "indirect" view. */
-    indirect?: string | string[];
+    indirect?: string[];
     /** The reflection probes (`<stem>-probes.ktx2`), when the bake placed some (`lecodes lightmap bake --probe-spacing`). */
     probes?: string;
-    /** THE LIGHT GRID for movers (`<stem>.lgrid`, `lecodes lightmap bake --volume`): the baked ambient light of every
-     *  place a mover can be. Absent = movers keep the scene's IBL. */
+    /** THE LIGHT GRID for movers (`<stem>.lgrid`, `lecodes lightmap bake --volume`): every node a Physics aspect or a
+     *  CharacterController moves (and what code marks with `Lightmap.track`) takes its ambient light from the bake at the
+     *  place it is at, whatever its shader. Absent = movers keep the scene's IBL. */
     volume?: string;
-    /** THE PACKED LIGHTMAP UV1 (`<stem>-uv1.bin`, the .bake's `uv1`): the bake packs every mesh's lightmap charts into a
-     *  square of their own and its rects map that uv1 — the engine swaps it into the models' TEXCOORD_1 first. Required
-     *  when the bake names one. */
+    /** THE PACKED LIGHTMAP UV1 (`<stem>-uv1.bin`): the bake packs every mesh's lightmap charts into a square of their own
+     *  and its rects map that uv1 — the engine swaps it into the models' TEXCOORD_1 before the rects go on. */
     uv1?: string;
 };
+/** What `bake('<path>.bake', options)` compiles to — the files of the bake and the level's options in one literal:
+ *  `env.lightmap` in a scene file, `Lightmap.load`'s argument in a hand-built scene. */
+export type LightmapDef = LightmapFiles & LightmapOptions;
 /** The lightmap material's data views (`Lightmap.debug`); "direct" / "indirect" bind a `--split` bake's pages instead. */
 export type LightmapDebugMode = "off" | "irradiance" | "albedo" | "normal" | "shadingNormal" | "share" | "skyVis" | "atlas" | "direction" | "lux" | "relief" | "direct" | "indirect" | "probe" | "probeMap" | "skyPath" | "probePath";
 export type LightmapDebugParams = {
@@ -103,7 +117,7 @@ export declare class Lightmap {
     private static next;
     private static movers;
     private static volumeOn;
-    /** A MOVER takes its ambient light from the level's baked LIGHT GRID (`env.lightmap.volume`) at the place it is at,
+    /** A MOVER takes its ambient light from the level's baked LIGHT GRID (the bake's `.lgrid`) at the place it is at,
      *  every frame — whatever its shader: the standard glTF one or a custom lit material. Every Model / Mesh under `node`
      *  is marked (a character, a weapon with its parts). A scene file does this itself for every node a Physics aspect or
      *  a CharacterController moves; call it for what CODE spawns — an enemy, a pickup, a projectile. `on = false` hands
@@ -127,14 +141,15 @@ export declare class Lightmap {
     /** The loaded bake's sun (TO the sun ×3, its illuminance rgb, the sun map's levels), null without a sun map. */
     private static sunArgs;
     private static applySun;
-    /** Apply a bake — or, under `lecodes lightmap bake`, run it. Resolves to null when nothing was
-     *  applied (no bake yet, a host without the feature, bake mode). */
+    /** Apply a bake — or, under `lecodes lightmap bake`, run it. `def` is what `bake('<path>.bake', options)` compiled
+     *  to (a scene file's `env.lightmap`). Resolves to null when nothing was applied (no bake yet, a host without the
+     *  feature, bake mode). */
     private static scene;
-    static load(scene: Scene, files: LightmapFiles, options?: LightmapLoadOptions): Promise<LightmapInfo | null>;
+    static load(scene: Scene, def: LightmapDef): Promise<LightmapInfo | null>;
     /** The bake's `<key>@k` records by their node key: a model's meshes (k = the primitive's ordinal in its file). */
     private static recordsOf;
     /** Switch every lightmapped surface to a DATA view (or back with `"off"` / 0). Level-wide, instant —
-     *  except "direct" / "indirect", which load that page set the first time (a `--split` bake listed in the scene). */
+     *  except "direct" / "indirect", which load that page set the first time (a bake made with `--split`). */
     static debug(mode: LightmapDebugMode | number, params?: LightmapDebugParams): void;
     /** Bind another page set of the bound bake to every surface (the "direct" / "indirect" views). */
     private static show;
@@ -152,7 +167,12 @@ export declare class Lightmap {
     static probe(screenX: number, screenY: number): LightmapProbe | null;
     /** A material's colour uniform as "#rrggbbaa" (the float4 uniform path sets its alpha); white without one. */
     private static colorUniform;
-    /** The lightmap material for a static Mesh, from whatever lit material it carried (colour, map, roughness, metallic). */
+    /** The lightmap material for a static Mesh, from whatever lit material it carried (colour, map, roughness, metallic)
+     *  — and its GLOW, so a glowing Mesh looks the same before and after the bake applies: `emissive` (linear) becomes the
+     *  lightmap material's `emissiveFactor` at strength 1; its own `emissiveNits` go over with `emissiveOwn` 1, which the
+     *  level-wide write (`lightmapSetOptions`) leaves alone. A glow without nits takes the level's, like a GLB panel:
+     *  screen-referred under a level of 0 nits, else emission x the level's nits through the exposure — the same as
+     *  before the bake when the level's nits are the camera's (the default). */
     private static meshMaterial;
     private static bake;
 }

package/dist/types/gl/Material.d.ts

@@ -112,12 +112,25 @@ export type ParticlesMaterialOptions = {
      *  length = size + stretch·|velocity|. Default 0.05. */
     stretch?: number;
 };
-/** `Material.lit` options — PBR scalars on top of the color/map pair. */
+/** `Material.lit` options — PBR scalars on top of the color/map pair, and the surface's own glow. */
 export type LitMaterialOptions = MaterialColorOptions & MaterialStateOptions & {
     /** Perceptual roughness, 0 (mirror) … 1 (matte). Unset = the shader's default. */
     roughness?: number;
     /** Metallic factor, 0 (dielectric) … 1 (metal). Unset = the shader's default. */
     metallic?: number;
+    /** The surface's GLOW, added on top of its lit colour: a ceiling panel, a screen, a sign. Any colour (sRGB, like
+     *  `color`); an `[r, g, b]` array may go past 1 — an HDR colour, its hue in sRGB and the excess a linear multiplier
+     *  (`[4, 3.6, 3]` = `[1, 0.9, 0.75]` four times as bright). Unset = no glow. */
+    emissive?: ColorInput;
+    /** The glow's luminance in cd / m² (nits) for `emissive` 1.0 — `#ffffff` at 1600 is a typical ceiling panel. Set,
+     *  the glow is drawn SCENE-referred: through the camera's exposure, as bright as the light it gives the room in a
+     *  bake. Unset (or 0) = SCREEN-referred: the colour is drawn as it is whatever the exposure, and a bake counts it at
+     *  the level's `emissiveNits` (what the camera makes of 1.0 unless the level says otherwise). */
+    emissiveNits?: number;
+    /** `false` = decoration: the glow is drawn, but a lightmap bake does not light the level with it (Unity's "Global
+     *  Illumination: None") — the level's lamps do. Default true: a glowing static lights the level like a lamp. The
+     *  level-wide `bake('…', { emissiveBake: false })` overrides it for every surface. */
+    emissiveBake?: boolean;
 };
 export declare class Material {
     readonly shader: FetchResponse | "unknown";
@@ -139,7 +152,8 @@ export declare class Material {
     set map(value: Texture | Canvas | null);
     /** The material an instance handle is of; a host that carries none under `name` is an error naming it. */
     private static _builtin;
-    /** PBR lit material. */
+    /** PBR lit material. `emissive` / `emissiveNits` / `emissiveBake` are its glow (`LitMaterialOptions`); the uniforms
+     *  are written only for a material that asks for a glow, so a plain lit material never names them. */
     static lit(options?: LitMaterialOptions): Material;
     /** Unlit (flat) material — opaque unless `transparent` asks for alpha blending. */
     static unlit(options?: UnlitMaterialOptions): Material;

package/dist/types/gl/Particles.d.ts

@@ -184,7 +184,7 @@ export type ParticlesOptions = ParticlesMaterialOptions & {
      *  without this the engine picks who covers whom per frame (smoke popping over a fireball).
      *  Default 0; a fireball wants 2, its smoke 1, a smoke trail -1. */
     order?: number;
-    /** Sprites take the light of the PLACE each one is in — the level's baked light grid (`env.lightmap.volume`).
+    /** Sprites take the light of the PLACE each one is in — the level's baked light grid (the bake's `.lgrid`).
      *  A sprite is unlit: its colour is the picture, which is right for fire and wrong for dust — a puff kicked up
      *  under an awning glows as if it stood in the sun. With `lit` every particle's colour is multiplied by the light
      *  where it is, relative to the level's OPEN ground: exactly the authored colour out in the sun, the ambient's

package/dist/types/inject.d.ts

@@ -130,6 +130,7 @@ export type { DynamicBoneCurve, DynamicBoneFloor, DynamicBoneColliders } from ".
 export type { IKTwoBone, IKLookAt } from "./gl/animation/IK";
 export { Light } from "./gl/Light";
 export { Lightmap } from "./gl/Lightmap";
+export type { LightmapDef, LightmapFiles, LightmapOptions, LightmapTransmit } from "./gl/Lightmap";
 export { Foliage } from "./gl/Foliage";
 export type { FoliageOptions, FoliageWind } from "./gl/Foliage";
 export { Terrain } from "./gl/terrain/Terrain";

package/dist/types/scene/defineScene.d.ts

@@ -4,10 +4,10 @@ import { Scene, type SceneOptions } from "../gl/Scene";
 import { Node } from "../gl/Node";
 import { Mesh } from "../gl/Mesh";
 import { Model } from "../gl/Model";
-import { type LightmapTransmit } from "../gl/Lightmap";
+import { type LightmapDef } from "../gl/Lightmap";
 import { type FoliageOptions } from "../gl/Foliage";
 import { type TerrainLayer, type TerrainRegion, type TerrainOptions } from "../gl/terrain/Terrain";
-import { Light, type SunOptions } from "../gl/Light";
+import { Light, type PointOptions, type SpotOptions, type SunOptions } from "../gl/Light";
 import { type MaterialDef } from "./material";
 import type { CapsuleOptions, CylinderOptions, PlaneOptions, SphereOptions } from "../gl/Geometry";
 import { GizmoBuffer } from "./gizmos";
@@ -23,9 +23,16 @@ export type MeshDef = {
 } & CapsuleOptions) | ({
     kind: "plane";
 } & PlaneOptions);
-export type LightDef = {
+/** The `light: {}` source block, by `kind` — `Light.sun` / `Light.point` / `Light.spot` with the node's transform: a
+ *  point light's `bakeArea` panel lies in the node's local XZ plane and emits along its local -Y, so `eulerAngles`
+ *  tilts it; a spot shines along the node's -Z (`direction` aims it, as a sun's does). */
+export type LightDef = ({
     kind: "sun";
-} & SunOptions;
+} & SunOptions) | ({
+    kind: "point";
+} & PointOptions) | ({
+    kind: "spot";
+} & SpotOptions);
 /** A stamp: the terrain conforms to another node of this file (a road) at load — see Terrain.conform. */
 export type TerrainStampDef = {
     /** Path of the node (a Mesh, a Model, or a node holding them) the ground hugs. */
@@ -134,7 +141,7 @@ export type SceneNodeDef = {
      *  `'cube'` = a static whose every mesh bakes as AMBIENT CUBES instead of atlas texels — an occluder (its shadow and
      *  bounce stay in the bake) lit where it stands, the way the bake treats small and thin props on its own: a pipe run, a
      *  fence, a prop whose lightmap seams show. A prefab marked `'cube'` bakes its statics that way too. By name for a whole
-     *  kit: `env.lightmap.cube`. */
+     *  kit: the `cube` option of `env.lightmap`'s `bake()`. */
     lightmap?: boolean | "cube";
     /** `model` nodes: vegetation — load through the FOLIAGE tier (wind, touch bending, per-copy tint; see
      *  `Foliage`). `{ fade: [start, end] }` also thins the cards out over that distance range (m) and drops the
@@ -156,54 +163,6 @@ export type SceneCameraDef = CameraProjectionDef & {
     /** Point the camera looks at. */
     target?: Vec3Like;
 };
-/** `env.lightmap` — the level's baked lighting (engines/bake): the files `lecodes lightmap bake`
- *  writes. Absent = real-time only. */
-export type SceneLightmapDef = {
-    /** `asset('./assets/lightmap/level.bake')` */
-    data: string;
-    /** `asset('./assets/lightmap/level-light.ktx2')` — or, for a bake that took more than one atlas PAGE
-     *  (`lecodes lightmap bake --pages`), every page in order: `[asset('x-light.ktx2'), asset('x-light_1.ktx2')]`. */
-    light: string | string[];
-    /** `asset('./assets/lightmap/level-aux.ktx2')` (pages like `light`) — sun / sky visibility + light direction. */
-    aux: string | string[];
-    /** DEBUG: the page sets a `lecodes lightmap bake --split` wrote (`<stem>-direct[_n].ktx2`, `<stem>-indirect[_n].ktx2`),
-     *  pages like `light` — the `Lightmap.debug("direct" | "indirect")` views bind them in place of `light`. */
-    direct?: string | string[];
-    indirect?: string | string[];
-    /** `asset('./assets/lightmap/level-probes.ktx2')` — the bake's reflection probes (one prefiltered cubemap of the level's
-     *  radiance per probe; every static reflects the nearest). Absent = statics reflect the sky's SH alone. */
-    probes?: string;
-    /** FOR THE BAKE: the radiance in cd / m² of emission 1.0 on this level (emissive factor x strength x map) - every lit
-     *  region of an emissive surface bakes as a rectangle lamp. An imported pack's emission is a LOOK (the school's panels
-     *  say 10); this is where the level says what they give: a 1.3 m ceiling panel of ~8000 lm is ~1600 nits. Default: what
-     *  the camera makes of 1.0 (`1.2 x 2^EV100`). 0 = emissive surfaces light nothing. `--emissive-nits` overrides. */
-    emissiveNits?: number;
-    /** `false` = the emissive surfaces light nothing in the bake - the level is lit by its lamps (`Light.point` with a
-     *  `bakeArea` next to every panel, the Unity packs' way) and the panels are decoration; `emissiveNits` then only says how
-     *  bright their glow is DRAWN (scene-referred: nits through the camera's exposure). Default true. */
-    emissiveBake?: boolean;
-    /** FOR THE BAKE: materials that let light THROUGH them, by glTF material name (`"name*"` = every name with that start) →
-     *  the share of a shadow ray that passes, tinted by the material's base colour x map: `{ mat_awning: 0.3 }` puts the
-     *  awning's warm, patterned light on the sand. The surface stays opaque - baked, drawn as before, a shadow caster.
-     *  `{ through, diffuse }` splits it: `through` goes straight (the picture of the map), `diffuse` is scattered by the
-     *  fibres (the underside glows, a soft fill with no picture) - dense canvas: `{ through: 0.08, diffuse: 0.25 }`. */
-    transmit?: Record<string, LightmapTransmit>;
-    /** FOR THE BAKE: CUBES BY NAME — regular expressions (ECMAScript, case-sensitive) searched in every baked mesh's key
-     *  (`<node path>@<ordinal>`): `['SM_pipe', 'SM_fence']` bakes every pipe and fence node as ambient cubes instead of atlas
-     *  texels, like a node's `lightmap: 'cube'`. The CLI's `--cube` adds to these. */
-    cube?: string[];
-    /** `asset('./assets/lightmap/level.lgrid')` — THE LIGHT GRID for movers: every node a Physics aspect or a
-     *  CharacterController moves (and what code marks with `Lightmap.track`) takes its ambient light from the bake at the
-     *  place it is at, whatever its shader. Absent = movers keep the scene's IBL. */
-    volume?: string;
-    /** `asset('./assets/lightmap/level-uv1.bin')` — THE PACKED LIGHTMAP UV1 the bake's rects map: it packs every mesh's
-     *  lightmap charts into a square of their own instead of the unwrap's (once per mesh, whatever model holds it), and the
-     *  engine swaps this into the models' TEXCOORD_1 before the rects go on. Required when the bake wrote one (the .bake's `uv1`): without it the statics
-     *  read the wrong texels, so the bake is not applied. */
-    uv1?: string;
-    /** A DEBUG multiplier on the atlas' lux (default 1). */
-    lightScale?: number;
-};
 /** `env.navmesh` — the level's navigation mesh (see navmesh.md): the file `lecodes navmesh bake`
  *  writes, the agent size it is built for, and the named areas. Absent = no navigation. */
 export type SceneNavmeshDef = {
@@ -220,8 +179,10 @@ export type SceneNavmeshDef = {
     areas?: Record<string, number>;
 };
 export type SceneDef = {
+    /** `lightmap` = the level's baked lighting (engines/bake): `bake('./assets/lightmap/level.bake', { …options })`, the
+     *  macro that reads the bake's manifest at compile time (`LightmapDef`). Absent = real-time only. */
     env?: SceneOptions & {
-        lightmap?: SceneLightmapDef;
+        lightmap?: LightmapDef;
         navmesh?: SceneNavmeshDef;
         foliage?: FoliageOptions;
     };

package/dist/types/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "2.4.8";
+export declare const SDK_VERSION = "2.4.10";
 /** The major of a semver string, or null when it is not one. */
 export declare const sdkMajor: (version: string | null | undefined) => number | null;
 /** The `// sdk: <version>` line of a compiled bundle's header (sdk/src/compile/header.ts), read from