@cimplify/sdk 0.108.0 → 0.110.2

package/dist/template-BkEGVTQj.d.ts

@@ -0,0 +1,190 @@
+import { G as GameBackend } from './backend-gUCzs5Kg.js';
+import { G as Game, a as GameUiHost } from './game-fgQy2YIm.js';
+import { G as GameScene } from './fluid-ARr0qUIL.js';
+
+type RealMoneyKind = "name" | "code" | "symbol";
+interface RealMoneyMatch {
+    readonly kind: RealMoneyKind;
+    readonly found: string;
+}
+declare const REAL_MONEY_SUGGESTION = "currencies can't use real money names or symbols; try something like 'Jollof Coins' or 'Danfo Tokens', or mark a soft currency in_world in a game with no shopping";
+declare function realMoneyIn(text: string): RealMoneyMatch | null;
+type RealMoneyId = "ngn" | "ghs" | "usd" | "eur" | "gbp" | "kes" | "zar" | "xof" | "xaf" | "jpy" | "cny" | "inr" | "ugx" | "tzs" | "naira" | "kobo" | "cedi" | "cedis" | "pesewa" | "pesewas" | "dollar" | "dollars" | "euro" | "euros" | "pound" | "pounds" | "shilling" | "shillings" | "rand" | "cfa" | "franc" | "francs" | "cent" | "cents" | "yen" | "rupee" | "rupees";
+type CurrencyId<Id extends string> = Lowercase<Id> extends RealMoneyId ? never : Id;
+declare const IN_WORLD_CATEGORY = "games";
+declare const COMMERCE_CAPABILITIES: readonly string[];
+interface InWorldContext {
+    readonly category: string;
+    readonly capabilities: readonly string[];
+}
+declare function inWorldRefusal(currency: string, context: InWorldContext): string | null;
+
+type ValueClass = "soft" | "premium";
+declare const ODDS_TOTAL_PPM: number;
+interface SoftCurrency<Id extends string = string> {
+    readonly kind: "currency";
+    readonly class: "soft";
+    readonly id: Id;
+    readonly name: string;
+    readonly maxBalance: number;
+    readonly inWorld: boolean;
+}
+interface PremiumCurrency<Id extends string = string> {
+    readonly kind: "currency";
+    readonly class: "premium";
+    readonly id: Id;
+    readonly name: string;
+    readonly maxBalance: number;
+}
+interface SoftItem<Id extends string = string> {
+    readonly kind: "item";
+    readonly class: "soft";
+    readonly id: Id;
+    readonly name: string;
+    readonly stackable: boolean;
+    readonly tradeable: boolean;
+    readonly sellsFor: SoftCurrency | null;
+}
+interface PremiumItem<Id extends string = string> {
+    readonly kind: "item";
+    readonly class: "premium";
+    readonly id: Id;
+    readonly name: string;
+    readonly stackable: boolean;
+    readonly tradeable: boolean;
+}
+type Currency = SoftCurrency | PremiumCurrency;
+type Item = SoftItem | PremiumItem;
+type SoftValue = SoftCurrency | SoftItem;
+type PremiumValue = PremiumCurrency | PremiumItem;
+type GameValue = SoftValue | PremiumValue;
+interface ValueGrant<V extends GameValue = GameValue> {
+    readonly kind: "value";
+    readonly value: V;
+    readonly quantity: number;
+}
+interface UnlockGrant {
+    readonly kind: "unlock";
+    readonly id: string;
+}
+interface EffectGrant {
+    readonly kind: "effect";
+    readonly id: string;
+}
+type CimplesGrant = ValueGrant | UnlockGrant | EffectGrant;
+interface LedgerRule<K extends "faucet" | "sink", V extends SoftValue = SoftValue> {
+    readonly kind: K;
+    readonly id: string;
+    readonly value: V;
+    readonly maxQuantity: number;
+}
+type Faucet<V extends SoftValue = SoftValue> = LedgerRule<"faucet", V>;
+type Sink<V extends SoftValue = SoftValue> = LedgerRule<"sink", V>;
+interface SoftExchange {
+    readonly kind: "exchange";
+    readonly class: "soft";
+    readonly id: string;
+    readonly pay: readonly ValueGrant<SoftValue>[];
+    readonly receive: readonly ValueGrant<SoftValue>[];
+}
+interface PremiumExchange {
+    readonly kind: "exchange";
+    readonly class: "premium";
+    readonly id: string;
+    readonly pay: readonly ValueGrant<PremiumValue>[];
+    readonly receive: readonly ValueGrant<PremiumItem>[];
+}
+type Exchange = SoftExchange | PremiumExchange;
+declare const disclosedBrand: unique symbol;
+interface OddsOutcomeDecl<V extends GameValue = GameValue> {
+    readonly value: V;
+    readonly quantity: number;
+    readonly partsPerMillion: number;
+}
+type DisclosedOdds<V extends GameValue = GameValue> = readonly OddsOutcomeDecl<V>[] & {
+    readonly [disclosedBrand]: true;
+};
+interface FixedOffer {
+    readonly kind: "fixed";
+    readonly id: string;
+    readonly name: string;
+    readonly priceCimples: number;
+    readonly grants: readonly CimplesGrant[];
+}
+interface RandomOffer {
+    readonly kind: "random";
+    readonly id: string;
+    readonly name: string;
+    readonly priceCimples: number;
+    readonly odds: DisclosedOdds;
+}
+type CimplesOffer = FixedOffer | RandomOffer;
+interface RandomExchange {
+    readonly kind: "random_exchange";
+    readonly id: string;
+    readonly name: string;
+    readonly pay: ValueGrant<PremiumCurrency>;
+    readonly odds: DisclosedOdds<PremiumItem>;
+}
+type PaidRandomReward = RandomOffer | RandomExchange;
+interface CurrencyOptions {
+    readonly maxBalance?: number;
+}
+interface ItemOptions {
+    readonly stackable?: boolean;
+    readonly tradeable?: boolean;
+}
+interface SoftItemOptions extends ItemOptions {
+    readonly sellsFor?: SoftCurrency | null;
+}
+declare function softCurrency<Id extends string>(id: Id & CurrencyId<Id>, name: string, options?: CurrencyOptions): SoftCurrency<Id>;
+declare function inWorldCurrency<Id extends string>(id: Id, name: string, options?: CurrencyOptions): SoftCurrency<Id>;
+declare function premiumCurrency<Id extends string>(id: Id & CurrencyId<Id>, name: string, options?: CurrencyOptions): PremiumCurrency<Id>;
+declare function softItem<Id extends string>(id: Id, name: string, options?: SoftItemOptions): SoftItem<Id>;
+declare function premiumItem<Id extends string>(id: Id, name: string, options?: ItemOptions): PremiumItem<Id>;
+declare function grant<V extends GameValue>(value: V, quantity: number): ValueGrant<V>;
+declare function unlock(id: string): UnlockGrant;
+declare function effect(id: string): EffectGrant;
+declare function faucet<V extends SoftValue>(id: string, value: V, maxQuantity: number): Faucet<V>;
+declare function sink<V extends SoftValue>(id: string, value: V, maxQuantity: number): Sink<V>;
+declare function softExchange(id: string, pay: readonly ValueGrant<SoftValue>[], receive: readonly ValueGrant<SoftValue>[]): SoftExchange;
+declare function premiumExchange(id: string, pay: readonly ValueGrant<PremiumValue>[], receive: readonly ValueGrant<PremiumItem>[]): PremiumExchange;
+declare function discloseOdds(outcomes: readonly OddsOutcomeDecl<PremiumItem>[]): DisclosedOdds<PremiumItem>;
+declare function discloseOdds(outcomes: readonly OddsOutcomeDecl[]): DisclosedOdds;
+declare function fixedOffer(id: string, name: string, priceCimples: number, grants: readonly CimplesGrant[]): FixedOffer;
+declare function randomOffer(id: string, name: string, priceCimples: number, odds: DisclosedOdds): RandomOffer;
+declare function randomExchange(id: string, name: string, pay: ValueGrant<PremiumCurrency>, odds: DisclosedOdds<PremiumItem>): RandomExchange;
+interface EconomyDecl {
+    readonly currencies: readonly Currency[];
+    readonly items: readonly Item[];
+    readonly faucets?: readonly Faucet[];
+    readonly sinks?: readonly Sink[];
+    readonly exchanges?: readonly Exchange[];
+    readonly offers?: readonly CimplesOffer[];
+    readonly randomExchanges?: readonly RandomExchange[];
+}
+
+interface TemplateBot<S extends GameScene<Game>> {
+    drive(scene: S, game: Game, frame: number): void;
+}
+interface GenreTemplate<S extends GameScene<Game>> {
+    readonly id: string;
+    readonly title: string;
+    readonly sources: readonly string[];
+    readonly economy: EconomyDecl | null;
+    scene(): S;
+    bot(): TemplateBot<S>;
+    progress(scene: S): number;
+    digest(scene: S, game: Game): number;
+}
+interface TemplateHarness<S extends GameScene<Game>> {
+    readonly game: Game;
+    readonly scene: S;
+    frame(index: number): void;
+}
+declare function templateFrameStamp(frame: number): number;
+declare function createTemplateHarness<S extends GameScene<Game>>(template: GenreTemplate<S>, backend: GameBackend, seed: number, ui?: GameUiHost | null): Promise<TemplateHarness<S>>;
+declare function digestFloats(values: Float32Array | Float64Array, count: number, seed?: number): number;
+declare function digestInts(values: ArrayLike<number>, count: number, seed?: number): number;
+
+export { randomExchange as $, createTemplateHarness as A, digestFloats as B, COMMERCE_CAPABILITIES as C, type DisclosedOdds as D, type EconomyDecl as E, type Faucet as F, type GameValue as G, digestInts as H, IN_WORLD_CATEGORY as I, discloseOdds as J, effect as K, type LedgerRule as L, faucet as M, fixedOffer as N, ODDS_TOTAL_PPM as O, type PaidRandomReward as P, grant as Q, REAL_MONEY_SUGGESTION as R, type Sink as S, type TemplateBot as T, type UnlockGrant as U, type ValueClass as V, inWorldCurrency as W, inWorldRefusal as X, premiumCurrency as Y, premiumExchange as Z, premiumItem as _, type CimplesGrant as a, randomOffer as a0, realMoneyIn as a1, sink as a2, softCurrency as a3, softExchange as a4, softItem as a5, templateFrameStamp as a6, unlock as a7, type CimplesOffer as b, type Currency as c, type CurrencyId as d, type EffectGrant as e, type Exchange as f, type FixedOffer as g, type GenreTemplate as h, type InWorldContext as i, type Item as j, type OddsOutcomeDecl as k, type PremiumCurrency as l, type PremiumExchange as m, type PremiumItem as n, type PremiumValue as o, type RandomExchange as p, type RandomOffer as q, type RealMoneyId as r, type RealMoneyKind as s, type RealMoneyMatch as t, type SoftCurrency as u, type SoftExchange as v, type SoftItem as w, type SoftValue as x, type TemplateHarness as y, type ValueGrant as z };

package/dist/terrain-BMxEc6Oc.d.ts

@@ -0,0 +1,429 @@
+import { A as AiGenerateRequest, j as AiRun } from './local-VZkqsCzR.js';
+import { C as Chemistry, b as DefineResult, I as InputActions } from './game-fgQy2YIm.js';
+import { V as Vec3, f as Vec3Like, N as NodeId, D as DeviceTier, T as TerrainPort, B as BrushOp, g as NoiseKind } from './backend-gUCzs5Kg.js';
+
+declare const CHEMISTRY_PROMPT = "chemistry_invent";
+declare const CHEMISTRY_SCHEMA = "chemistry_proposal";
+declare const MAX_KNOWN_CHARS = 200;
+declare const MAX_NAME = 32;
+declare const MAX_FORMULA = 24;
+declare const MAX_TERMS = 4;
+declare const MAX_SPECIES = 2;
+type Json = string | number | boolean | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+declare const PROPOSAL_SCHEMA: Json;
+declare const CHEMISTRY_TEMPLATE: string;
+declare const CHEMISTRY_AI_CAPABILITY = "Describe a reaction and the world's chemistry decides whether it can happen";
+declare function chemistryAiSection(): string;
+declare function chemistryAiToml(): string;
+interface ChemistryAi {
+    generate(request: AiGenerateRequest): Promise<AiRun>;
+}
+interface ReactionIdea {
+    readonly description: string;
+    readonly materials: string;
+    readonly requestKey: string;
+}
+declare function reactionRequest(idea: ReactionIdea): AiGenerateRequest;
+interface ProposedTerm {
+    readonly material: string;
+    readonly count: number;
+    readonly phase?: "solid" | "liquid" | "gas" | "any";
+}
+interface ProposedMaterial {
+    readonly name: string;
+    readonly formula: string;
+    readonly formation_kj: number;
+    readonly melt_k?: number;
+    readonly boil_k?: number;
+    readonly density?: number;
+    readonly groups?: readonly string[];
+    readonly colour?: string;
+    readonly ignition_k?: number;
+}
+interface Proposal {
+    readonly materials?: readonly ProposedMaterial[];
+    readonly reaction: {
+        readonly name: string;
+        readonly reactants: readonly ProposedTerm[];
+        readonly products: readonly ProposedTerm[];
+        readonly catalyst?: string;
+        readonly above_k?: number;
+        readonly activation_kj?: number;
+        readonly claimed_kj?: number;
+    };
+}
+declare function proposalText(p: Proposal): string;
+declare function knownMaterials(chemistry: Chemistry): string;
+declare function proposeReaction(chemistry: Chemistry, ai: ChemistryAi, idea: Omit<ReactionIdea, "materials">): Promise<DefineResult | {
+    readonly ok: false;
+    readonly line: 0;
+    readonly refusal: "malformed";
+    readonly reason: string;
+}>;
+
+declare class Box3 {
+    readonly min: Vec3;
+    readonly max: Vec3;
+    set(min: Vec3Like, max: Vec3Like): this;
+    setValues(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): this;
+    copy(box: Box3): this;
+    makeEmpty(): this;
+    isEmpty(): boolean;
+    expandByPoint(p: Vec3Like): this;
+    expandByXyz(x: number, y: number, z: number): this;
+    expandByScalar(s: number): this;
+    setFromArray(positions: ArrayLike<number>, start?: number, count?: number, stride?: number): this;
+    union(box: Box3): this;
+    intersect(box: Box3): this;
+    center(out: Vec3): Vec3;
+    size(out: Vec3): Vec3;
+    containsPoint(p: Vec3Like): boolean;
+    containsBox(box: Box3): boolean;
+    intersectsBox(box: Box3): boolean;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsPlane(plane: Plane): boolean;
+    clampPoint(p: Vec3Like, out: Vec3): Vec3;
+    distanceSquaredToPoint(p: Vec3Like): number;
+    distanceToPoint(p: Vec3Like): number;
+    boundingSphere(out: Sphere): Sphere;
+    corner(index: number, out: Vec3): Vec3;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+    translate(offset: Vec3Like): this;
+}
+declare class Sphere {
+    readonly center: Vec3;
+    radius: number;
+    set(center: Vec3Like, radius: number): this;
+    copy(sphere: Sphere): this;
+    makeEmpty(): this;
+    isEmpty(): boolean;
+    setFromArray(positions: ArrayLike<number>, scratch: Box3, stride?: number): this;
+    containsPoint(p: Vec3Like): boolean;
+    distanceToPoint(p: Vec3Like): number;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsBox(box: Box3): boolean;
+    intersectsPlane(plane: Plane): boolean;
+    expandByPoint(p: Vec3Like): this;
+    union(sphere: Sphere): this;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+}
+declare class Plane {
+    readonly normal: Vec3;
+    constant: number;
+    set(normal: Vec3Like, constant: number): this;
+    setComponents(x: number, y: number, z: number, w: number): this;
+    setFromNormalAndPoint(normal: Vec3Like, point: Vec3Like): this;
+    setFromCoplanarPoints(a: Vec3Like, b: Vec3Like, c: Vec3Like): this;
+    copy(plane: Plane): this;
+    normalize(): this;
+    negate(): this;
+    distanceToPoint(p: Vec3Like): number;
+    projectPoint(p: Vec3Like, out: Vec3): Vec3;
+    coplanarPoint(out: Vec3): Vec3;
+    intersectLine(start: Vec3Like, end: Vec3Like, out: Vec3): boolean;
+    applyMat4(m: ArrayLike<number>, o: number, normalMatrix: ArrayLike<number>, no: number): this;
+    toTuple(out: Float32Array | Float64Array, offset?: number): void;
+}
+declare class Ray {
+    readonly origin: Vec3;
+    readonly direction: Vec3;
+    set(origin: Vec3Like, direction: Vec3Like): this;
+    copy(ray: Ray): this;
+    at(t: number, out: Vec3): Vec3;
+    lookAt(target: Vec3Like): this;
+    closestPointToPoint(p: Vec3Like, out: Vec3): Vec3;
+    distanceSquaredToPoint(p: Vec3Like): number;
+    distanceToPlane(plane: Plane): number;
+    intersectPlane(plane: Plane, out: Vec3): boolean;
+    intersectSphereDistance(sphere: Sphere): number;
+    intersectSphere(sphere: Sphere, out: Vec3): boolean;
+    intersectBoxDistance(box: Box3): number;
+    intersectBox(box: Box3, out: Vec3): boolean;
+    intersectTriangleDistance(a: Vec3Like, b: Vec3Like, c: Vec3Like, backfaceCulling?: boolean): number;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+}
+declare class Frustum {
+    readonly planes: readonly Plane[];
+    setFromProjectionMatrix(m: ArrayLike<number>, o: number): this;
+    copy(frustum: Frustum): this;
+    containsPoint(p: Vec3Like): boolean;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsBox(box: Box3): boolean;
+}
+declare class Triangle {
+    readonly a: Vec3;
+    readonly b: Vec3;
+    readonly c: Vec3;
+    set(a: Vec3Like, b: Vec3Like, c: Vec3Like): this;
+    setFromArray(positions: ArrayLike<number>, i0: number, i1: number, i2: number): this;
+    normal(out: Vec3): Vec3;
+    area(): number;
+    midpoint(out: Vec3): Vec3;
+    plane(out: Plane): Plane;
+    barycoord(p: Vec3Like, out: Vec3): boolean;
+    containsPoint(p: Vec3Like): boolean;
+    closestPointToPoint(p: Vec3Like, out: Vec3): Vec3;
+}
+declare class Spherical {
+    radius: number;
+    polar: number;
+    azimuth: number;
+    set(radius: number, polar: number, azimuth: number): this;
+    makeSafe(): this;
+    setFromVector(v: Vec3Like): this;
+    toVector(out: Vec3): Vec3;
+}
+declare class Cylindrical {
+    radius: number;
+    theta: number;
+    y: number;
+    set(radius: number, theta: number, y: number): this;
+    setFromVector(v: Vec3Like): this;
+    toVector(out: Vec3): Vec3;
+}
+
+interface InputSurface {
+    addEventListener(type: string, listener: (event: Event) => void, options?: AddEventListenerOptions): void;
+    removeEventListener(type: string, listener: (event: Event) => void): void;
+    getBoundingClientRect(): DOMRect;
+}
+interface DomInputOptions {
+    readonly wheel?: boolean;
+    readonly preventWheel?: boolean;
+    readonly orientation?: boolean;
+    readonly preventContextMenu?: boolean;
+}
+declare function wheelPixels(delta: number, mode: number, pageHeight: number): number;
+declare function attachDomInput(input: InputActions, surface: InputSurface, keyTarget: EventTarget, options?: DomInputOptions): () => void;
+interface PointerLockTarget {
+    requestPointerLock(): Promise<void> | void;
+}
+interface PointerLockDocument {
+    readonly pointerLockElement: Element | null;
+    exitPointerLock(): void;
+}
+declare function requestPointerLock(target: PointerLockTarget): Promise<boolean>;
+declare function exitPointerLock(doc: PointerLockDocument): void;
+declare function isPointerLocked(doc: PointerLockDocument, target: unknown): boolean;
+declare function requestOrientationPermission(source?: unknown): Promise<boolean>;
+declare function screenOrientationDegrees(source?: unknown): number;
+interface GamepadButtonLike {
+    readonly value: number;
+    readonly pressed: boolean;
+}
+interface GamepadEffectLike {
+    playEffect(type: "dual-rumble", params: {
+        duration: number;
+        strongMagnitude: number;
+        weakMagnitude: number;
+        startDelay?: number;
+    }): Promise<unknown>;
+}
+interface GamepadLike {
+    readonly connected: boolean;
+    readonly buttons: readonly GamepadButtonLike[];
+    readonly axes: readonly number[];
+    readonly vibrationActuator?: GamepadEffectLike | null;
+}
+interface GamepadSource {
+    getGamepads(): ArrayLike<GamepadLike | null>;
+}
+declare class GamepadPoller {
+    readonly index: number;
+    private readonly source;
+    private readonly buttons;
+    private readonly axes;
+    private connectedState;
+    constructor(source: GamepadSource, index?: number);
+    get connected(): boolean;
+    poll(input: InputActions, timeMs: number): boolean;
+    rumble(strong: number, weak: number, durationMs: number): boolean;
+    private pad;
+}
+
+type ProjectionMode = "perspective" | "orthographic";
+interface NodeMatrixSource {
+    readNodeMatrix(node: NodeId, out: Float32Array, offset?: number): void;
+}
+interface CameraProjectionOptions {
+    readonly mode?: ProjectionMode;
+    readonly fov?: number;
+    readonly near?: number;
+    readonly far?: number;
+    readonly height?: number;
+    readonly zoom?: number;
+    readonly width?: number;
+    readonly viewportHeight?: number;
+}
+interface ViewOffset {
+    readonly fullWidth: number;
+    readonly fullHeight: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+declare class CameraProjection {
+    mode: ProjectionMode;
+    fov: number;
+    near: number;
+    far: number;
+    orthoHeight: number;
+    zoom: number;
+    width: number;
+    height: number;
+    w: number;
+    readonly world: Float64Array<ArrayBuffer>;
+    readonly view: Float64Array<ArrayBuffer>;
+    readonly projection: Float64Array<ArrayBuffer>;
+    readonly projectionInverse: Float64Array<ArrayBuffer>;
+    readonly viewProjection: Float64Array<ArrayBuffer>;
+    readonly viewProjectionInverse: Float64Array<ArrayBuffer>;
+    readonly position: Vec3;
+    private readonly offset;
+    private hasOffset;
+    private readonly custom;
+    private hasCustom;
+    private readonly scratch;
+    private readonly scratchB;
+    private readonly matrixScratch;
+    constructor(options?: CameraProjectionOptions);
+    get aspect(): number;
+    setViewport(width: number, height: number): this;
+    setPerspective(fovDegrees: number, near: number, far: number): this;
+    setOrthographic(height: number, near: number, far: number): this;
+    setViewOffset(offset: ViewOffset): this;
+    clearViewOffset(): this;
+    setCustomProjection(matrix: ArrayLike<number> | null, offset?: number): this;
+    get customProjection(): boolean;
+    updateProjection(): this;
+    update(world: ArrayLike<number>, offset?: number): this;
+    updateFromNode(source: NodeMatrixSource, node: NodeId): this;
+    updateView(): this;
+    worldToNdc(world: Vec3Like, out: Vec3): boolean;
+    inFront(world: Vec3Like): boolean;
+    worldToScreen(world: Vec3Like, out: Vec3, normalized?: boolean): boolean;
+    unproject(ndcX: number, ndcY: number, ndcZ: number, out: Vec3): Vec3;
+    screenToNdc(x: number, y: number, normalized: boolean, out: Vec3): Vec3;
+    screenToRay(x: number, y: number, out: Ray, normalized?: boolean): Ray;
+    screenToWorld(x: number, y: number, distance: number, out: Vec3, ray: Ray, normalized?: boolean): Vec3;
+    forward(out: Vec3): Vec3;
+    frustum(out: Frustum): Frustum;
+    pixelsPerUnitAt(distance: number): number;
+    private combine;
+}
+
+interface TerrainRecipe {
+    readonly base?: number;
+    readonly amplitude?: number;
+    readonly octaves?: number;
+    readonly frequency?: number;
+    readonly lacunarity?: number;
+    readonly gain?: number;
+    readonly seed?: number;
+    readonly ridged?: number;
+    readonly warp?: number;
+    readonly rockSlope?: number;
+    readonly snowHeight?: number;
+    readonly sandHeight?: number;
+}
+interface TerrainOptions {
+    readonly size?: number;
+    readonly spacing?: number;
+    readonly center?: readonly [number, number];
+    readonly heightMin?: number;
+    readonly heightRange?: number;
+    readonly tier?: DeviceTier;
+    readonly recipe?: TerrainRecipe;
+    readonly pack?: Uint8Array;
+}
+interface GrassOptions {
+    readonly seed?: number;
+    readonly density?: number;
+    readonly height?: readonly [number, number];
+    readonly width?: readonly [number, number];
+    readonly radius?: number;
+    readonly maxSlope?: number;
+    readonly layer?: number;
+    readonly color?: readonly [number, number, number];
+    readonly tipBrightness?: number;
+}
+interface LayerOptions {
+    readonly color: readonly [number, number, number];
+    readonly roughness?: number;
+    readonly tiling?: number;
+    readonly heightScale?: number;
+    readonly variation?: number;
+    readonly normalStrength?: number;
+}
+interface ScatterRules {
+    readonly area: readonly [number, number, number, number];
+    readonly seed?: number;
+    readonly kind?: number;
+    readonly spacing?: number;
+    readonly chance?: number;
+    readonly height?: readonly [number, number];
+    readonly slope?: readonly [number, number];
+    readonly scale?: readonly [number, number];
+    readonly layer?: number;
+    readonly layerFloor?: number;
+}
+declare class ScatterColumns {
+    readonly capacity: number;
+    readonly data: Float32Array;
+    readonly x: Float32Array;
+    readonly y: Float32Array;
+    readonly z: Float32Array;
+    readonly yaw: Float32Array;
+    readonly scale: Float32Array;
+    readonly kind: Uint32Array;
+    count: number;
+    constructor(capacity: number);
+}
+declare class Terrain {
+    private readonly port;
+    private readonly handle;
+    readonly radius: number;
+    private readonly eye;
+    private readonly brush;
+    private readonly grassWords;
+    private readonly layerWords;
+    private readonly rules;
+    private readonly normalOut;
+    private registerView;
+    private closed;
+    constructor(port: TerrainPort, handle: number, radius?: number);
+    gravity(surface: number): number;
+    private registers;
+    update(x: number, y: number, z: number, vx?: number, vy?: number, vz?: number): number;
+    heightAt(x: number, z: number): number;
+    normalAt(x: number, z: number, out?: Float32Array): Float32Array | null;
+    sculpt(op: BrushOp, x: number, z: number, radius: number, strength: number, target?: number, layer?: number): number;
+    paint(layer: number, x: number, z: number, radius: number, strength: number): number;
+    hole(x: number, z: number, radius: number, open?: boolean): number;
+    colliders(x: number, y: number, z: number): number;
+    grass(options?: GrassOptions | false): void;
+    setWind(x: number, z: number, strength: number, gust: number): void;
+    setInteractors(data: Float32Array, count: number): void;
+    setLayers(layers: readonly LayerOptions[]): void;
+    scatter(rules: ScatterRules, out: ScatterColumns): number;
+    get resident(): number;
+    get nodes(): number;
+    get inflight(): number;
+    get totalInstalls(): number;
+    dispose(): void;
+}
+interface PlanetOptions {
+    readonly radius: number;
+    readonly levels?: number;
+    readonly amplitude?: number;
+    readonly seed?: number;
+    readonly tier?: DeviceTier;
+}
+declare function openTerrain(port: TerrainPort | null | undefined, options?: TerrainOptions): Terrain;
+declare function openPlanet(port: TerrainPort | null | undefined, options: PlanetOptions): Terrain;
+declare function noise(port: TerrainPort | null | undefined, kind: NoiseKind, x: number, y: number, z: number, seed?: number): number;
+
+export { openTerrain as $, type PlanetOptions as A, Box3 as B, CHEMISTRY_AI_CAPABILITY as C, type DomInputOptions as D, type ProjectionMode as E, Frustum as F, type GamepadLike as G, Ray as H, type InputSurface as I, ScatterColumns as J, type ScatterRules as K, type LayerOptions as L, MAX_FORMULA as M, type NodeMatrixSource as N, Spherical as O, PROPOSAL_SCHEMA as P, type TerrainOptions as Q, type ReactionIdea as R, Sphere as S, Terrain as T, type TerrainRecipe as U, Triangle as V, attachDomInput as W, exitPointerLock as X, isPointerLocked as Y, noise as Z, openPlanet as _, CHEMISTRY_PROMPT as a, requestOrientationPermission as a0, requestPointerLock as a1, screenOrientationDegrees as a2, wheelPixels as a3, CHEMISTRY_SCHEMA as b, CHEMISTRY_TEMPLATE as c, type ChemistryAi as d, MAX_KNOWN_CHARS as e, MAX_NAME as f, MAX_SPECIES as g, MAX_TERMS as h, type Proposal as i, type ProposedMaterial as j, type ProposedTerm as k, chemistryAiSection as l, chemistryAiToml as m, knownMaterials as n, proposeReaction as o, proposalText as p, type PointerLockTarget as q, reactionRequest as r, type PointerLockDocument as s, CameraProjection as t, type CameraProjectionOptions as u, Cylindrical as v, GamepadPoller as w, type GamepadSource as x, type GrassOptions as y, Plane as z };