lecodes-sdk 2.4.9 → 2.5.0

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

@@ -201,26 +201,32 @@ export declare class Material {
     static terrainLightmap(): Material;
     private static _lmTemplate;
     private static _lmMaskedTemplate;
-    /** The FOLIAGE tier (`Model.load(…, { foliage: true })`, see `Foliage`): an unlit shader with its own cheap
-     *  lighting plus a vertex shader that sways in the wind, bends away from benders and thins out with distance,
-     *  and a per-copy tint. glTF parameters like `Material.lightmap()` plus `wind` / `sway` / `fade` / `benders`,
-     *  which the engine writes itself. Not baked by the rewritten bake yet. */
+    /** The FOLIAGE tier's BARK (`Model.load(…, { foliage })`, see `Foliage`): the opaque material a vegetation model's
+     *  trunks, limbs and stems take — lit by the sky and the real-time sun, swaying in the wind, bending away from
+     *  benders, thinning out with distance, with a per-copy tint. glTF parameters like `Material.lightmap()` plus
+     *  `wind` / `sway` / `fade` / `benders`, which the engine writes itself. */
     static foliage(): Material;
-    /** `Material.foliage()`'s masked twin (`blending: masked`): what the engine gives a foliage model's alpha-MASK
-     *  materials — the cards. */
-    static foliageMasked(): Material;
+    /** The CARDS of a crown (`Model.load(…, { foliage: 'tree' })`): what a vegetation model's alpha-MASK materials take
+     *  — leaves and needles lit per vertex on the crown's hull normal by the sky and the real-time sun, with the
+     *  sun's shadow per pixel. Ground cover takes `Material.grass()` instead. */
+    static foliageCards(): Material;
+    /** GROUND COVER (`Model.load(…, { foliage: 'grass' })`): the cards of grass, ferns, heath — the plant that IS the
+     *  ground's surface. The same wind as `Material.foliage()`, lit by the terrain it stands on: the ground's baked
+     *  ambient and sun share under it, the soil's colour at its base. A crown (`'tree'`) reads nothing from the ground. */
+    static grass(): Material;
+    /** A tree's far IMPOSTOR (`Model.load(…, { foliage: 'tree' })`): the material of the camera-facing quad
+     *  lecodes-assets bakes into a tree's GLB as its last LOD level — an atlas of views of the tree (a grid of azimuths ×
+     *  elevation rows, or a hemi-octahedron; albedo, normal, baked sky visibility) lit per pixel like the crown's cards.
+     *  The engine picks it for the material whose extras carry `lecodes.impostor` and writes `impostorGrid` /
+     *  `impostor` from them. */
+    static foliageImpostor(): Material;
     /** the glTF-side identity values every provider-handed material starts from */
     private static _glbDefaults;
     private static _lightmapDefaults;
     private static _folTemplate;
-    /** Which material a foliage model's CARDS (its alpha-MASK materials) take: `"full"` = `foliage-masked`, the
-     *  shader with the card's own plane, normal map, edge fade and the ground's baked light; `"lean"` =
-     *  `foliage-cards`, the same wind with the lighting moved to the vertex (one texture read, the sun's shadow
-     *  kept) — a third of a forest frame less on a phone-class GPU (2026-10-18). Read when the first foliage
-     *  model loads; set it before. */
-    static foliageCards: "full" | "lean";
-    static _foliageMaskedTemplate(): Material | null;
-    private static _folMaskedTemplate;
+    private static _folCardsTemplate;
+    private static _grassTpl;
+    private static _folImpostorTpl;
     private static _glbTemplate;
     /** Shadow-catcher material (transparent except where shadows fall). */
     static shadow(color?: ColorInput): Material;

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

@@ -12,7 +12,7 @@ export interface TrianglePick {
     mesh: string;
     primitive: number;
     material: string;
-    /** the primitive's index over its file's meshes: the lightmap bake's record `<key>@<ordinal>` */
+    /** the primitive's index over its file's walked nodes' primitives: the lightmap bake's record `<key>@<ordinal>` */
     lightmapOrdinal: number;
     /** triangle index within the primitive (index-buffer order), and whether the ray came from behind */
     triangle: number;
@@ -33,6 +33,8 @@ export interface TrianglePick {
         }[];
     }[];
 }
+/** What a vegetation model is lit as (`Model.load`'s `foliage`): a CROWN or GROUND COVER; false = not foliage. */
+export type FoliageKind = false | "tree" | "grass";
 export declare class Model extends Node {
     /** The model's Animator — always present, its clip table = the GLB's embedded clips. Add to it
      *  with `model.anim.addClip(name, clip)` (external clips), `model.anim.addLayer()`; set its fields
@@ -88,7 +90,10 @@ export declare class Model extends Node {
          *  the standard shader, lit real-time (movers). Hosts without lightmap support ignore it. */
         lightmap?: boolean;
         /** Vegetation: load through the FOLIAGE tier (see `Foliage`) — wind, touch bending, distance fade,
-         *  per-copy tint. Hosts without the tier fall back to the standard shader. */
-        foliage?: boolean;
+         *  per-copy tint. `'tree'` (= `true`): a CROWN — a volume in the air, lit by the sky and the real-time sun
+         *  through the shadow map. `'grass'`: GROUND COVER — grass, ferns, heath: the plant that is the ground's
+         *  surface, lit by the terrain's baked light under it and tinted by its soil at the base. Hosts without the
+         *  tier fall back to the standard shader. */
+        foliage?: boolean | "tree" | "grass";
     }): Promise<Model>;
 }

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

@@ -1,140 +1,9 @@
-import { type ColorInput } from "../core/color";
-import { type Vec3Like } from "../math/vec";
+import type { Vec3Like } from "../math/vec";
 import type { Geometry } from "./Geometry";
 import { Material, type ParticlesMaterialOptions } from "./Material";
 import { Node } from "./Node";
-type Range<T> = T | {
-    min: T;
-    max: T;
-};
-export declare class CurveBuilder {
-    private _kind;
-    private _lo;
-    private _hi;
-    private _stops;
-    constructor(base: Range<number>, mode: "multiply" | "add");
-    /** Curve value at birth (t = 0). Must come before any other stop. */
-    from(v: Range<number>): this;
-    /** Curve value at `t` (0..1 of the particle's life). Stops must be added in ascending t order. */
-    via(t: number, v: Range<number>): this;
-    /** Curve value at death (t = 1). */
-    to(v: Range<number>): this;
-    /** The classic opacity envelope: rise over the first `fadeIn`, fall over the last `fadeOut`. */
-    fade(fadeIn?: number, fadeOut?: number): this;
-    /** The PARAM_CURVE record payload (sans slot): [kind, baseLo, baseHi, n, (t, lo, hi)×n]. */
-    get _data(): Float32Array;
-}
-export declare class ColorCurveBuilder {
-    private _lo;
-    private _hi;
-    private _stops;
-    constructor(base: Range<ColorInput>);
-    /** Curve color at birth (t = 0). Must come first. The curve multiplies the base color. */
-    from(c: Range<ColorInput>): this;
-    /** Curve color at `t` (0..1 of the particle's life), in ascending t order. */
-    via(t: number, c: Range<ColorInput>): this;
-    /** Curve color at death (t = 1). */
-    to(c: Range<ColorInput>): this;
-    /** The COLOR_CURVE record payload: [baseLo rgba, baseHi rgba, n, (t, lo rgba, hi rgba)×n]. */
-    get _data(): Float32Array;
-}
-/** A value curve over each particle's lifetime. Default mode `multiply` (the curve scales the
- *  base); `add` offsets it instead. */
-export declare const curve: (base?: Range<number>, mode?: "multiply" | "add") => CurveBuilder;
-/** A color curve over each particle's lifetime — always multiplies the base color. */
-export declare const colorCurve: (base?: Range<ColorInput>) => ColorCurveBuilder;
-export type ParticleValue = Range<number> | CurveBuilder | {
-    _data: Float32Array;
-};
-export type ParticleColor = ColorInput | {
-    min: ColorInput;
-    max: ColorInput;
-} | ColorCurveBuilder | {
-    _data: Float32Array;
-};
-type VelocityValue = {
-    speed?: Range<number>;
-    /** Cone half-angle in radians — jitter the launch direction uniformly within it. */
-    spread?: number;
-    /** Asymmetric jitter: two angles (u, v — the x/y components) in radians. */
-    randomizeAngle?: {
-        min: Vec3Like;
-        max: Vec3Like;
-    };
-} & ({
-    from: Vec3Like;
-} | {
-    to: Vec3Like;
-} | {
-    dir: Vec3Like;
-} | {});
-/** Where particles are born, in emitter space. Sphere / hemisphere / cone have an axis of +Y (the
- *  hemisphere is the +Y half, the cone opens along +Y from its base disc at `center`) — aim the
- *  node with `lookAt(target, 'y')`. `thickness` 0 emits from the surface only, 1 (default) from the
- *  whole volume. A sphere or cone also sets the LAUNCH DIRECTION (outward / from the cone's apex)
- *  when `startVelocity` gives a speed but no direction, like Unity's shapes. */
-type Shape = {
-    type: "point";
-    v: Vec3Like;
-} | {
-    type: "box";
-    min: Vec3Like;
-    max: Vec3Like;
-} | {
-    type: "circle";
-    center: Vec3Like;
-    radius: number;
-} | {
-    type: "sphere";
-    center?: Vec3Like;
-    radius: number;
-    thickness?: number;
-} | {
-    type: "hemisphere";
-    center?: Vec3Like;
-    radius: number;
-    thickness?: number;
-} | {
-    type: "cone";
-    center?: Vec3Like;
-    radius: number; /** half-angle, radians */
-    angle?: number; /** emit this far up the axis too */
-    length?: number;
-    thickness?: number;
-};
-/** Extra velocity over each particle's life — evaluated from the curves every frame and ADDED as a
- *  displacement (not accumulated like `acceleration`): `radial` pushes outward along the particle's
- *  birth direction (a burst that decays: `curve(4).to(0)`), `x`/`y`/`z` drift in the simulation
- *  space (rising smoke: `y: curve(2).from(0).to(1)`). Unity's velocityOverLifetime. */
-export type VelocityOverLife = {
-    radial?: ParticleValue;
-    x?: ParticleValue;
-    y?: ParticleValue;
-    z?: ParticleValue;
-};
-type Noise = {
-    strength?: number;
-    frequency?: number;
-    speed?: number;
-    /** How much of the displacement a particle earns with AGE (default 0 = all of it from birth).
-     *  The field is sampled by position, so at 0 every particle born at the same spot is pushed the
-     *  same way and a plume's root wanders off its emitter by up to `strength` metres; at 1 a particle
-     *  is born exactly where the emitter put it and drifts into the field over its life — what you
-     *  want whenever the source is visible (an exhaust pipe, a contact patch, a muzzle). */
-    ramp?: number;
-};
-/** Ground plane for bouncing particles (all render modes). `height` is in the simulation space:
- *  world y with `space: 'world'`, emitter-local y otherwise. */
-export type ParticleGround = {
-    /** Plane height (default 0). */
-    height?: number;
-    /** Contact radius — particles stop `radius` above the plane (a mesh's half-extent; default 0). */
-    radius?: number;
-    /** Fraction of the vertical speed kept on impact, 0..1 (default 0.3). */
-    bounce?: number;
-    /** Tangential damping while in contact, per second — like `drag` (default 8). */
-    friction?: number;
-};
+import { type ParticleColor, type ParticleGround, type ParticleNoise as Noise, type ParticleShape as Shape, type ParticleValue, type Range, type VelocityOverLife, type VelocityValue } from "../core/particlesConfig";
+export { _particleTags, CurveBuilder, ColorCurveBuilder, curve, colorCurve, type ParticleValue, type ParticleColor, type VelocityOverLife, type ParticleGround, } from "../core/particlesConfig";
 export type ParticlesOptions = ParticlesMaterialOptions & {
     /** Draw every particle as this mesh — lit, tumbling 3D debris (shell casings, rubble, leaves,
      *  shrapnel) in one draw call. The system switches to the mesh render mode; the default
@@ -341,4 +210,3 @@ export declare class Trail extends Node {
     set emitting(val: boolean);
     get material(): Material;
 }
-export {};

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

@@ -0,0 +1,56 @@
+import { type FetchResponse } from "../runtime/fetch";
+import { Model, type FoliageKind } from "./Model";
+import { Node } from "./Node";
+import { Scene } from "./Scene";
+import type { SceneDef, SceneNodeDef } from "../scene/defineScene";
+import type { BakeData } from "./Lightmap";
+import { type Digest } from "./staticsFormat";
+export { bakeDigest, type Digest } from "./staticsFormat";
+/** `lecodes level build` runs the app with this on `globalThis.__lecodesStatic`: the project root the snapshot is written under. */
+export type StaticsConfig = {
+    root: string;
+};
+export declare const staticsConfig: () => StaticsConfig | null;
+/** True under any of the CLI's tool runs that must see the level the slow, complete way (the bakes, the snapshot). */
+export declare const toolRun: () => boolean;
+export type CoveredRoot = {
+    path: string;
+    def: SceneNodeDef;
+};
+/** The maximal cacheable subtrees among `defs`, depth first: through `children`, and through a prefab's nodes
+ *  (paths run through the prefab's path, as the bake's keys do). */
+export declare const coveredRoots: (defs: Record<string, SceneNodeDef> | undefined, scene: SceneDef) => CoveredRoot[];
+/** The live node at a full path: a top-level entry of the record, or a prefab internal reached through its
+ *  wrapper's part rows (the record only keys the top level; internals live in the wrapper's `_prefabParts`). */
+export declare const findNode: (nodes: Record<string, Node>, path: string) => Node | null;
+/** The digest of the covered defs — what a snapshot's placements were made from. */
+export declare const defsDigest: (roots: CoveredRoot[], scene: SceneDef) => Digest;
+/** The snapshot of the covered roots' subtrees as they stand: the bytes `lecodes level build` writes. `bake` = the
+ *  data the level is bound to (its records go in, joined by path), null = an unbaked level (placements and bodies
+ *  only; the CLI stitches the records in after the bake). */
+export declare const snapshot: (roots: {
+    root: CoveredRoot;
+    node: Node;
+}[], scene: SceneDef, bake: BakeData | null, defs: Digest) => {
+    bytes: Uint8Array;
+    kinds: number;
+    placements: number;
+    records: number;
+};
+export type OpenedCache = {
+    resp: FetchResponse;
+    kinds: {
+        url: string;
+        lightmap: boolean;
+        foliage: FoliageKind;
+    }[];
+    placements: number;
+    roots: number;
+};
+/** Fetch the level's cache and check it against the digests; null = absent, not a cache, or stale (the why logged). */
+export declare const open: (url: string, defs: Digest, bake: Digest) => Promise<OpenedCache | null>;
+/** Build the opened cache under `roots` (the covered roots' JS nodes, in the snapshot's order) in `scene`: the
+ *  templates load through `template` (one per kind, as the level's slow path would load them), the engine clones
+ *  each at its placements as it resolves. `pages` = the bake's light/aux texture ids interleaved (empty = no bake
+ *  bound). Resolves to the placements made. */
+export declare const build: (opened: OpenedCache, scene: Scene, roots: Node[], pages: Uint32Array, template: (url: string, lightmap: boolean, foliage: FoliageKind) => Promise<Model>) => Promise<number>;

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

@@ -0,0 +1,101 @@
+import type { FoliageKind } from "./Model";
+export declare const MAGIC = 1414742860, VERSION = 2, NONE = 4294967295;
+export declare const HEADER = 11, KIND = 4, PLACEMENT = 20, RECORD = 6;
+export declare const ShapeKind: {
+    readonly None: 0;
+    readonly Mesh: 1;
+    readonly Convex: 2;
+    readonly Box: 3;
+    readonly Sphere: 4;
+    readonly Cylinder: 5;
+    readonly Capsule: 6;
+    readonly AutoBox: 7;
+};
+export type ShapeKind = number;
+export type Digest = [number, number];
+export type StaticKind = {
+    name: string;
+    lightmap: boolean;
+    foliage: FoliageKind;
+};
+/** A record: a rect (`page` + `st`) or an object light (`page === NONE`, `slabs` = the floats lightmapObjectApply takes). */
+export type StaticRecord = {
+    ordinal: number;
+    page: number;
+    st?: number[];
+    slabs?: number[];
+};
+export type StaticPlacement = {
+    kind: number;
+    path: string;
+    root: number;
+    pos: number[];
+    quat: number[];
+    scale: number[];
+    castShadows: boolean;
+    receiveShadows: boolean;
+    shape: ShapeKind;
+    params: number[];
+    records: StaticRecord[];
+};
+export type StaticsFile = {
+    defs: Digest;
+    bake: Digest;
+    kinds: StaticKind[];
+    placements: StaticPlacement[];
+};
+/** Two independent 32-bit hashes over `s` (FNV-1a and a multiplicative xor mix), chained from `seed`: 64 bits of
+ *  "did this change", which is all a header needs. */
+export declare const hash64: (s: string, seed?: Digest) => Digest;
+export declare const NO_BAKE: Digest;
+/** The bake's identity as the cache keys it: what a rebake changes. `bake` is the `.bake` JSON. */
+export declare const bakeDigest: (bake: {
+    size: number;
+    pages: number;
+    texel: number;
+    texels?: number;
+    instances: unknown[];
+    uv1?: string | null;
+} | null) => Digest;
+/** What a `.bake` instance carries that the cache keeps (the SDK's BakeInstance, structurally). */
+export type BakeRecordSource = {
+    key: string;
+    receiver: boolean;
+    small?: boolean;
+    page?: number;
+    st?: number[];
+    light?: {
+        axis: number;
+        from: number;
+        to: number;
+        cubes: number[][][];
+        probes: number[];
+    };
+};
+/** The records of every bake instance keyed by node PATH (`<path>@<ordinal>` and whole-node `<path>` alike), in the
+ *  shape the cache stores — the same join the runtime makes when it binds a bake the slow way. */
+export declare const recordsByPath: (instances: BakeRecordSource[]) => Map<string, StaticRecord[]>;
+/** The file's bytes for `f`. */
+export declare const encode: (f: StaticsFile) => Uint8Array;
+/** The header alone: null when `bytes` is not a cache of this version. */
+export declare const readHeader: (bytes: Uint8Array) => {
+    defs: Digest;
+    bake: Digest;
+    kinds: number;
+    placements: number;
+    records: number;
+    floats: number;
+    stringBytes: number;
+} | null;
+/** The whole file as data: null when it is not one. */
+export declare const decode: (bytes: Uint8Array) => StaticsFile | null;
+/** `f` with its records replaced by `bake`'s (joined by placement path) and its bake digest restamped — what
+ *  `lecodes level build` does after a bake, with no host run. `null` bake = no records, NO_BAKE. */
+export declare const stitch: (f: StaticsFile, bake: {
+    size: number;
+    pages: number;
+    texel: number;
+    texels?: number;
+    instances: BakeRecordSource[];
+    uv1?: string | null;
+} | null) => StaticsFile;

package/dist/types/inject.d.ts

@@ -13,16 +13,18 @@ export { __compWrite, __compOp, type CompAxis, type CompWriter } from "./core/co
 export { Canvas, Bitmap } from "./canvas/Canvas";
 export { toast, openURL, SvgSource } from "./runtime/misc";
 export { app, type AppState, type OrientationLock } from "./runtime/app";
+export { env } from "./runtime/env";
 export { clipboard } from "./runtime/clipboard";
 export { permissions, type PermissionKind, type PermissionState } from "./runtime/permissions";
 export { date, type DateValue, type DateInput, type Unit, type Locale } from "./runtime/datetime";
-export { fetch, fetchLocal, FormData, File, type FetchResponse } from "./runtime/fetch";
+export { fetch, fetchLocal, FormData, File, __localAsset, type FetchResponse } from "./runtime/fetch";
 export { localStorage } from "./runtime/storage";
 export { device, type HapticStyle, type MotionOptions } from "./runtime/device";
 export { Input, InputChannel, type InputKeyEvent, type InputGamepadEvent, type InputEventName, type GamepadState, type GamepadAxisName } from "./runtime/input";
 export { WebSocket } from "./runtime/net";
 export { Net, NetPlayer, Replicated, NetEntity, type NetMessage, type NetRole, type NetStatus, type NetEvents, type NetLaunch, type NetInput, type NetKind, type NetTransform, type NetCorrection } from "./net";
 export { __rpc, __channel, __pushChannel, __serverOnly, RpcError } from "./runtime/rpc";
+export { __registerFont } from "./ui/fonts";
 export { resource, action, dataOf, failureOf, type Loaded, type Failure, type Resource, type Action } from "./runtime/resource";
 export type { ChannelSubscription } from "./server/channel";
 export type { PushChannel, PushMessage, PushNotification, PushTarget } from "./server/pushChannel";
@@ -47,7 +49,12 @@ export { CharacterController2D } from "./g2/CharacterController2D";
 export { OneWay2D } from "./g2/OneWay2D";
 export { PhysicsGroup2D } from "./g2/groups2d";
 export { Tilemap } from "./g2/Tilemap";
+export { Path2D, type Path2DOptions, type Stroke2D, type StrokeJoin2D, type StrokeCap2D } from "./g2/Path2D";
+export { Material2D, type Material2DOptions, type Blend2D, type Filter2D, type Wrap2D } from "./g2/Material2D";
 export { Texture2D } from "./g2/Texture2D";
+export { Font2D, type Font2DOptions } from "./g2/Font2D";
+export { Text2D, type Text2DOptions, type TextAlign2D, type TextOutline2D } from "./g2/Text2D";
+export { Particles2D, type Particles2DOptions, type ParticleMode2D, type ParticleShape2D, type VelocityValue2D, type VelocityOverLife2D, } from "./g2/Particles2D";
 export { SpriteSheet, defineSpriteSheet } from "./g2/SpriteSheet";
 export type { SpriteSheetDef, SheetSprite, SpriteMakeOptions } from "./g2/SpriteSheet";
 export { Tileset, defineTileset, Autotile2D } from "./g2/Tileset";
@@ -55,7 +62,7 @@ export { rawCell, isRawCell, rawIndex } from "./g2/autotile";
 export { rot90, rot180, rot270, flipX, packTile, tileIndex, tileTurns, tileFlip, tileOriented } from "./g2/autotile";
 export type { TilesetDef, TileMaterial, PatchMaterial, PathMaterial, PatchSlots, EdgeSlot, FillBlock, BlockEntry, TileBlock, TilePart, } from "./g2/autotile";
 export { defineScene2d, Scene2dHandle } from "./g2/defineScene2d";
-export type { Scene2dDef, Scene2dNodeDef, Scene2dEnv, SpriteSourceDef, TilemapSourceDef, Camera2dNodeDef, LoadedScene2d } from "./g2/defineScene2d";
+export type { Scene2dDef, Scene2dNodeDef, Scene2dEnv, SpriteSourceDef, TilemapSourceDef, PathSourceDef, TextSourceDef, Particles2DSourceDef, Camera2dNodeDef, LoadedScene2d } from "./g2/defineScene2d";
 export { cells, encodeCells, type CellsData } from "./g2/cells";
 export { CameraFollow } from "./g2/scenarios2d";
 export { UIScreen, type UIScreenStyle, UIRow, UIColumn, UIBox, type UIContainerStyle, UIText, type UITextStyle, UIButton, type UIButtonStyle, UIImage, type UIImageStyle, UIVideo, type UIVideoStyle, UIInput, UITextArea, type UIInputStyle, UIScrollable, type UIScrollableStyle, UIPager, type UIPagerStyle, UITabs, type UITabDef, defineTabs, type TabDef, type TabsHandle, UIWidget, type UIWidgetStyle, type WidgetSet, type UIWidgetContent, type UIWidgetChild, UIModal, type UIModalStyle, UIBottomSheet, type UIBottomSheetStyle, UIPopover, type UIPopoverStyle, UISpacer, type UISpacerStyle, UIVirtualizedList, Router, NativeView, type UINativeViewStyle, registerFont, __uiMap, __UIColumn, __UIRow, __UIBox, __UIButton, __UIScreen, __UIScrollable, __UIWidget, } from "./ui/UI";
@@ -157,6 +164,7 @@ export type { ReflectionProbeOptions } from "./gl/ReflectionProbe";
 export { Ray } from "./gl/Ray";
 export { Plane } from "./gl/Plane";
 export { Noise } from "./gl/Noise";
-export { Particles, Trail, curve, colorCurve } from "./gl/Particles";
+export { Particles, Trail } from "./gl/Particles";
+export { curve, colorCurve } from "./core/particlesConfig";
 export { DecalSet, DecalTrail } from "./gl/DecalSet";
 export type { DecalOptions, DecalSetOptions, DecalSpawnOptions, DecalPlacement, DecalTrailOptions } from "./gl/DecalSet";

package/dist/types/runtime/env.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `env` in the APP — the project's `PUBLIC_*` keys (src/core/env.ts says what `env` is): a maps key
+ * restricted to the app's id, an analytics id, a Sentry DSN. The values are baked into the bundle at
+ * compile time (./envValues.ts, replaced by the compile), so they are there offline and without a
+ * backend. Any other key is a secret: the compile refuses `env.STRIPE_KEY` in app code — read it in a
+ * `*.server.ts` file and call an endpoint.
+ */
+import { type Env } from "../core/env";
+/** The app's public keys. A `PUBLIC_*` key that is not set throws `EnvError` on read. */
+export declare const env: Env;

package/dist/types/runtime/envValues.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The app's keys — the `PUBLIC_*` subset of the project's keys, baked into the bundle.
+ *
+ * This module is a placeholder the COMPILER REPLACES: `compileProjectWithMap({ env })` puts a module
+ * with the real values at this same path in chisel's file map (project files win over SDK files),
+ * the way `server/auth/appConfig.ts` carries app.json. Outside a compiled bundle it is empty.
+ */
+export declare const values: Record<string, string>;

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

@@ -134,19 +134,24 @@ export type SceneNodeDef = {
      *  the GLB instance, so `castShadows: false` on a first-person viewmodel covers the whole gun. */
     castShadows?: boolean;
     receiveShadows?: boolean;
-    /** Baked lighting (a scene with `env.lightmap`): is this model/mesh node a lightmap STATIC — a
-     *  receiver and an occluder in the bake, real-time shadow casting off once the bake applies?
-     *  Default: static unless a `Physics` aspect moves the node (`dynamic` — Physics' default — or
-     *  `kinematic`). Set it only to override that rule; prefab subtrees inherit the verdict.
-     *  `'cube'` = a static whose every mesh bakes as AMBIENT CUBES instead of atlas texels — an occluder (its shadow and
+    /** Is this node STATIC — part of the level that never moves once loaded? A static is what the bake sees (a
+     *  receiver and an occluder, real-time shadow casting off once the bake applies) and what the level cache
+     *  snapshots after the first load. Default: static unless a `Physics` aspect moves the node (`dynamic` —
+     *  Physics' default — or `kinematic`). `false` = built live, lit in real time, never cached. Set it only to
+     *  override that rule; prefab subtrees inherit the verdict. */
+    static?: boolean;
+    /** `'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: the `cube` option of `env.lightmap`'s `bake()`. */
-    lightmap?: boolean | "cube";
+    lightmap?: "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
-     *  copy past `end` — for ground cover. The fade is per ASSET: every node of the same GLB shares it. */
-    foliage?: boolean | {
+     *  `Foliage`). `'tree'` (= `true`): a crown, lit by the sky and the real-time sun; `'grass'`: ground cover, lit by
+     *  the terrain's baked light under it (`Model.load`'s `foliage`). The object form names the kind and may add
+     *  `fade: [start, end]`: the cards thin out over that distance range (m) and the copy drops past `end` — for
+     *  ground cover. The fade is per ASSET: every node of the same GLB shares it. */
+    foliage?: boolean | "tree" | "grass" | {
+        kind?: "tree" | "grass";
         fade?: [number, number];
     };
     /** Navigation (a scene with `env.navmesh`, see navmesh.md): every STATIC body is walkable by
@@ -250,9 +255,9 @@ export type ModelPartRow = {
 export declare const modelPartRows: (root: Node) => ModelPartRow[];
 /** Where a def node attaches: its `mount` part when it resolves, else the parent itself. */
 export declare const attachHost: (parent: Node, def: SceneNodeDef, path: string) => Node;
-/** The static verdict for one node def (the editor's "Baked lighting" switch shows the same rule).
- *  Children of a mover are movers too — buildNodes carries that down, this is the node's own verdict. */
-export declare const isLightmapStatic: (def: SceneNodeDef) => boolean;
+/** The static verdict for one node def (the editor's "Static" switch shows the same rule). Children of a
+ *  mover are movers too — buildNodes carries that down, this is the node's own verdict. */
+export declare const isStatic: (def: SceneNodeDef) => boolean;
 /** Edit mode: play the preview pose on a model node (`editor: { clip, time }`) — idempotent, the
  *  harness re-applies it on inspector edits. No clip = back to the rest pose. */
 export declare const applyEditorPose: (node: Node, pose: {

package/dist/types/server/env.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `env` on the SERVER — every key of the project (src/core/env.ts says what `env` is). The values
+ * (Settings → Keys on le.codes, the project's `.env` on this machine) are handed to the bundle by the
+ * host that runs it (`setEnv`) through the `globalThis.__lecodesEnv` seam — a global on purpose,
+ * like `__lecodesRequest`: the bundle carries its own SDK copy, so the host can't pass a value by
+ * import. The compile lists the names the server code reads (serverSplit.ts `scanEnvReads`) so a
+ * deploy can warn before any call does.
+ */
+import { type Env } from "../core/env";
+export { ENV_NAME, PUBLIC_ENV_PREFIX, isPublicEnvName, EnvError, type Env } from "../core/env";
+/** Host hook (runner / local backend / tests): the values the bundle reads. `null` = none set. */
+export declare const setEnv: (values: Record<string, string> | null) => void;
+/** The project's keys. A missing key throws `EnvError` on read. */
+export declare const env: Env;

package/dist/types/server/inject.d.ts

@@ -1,5 +1,6 @@
 export { t, model, defineDb, ref } from "./db";
 export { ApiError } from "./errors";
+export { env, type Env } from "./env";
 export { channel } from "./channel";
 export { pushChannel, type PushChannel, type PushMessage, type PushNotification, type PushTarget } from "./pushChannel";
 export { request } from "./context";

package/dist/types/ui/fonts.d.ts

@@ -6,4 +6,8 @@ type FontOptions = {
  *  use in styles. For registry/project fonts prefer the compile-time `font()` macro — this is the
  *  dynamic escape hatch. */
 export declare function registerFont(fontFamily: string, url: string, options?: FontOptions): Promise<void>;
+/** The macro's registration call (a bundle global, like `__rpc`). `url` is either a full URL (a
+ *  project / vendored entry) or a cdn base ending in "." — the format is appended here: the host's
+ *  for the UI tree, always ttf for 2D text. */
+export declare function __registerFont(family: string, url: string, weight: number, italic: boolean): void;
 export {};

package/dist/types/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "2.4.9";
+export declare const SDK_VERSION = "2.5.0";
 /** 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