@cimplify/sdk 0.108.0 → 0.110.2

package/dist/tycoon-hmHo-3HX.d.ts

@@ -0,0 +1,255 @@
+import { kP as StoreApi, C as Ctx, fV as HostCall, dZ as CtxEconomy, hA as ParticipantId, gJ as LedgerReceipt, f9 as ExchangeReceipt, lw as TradeOffer, lz as TradeSettlement, eT as EconomyCatalogue } from './local-VZkqsCzR.js';
+import { L as LifecycleSource, K as KeySource } from './ports-CGU_3e_0.js';
+import { c as Currency, j as Item, F as Faucet, S as Sink, f as Exchange, b as CimplesOffer, p as RandomExchange, E as EconomyDecl, x as SoftValue, z as ValueGrant, u as SoftCurrency, m as PremiumExchange, n as PremiumItem, g as FixedOffer, l as PremiumCurrency, h as GenreTemplate, q as RandomOffer } from './template-BkEGVTQj.js';
+import { G as Game } from './game-fgQy2YIm.js';
+import { G as GameScene } from './fluid-ARr0qUIL.js';
+
+type SaveStorePort = Pick<StoreApi, "get" | "commit">;
+type Migration = (previous: unknown) => unknown;
+interface SaveSchema<T> {
+    readonly name: string;
+    readonly version: number;
+    initial(): T;
+    parse(value: unknown): T | null;
+    readonly migrations?: Readonly<Record<number, Migration>>;
+}
+type LoadStatus = "fresh" | "loaded" | "migrated" | "newer" | "invalid";
+interface Loaded<T> {
+    readonly value: T;
+    readonly status: LoadStatus;
+    readonly writtenBy: string | null;
+}
+declare class SaveSlots<T> {
+    readonly schema: SaveSchema<T>;
+    private readonly store;
+    private readonly revision;
+    private readonly blocked;
+    private readonly writes;
+    constructor(store: SaveStorePort, schema: SaveSchema<T>, revision: string);
+    load(slot: string): Promise<Loaded<T>>;
+    save(slot: string, value: T): Promise<void>;
+    reset(slot: string, value?: T): Promise<void>;
+    private write;
+    private block;
+}
+type SaveCtx = Pick<Ctx, "open_store" | "program">;
+declare function openSaveSlots<T>(ctx: SaveCtx, schema: SaveSchema<T>): Promise<SaveSlots<T>>;
+declare class Autosave<T> {
+    private readonly slots;
+    private readonly slot;
+    private readonly source;
+    private readonly unsubscribes;
+    private dirty;
+    private inflight;
+    private readonly onEvent;
+    constructor(slots: SaveSlots<T>, slot: string, source: () => T, lifecycle: LifecycleSource);
+    get pending(): boolean;
+    markDirty(): void;
+    flush(): Promise<void>;
+    dispose(): void;
+}
+
+declare const MS_PER_DAY = 86400000;
+declare function dayIndex(unixMs: number, utcOffsetMinutes?: number): number;
+declare function utcOffsetMinutes(timeZone: string, unixMs: number): number;
+declare function hashSalt(salt: string): number;
+declare function daySeed(day: number, salt: number): number;
+interface ChallengeDecl<K extends string = string> {
+    readonly id: string;
+    readonly kind: K;
+    readonly target: number;
+}
+declare class DailyChallenges<K extends string = string> {
+    readonly pool: readonly ChallengeDecl<K>[];
+    readonly perDay: number;
+    private readonly salt;
+    private readonly random;
+    private readonly order;
+    readonly picks: Int32Array;
+    readonly progress: Float64Array;
+    private dayValue;
+    constructor(pool: readonly ChallengeDecl<K>[], perDay: number, salt: string);
+    get day(): number;
+    select(day: number): boolean;
+    record(kind: K, amount: number): void;
+    maxOut(kind: K, value: number): void;
+    challenge(index: number): ChallengeDecl<K>;
+    completed(index: number): boolean;
+    allCompleted(): boolean;
+    snapshot(): {
+        readonly day: number;
+        readonly progress: readonly number[];
+    };
+    restore(saved: {
+        readonly day: number;
+        readonly progress: readonly number[];
+    } | null, today: number): void;
+}
+
+interface Economy {
+    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[];
+    currencyIndex(id: string): number;
+    itemIndex(id: string): number;
+    offer(id: string): CimplesOffer | null;
+}
+declare function defineEconomy(decl: EconomyDecl): Economy;
+
+interface EconomyExchangePort {
+    exchange: HostCall<"game.economy.exchange">;
+}
+interface LedgerPorts {
+    readonly economy: CtxEconomy;
+    readonly keys: KeySource;
+    readonly exchange?: EconomyExchangePort | null;
+}
+type TradeableValue = SoftCurrency | Item;
+declare class Ledger {
+    private readonly declared;
+    private readonly ports;
+    private readonly amounts;
+    private readonly holdings;
+    private revisionValue;
+    private ownerValue;
+    constructor(economy: Economy, ports: LedgerPorts);
+    get revision(): number;
+    get owner(): ParticipantId | null;
+    balance(currency: Currency): number;
+    holding(item: Item): number;
+    verifyCatalogue(): Promise<void>;
+    refresh(): Promise<void>;
+    earn<V extends SoftValue>(rule: Faucet<V>, quantity: number): Promise<LedgerReceipt>;
+    spend<V extends SoftValue>(rule: Sink<V>, quantity: number): Promise<LedgerReceipt>;
+    exchange(exchange: Exchange, quantity?: number): Promise<ExchangeReceipt>;
+    roll(reward: RandomExchange): Promise<ExchangeReceipt>;
+    propose(counterparty: ParticipantId, give: readonly ValueGrant<TradeableValue>[], take: readonly ValueGrant<TradeableValue>[], expiresInMs: number): Promise<TradeOffer>;
+    accept(tradeId: string): Promise<TradeSettlement>;
+    cancel(tradeId: string): Promise<TradeOffer>;
+    private settle;
+    private apply;
+}
+declare function catalogueProblems(economy: Economy, catalogue: EconomyCatalogue): string[];
+
+declare const STALLS = 4;
+declare const STALL_NAMES: readonly string[];
+declare const coins: SoftCurrency<"coins">;
+declare const gems: PremiumCurrency<"gems">;
+declare const goldenPot: PremiumItem<"golden-pot">;
+declare const chefHat: PremiumItem<"chef-hat">;
+declare const festivalBanner: PremiumItem<"festival-banner">;
+declare const stallEarnings: Faucet<SoftCurrency<"coins">>;
+declare const buyStall: Sink<SoftCurrency<"coins">>;
+declare const buyChefHat: PremiumExchange;
+declare const gemPouch: FixedOffer;
+declare const coinPack: FixedOffer;
+declare const spiceCrate: RandomOffer;
+declare const spiceCrateForGems: RandomExchange;
+declare const tycoonEconomy: EconomyDecl;
+type TycoonChallenge = "cook" | "buy" | "collect";
+declare const TYCOON_CHALLENGES: readonly ChallengeDecl<TycoonChallenge>[];
+declare const BANK_COINS = 0;
+declare const BANK_COLLECT = 0;
+declare const BANK_BUY = 1;
+interface TycoonBank {
+    readonly coins: Float64Array;
+    readonly requests: Float64Array;
+    readonly confirmed: Int32Array;
+    pump(): void;
+}
+type TycoonBankFactory = (costs: Float64Array) => TycoonBank;
+declare class LocalTycoonBank implements TycoonBank {
+    readonly coins: Float64Array<ArrayBuffer>;
+    readonly requests: Float64Array<ArrayBuffer>;
+    readonly confirmed: Int32Array<ArrayBuffer>;
+    private readonly costs;
+    constructor(costs: Float64Array, starting?: number);
+    pump(): void;
+}
+declare class LedgerTycoonBank implements TycoonBank {
+    readonly coins: Float64Array<ArrayBuffer>;
+    readonly requests: Float64Array<ArrayBuffer>;
+    readonly confirmed: Int32Array<ArrayBuffer>;
+    private readonly ledger;
+    private readonly costs;
+    private busy;
+    constructor(ledger: Ledger, costs: Float64Array);
+    pump(): void;
+    private run;
+}
+interface TycoonSave {
+    readonly owned: readonly number[];
+    readonly pending: number;
+    readonly earned: number;
+    readonly savedAt: number;
+}
+declare const tycoonSaveSchema: SaveSchema<TycoonSave>;
+declare class JollofTycoon implements GameScene<Game> {
+    readonly name = "jollof-tycoon";
+    readonly owned: Int32Array<ArrayBuffer>;
+    readonly cost: Float64Array<ArrayBuffer>;
+    readonly potProgress: Float64Array<ArrayBuffer>;
+    readonly stats: Float64Array<ArrayBuffer>;
+    readonly daily: DailyChallenges<TycoonChallenge>;
+    readonly bank: TycoonBank;
+    potsCooked: number;
+    stallsBought: number;
+    private readonly springs;
+    private readonly pops;
+    private readonly buyActions;
+    private collectAction;
+    private coinSlot;
+    private pendingSlot;
+    private readonly ownedSlots;
+    private boxes;
+    constructor(bank?: TycoonBankFactory | null, daily?: DailyChallenges<TycoonChallenge> | null);
+    get pending(): number;
+    get earned(): number;
+    enter(game: Game): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    snapshot(nowMs: number): TycoonSave;
+    restore(save: TycoonSave, nowMs: number): number;
+}
+declare const jollofTycoonTemplate: GenreTemplate<JollofTycoon>;
+
+declare const tycoon_BANK_BUY: typeof BANK_BUY;
+declare const tycoon_BANK_COINS: typeof BANK_COINS;
+declare const tycoon_BANK_COLLECT: typeof BANK_COLLECT;
+type tycoon_JollofTycoon = JollofTycoon;
+declare const tycoon_JollofTycoon: typeof JollofTycoon;
+type tycoon_LedgerTycoonBank = LedgerTycoonBank;
+declare const tycoon_LedgerTycoonBank: typeof LedgerTycoonBank;
+type tycoon_LocalTycoonBank = LocalTycoonBank;
+declare const tycoon_LocalTycoonBank: typeof LocalTycoonBank;
+declare const tycoon_STALLS: typeof STALLS;
+declare const tycoon_STALL_NAMES: typeof STALL_NAMES;
+declare const tycoon_TYCOON_CHALLENGES: typeof TYCOON_CHALLENGES;
+type tycoon_TycoonBank = TycoonBank;
+type tycoon_TycoonBankFactory = TycoonBankFactory;
+type tycoon_TycoonChallenge = TycoonChallenge;
+type tycoon_TycoonSave = TycoonSave;
+declare const tycoon_buyChefHat: typeof buyChefHat;
+declare const tycoon_buyStall: typeof buyStall;
+declare const tycoon_chefHat: typeof chefHat;
+declare const tycoon_coinPack: typeof coinPack;
+declare const tycoon_coins: typeof coins;
+declare const tycoon_festivalBanner: typeof festivalBanner;
+declare const tycoon_gemPouch: typeof gemPouch;
+declare const tycoon_gems: typeof gems;
+declare const tycoon_goldenPot: typeof goldenPot;
+declare const tycoon_jollofTycoonTemplate: typeof jollofTycoonTemplate;
+declare const tycoon_spiceCrate: typeof spiceCrate;
+declare const tycoon_spiceCrateForGems: typeof spiceCrateForGems;
+declare const tycoon_stallEarnings: typeof stallEarnings;
+declare const tycoon_tycoonEconomy: typeof tycoonEconomy;
+declare const tycoon_tycoonSaveSchema: typeof tycoonSaveSchema;
+declare namespace tycoon {
+  export { tycoon_BANK_BUY as BANK_BUY, tycoon_BANK_COINS as BANK_COINS, tycoon_BANK_COLLECT as BANK_COLLECT, tycoon_JollofTycoon as JollofTycoon, tycoon_LedgerTycoonBank as LedgerTycoonBank, tycoon_LocalTycoonBank as LocalTycoonBank, tycoon_STALLS as STALLS, tycoon_STALL_NAMES as STALL_NAMES, tycoon_TYCOON_CHALLENGES as TYCOON_CHALLENGES, type tycoon_TycoonBank as TycoonBank, type tycoon_TycoonBankFactory as TycoonBankFactory, type tycoon_TycoonChallenge as TycoonChallenge, type tycoon_TycoonSave as TycoonSave, tycoon_buyChefHat as buyChefHat, tycoon_buyStall as buyStall, tycoon_chefHat as chefHat, tycoon_coinPack as coinPack, tycoon_coins as coins, tycoon_festivalBanner as festivalBanner, tycoon_gemPouch as gemPouch, tycoon_gems as gems, tycoon_goldenPot as goldenPot, tycoon_jollofTycoonTemplate as jollofTycoonTemplate, tycoon_spiceCrate as spiceCrate, tycoon_spiceCrateForGems as spiceCrateForGems, tycoon_stallEarnings as stallEarnings, tycoon_tycoonEconomy as tycoonEconomy, tycoon_tycoonSaveSchema as tycoonSaveSchema };
+}
+
+export { Autosave as A, BANK_BUY as B, type ChallengeDecl as C, DailyChallenges as D, type Economy as E, type TycoonSave as F, buyChefHat as G, buyStall as H, chefHat as I, JollofTycoon as J, coinPack as K, Ledger as L, MS_PER_DAY as M, coins as N, festivalBanner as O, gemPouch as P, gems as Q, goldenPot as R, type SaveCtx as S, type TradeableValue as T, jollofTycoonTemplate as U, spiceCrate as V, spiceCrateForGems as W, stallEarnings as X, tycoonEconomy as Y, tycoonSaveSchema as Z, type EconomyExchangePort as a, type LedgerPorts as b, type LoadStatus as c, type Loaded as d, type Migration as e, type SaveSchema as f, SaveSlots as g, type SaveStorePort as h, catalogueProblems as i, dayIndex as j, daySeed as k, defineEconomy as l, hashSalt as m, BANK_COINS as n, openSaveSlots as o, BANK_COLLECT as p, LedgerTycoonBank as q, LocalTycoonBank as r, STALLS as s, tycoon as t, utcOffsetMinutes as u, STALL_NAMES as v, TYCOON_CHALLENGES as w, type TycoonBank as x, type TycoonBankFactory as y, type TycoonChallenge as z };

package/dist/types-BQkxPwZP.d.mts

@@ -0,0 +1,219 @@
+import { C as CompoundPartDesc, D as DeviceTier, B as BrushOp } from './backend-gUCzs5Kg.mjs';
+
+declare const CSG_EPSILON = 0.00001;
+interface CsgVertex {
+    readonly p: readonly [number, number, number];
+    readonly n: readonly [number, number, number];
+}
+declare class CsgPlane {
+    readonly normal: readonly [number, number, number];
+    readonly w: number;
+    constructor(normal: readonly [number, number, number], w: number);
+    static through(a: readonly number[], b: readonly number[], c: readonly number[]): CsgPlane | null;
+    flipped(): CsgPlane;
+    distance(p: readonly number[]): number;
+    split(polygon: CsgPolygon, coplanarFront: CsgPolygon[], coplanarBack: CsgPolygon[], front: CsgPolygon[], back: CsgPolygon[]): void;
+}
+declare class CsgPolygon {
+    readonly vertices: readonly CsgVertex[];
+    readonly shared: number;
+    readonly plane: CsgPlane;
+    constructor(vertices: readonly CsgVertex[], shared: number, plane: CsgPlane);
+    static of(vertices: readonly CsgVertex[], shared: number): CsgPolygon | null;
+    flipped(): CsgPolygon;
+}
+type CsgOperation = "union" | "subtract" | "intersect";
+declare function csg(a: readonly CsgPolygon[], b: readonly CsgPolygon[], operation: CsgOperation): CsgPolygon[];
+
+type Vec3 = readonly [number, number, number];
+type ThingShape = {
+    readonly kind: "box";
+    readonly size: Vec3;
+} | {
+    readonly kind: "sphere";
+    readonly radius: number;
+} | {
+    readonly kind: "cylinder";
+    readonly radius: number;
+    readonly height: number;
+} | {
+    readonly kind: "tube";
+    readonly radius: number;
+    readonly length: number;
+} | {
+    readonly kind: "rounded";
+    readonly size: Vec3;
+    readonly radius: number;
+};
+type ThingShapeKind = ThingShape["kind"];
+declare const THING_SHAPE_KINDS: readonly ThingShapeKind[];
+interface Placement {
+    readonly at: Vec3;
+    readonly turn: Vec3;
+    readonly mirror: 0 | 1 | 2 | -1;
+}
+type Matrix = readonly [number, number, number, number, number, number, number, number, number];
+declare function rotationMatrix(turn: Vec3): Matrix;
+declare function shapeFaces(shape: ThingShape, segments: number): CsgVertex[][];
+declare function shapePolygons(shape: ThingShape, placement: Placement, shared: number, segments: number): CsgPolygon[];
+declare function shapeRadius(shape: ThingShape): number;
+
+type ThingCombine = "join" | "cut" | "overlap";
+type ThingMirror = "none" | "x" | "y" | "z";
+type ThingEffectKind = "fire" | "smoke" | "steam" | "sparks" | "confetti" | "water" | "rain" | "break" | "sound";
+interface ThingPart {
+    readonly id: string;
+    readonly name: string;
+    readonly shape: ThingShape;
+    readonly at: Vec3;
+    readonly turn: Vec3;
+    readonly material: string;
+    readonly combine: ThingCombine;
+    readonly mirror: ThingMirror;
+}
+interface ThingEffect {
+    readonly kind: ThingEffectKind;
+    readonly at: Vec3;
+    readonly size: number;
+    readonly startsAfter?: number;
+    readonly lasts?: number;
+    readonly color?: number;
+    readonly sound?: string | null;
+}
+interface Thing {
+    readonly name: string;
+    readonly parts: readonly ThingPart[];
+    readonly effects: readonly ThingEffect[];
+}
+interface ThingMeshGroup {
+    readonly material: string;
+    readonly start: number;
+    readonly count: number;
+}
+interface ThingMesh {
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly indices: Uint32Array;
+    readonly groups: readonly ThingMeshGroup[];
+    readonly triangles: number;
+}
+interface ThingMass {
+    readonly volume: number;
+    readonly mass: number;
+    readonly centre: Vec3;
+}
+type PhoneCost = "light" | "medium" | "heavy";
+interface ThingLevel {
+    readonly name: "close" | "middle" | "far";
+    readonly mesh: ThingMesh;
+    readonly dropped: readonly string[];
+}
+interface CompiledThing {
+    readonly levels: readonly ThingLevel[];
+    readonly mass: ThingMass;
+    readonly collider: {
+        readonly kind: "compound";
+        readonly parts: readonly CompoundPartDesc[];
+    };
+    readonly bounds: {
+        readonly min: Vec3;
+        readonly max: Vec3;
+    };
+    readonly cost: PhoneCost;
+    readonly effects: readonly ThingEffect[];
+}
+declare const THING_COMBINES: readonly ThingCombine[];
+declare const THING_MIRRORS: readonly ThingMirror[];
+declare const THING_EFFECTS: readonly ThingEffectKind[];
+declare const CLOSE_SEGMENTS = 32;
+declare const MIDDLE_SEGMENTS = 12;
+declare const SMALL_PART_SHARE = 0.08;
+declare const LIGHT_TRIANGLES = 4000;
+declare const MEDIUM_TRIANGLES = 16000;
+declare const EFFECT_TRIANGLE_COST = 1000;
+declare const MAX_THING_PARTS = 64;
+declare class ThingError extends Error {
+    constructor(message: string);
+}
+declare function massOf(mesh: ThingMesh): ThingMass;
+declare function colliderOf(thing: Thing): {
+    readonly kind: "compound";
+    readonly parts: readonly CompoundPartDesc[];
+};
+declare function phoneCost(triangles: number, effects: number): PhoneCost;
+declare function compileThing(thing: Thing): CompiledThing;
+
+type Point2 = readonly [number, number];
+type WorldLayer = "ground" | "roads" | "buildings" | "props" | "crowds" | "lights" | "sounds";
+declare const WORLD_LAYERS: readonly WorldLayer[];
+interface WorldPlacement {
+    readonly kind: string;
+    readonly at: Point2;
+    readonly yaw: number;
+}
+interface GroundStroke {
+    readonly op: BrushOp;
+    readonly at: Point2;
+    readonly radius: number;
+    readonly strength: number;
+    readonly target: number | null;
+    readonly layer: number;
+}
+interface Road {
+    readonly points: readonly Point2[];
+    readonly width: number;
+}
+interface ScatterStroke {
+    readonly layer: "props" | "crowds";
+    readonly kinds: readonly string[];
+    readonly at: Point2;
+    readonly radius: number;
+    readonly count: number;
+    readonly spacing: number;
+    readonly seed: number;
+}
+interface CrowdArea {
+    readonly at: Point2;
+    readonly radius: number;
+    readonly count: number;
+    readonly kinds: readonly string[];
+}
+interface WorldLight {
+    readonly at: Point2;
+    readonly height: number;
+    readonly color: number;
+    readonly intensity: number;
+}
+interface SoundZone {
+    readonly at: Point2;
+    readonly radius: number;
+    readonly sound: string;
+}
+type WeatherPreset = "clear" | "overcast" | "fog" | "drizzle" | "heavy_rain" | "thunderstorm" | "snow" | "blizzard" | "desert_dust" | "monsoon" | "golden_hour" | "night" | "harmattan_haze" | "real_sky";
+interface WorldSky {
+    readonly hour: number;
+    readonly weather: WeatherPreset;
+    readonly dayMinutes: number;
+}
+type CrowdCaps = {
+    readonly [T in DeviceTier]?: number | null;
+};
+interface WorldDoc {
+    readonly name: string;
+    readonly place: string | null;
+    readonly size: Point2;
+    readonly ground: readonly GroundStroke[];
+    readonly roads: readonly Road[];
+    readonly buildings: readonly WorldPlacement[];
+    readonly props: readonly WorldPlacement[];
+    readonly scatters: readonly ScatterStroke[];
+    readonly crowds: readonly CrowdArea[];
+    readonly lights: readonly WorldLight[];
+    readonly sounds: readonly SoundZone[];
+    readonly gates: readonly Point2[];
+    readonly sky: WorldSky;
+    readonly crowdCaps?: CrowdCaps;
+}
+declare function emptyWorld(name: string, size: Point2, place?: string | null): WorldDoc;
+
+export { rotationMatrix as $, type ThingPart as A, type ThingShape as B, CLOSE_SEGMENTS as C, type ThingShapeKind as D, EFFECT_TRIANGLE_COST as E, type WeatherPreset as F, type GroundStroke as G, type WorldDoc as H, type WorldLayer as I, type WorldLight as J, type WorldPlacement as K, LIGHT_TRIANGLES as L, MAX_THING_PARTS as M, type Point2 as N, type WorldSky as O, type PhoneCost as P, colliderOf as Q, type Road as R, SMALL_PART_SHARE as S, THING_COMBINES as T, compileThing as U, type Vec3 as V, WORLD_LAYERS as W, csg as X, emptyWorld as Y, massOf as Z, phoneCost as _, CSG_EPSILON as a, shapeFaces as a0, shapePolygons as a1, shapeRadius as a2, type CompiledThing as b, type CrowdArea as c, type CrowdCaps as d, type CsgOperation as e, CsgPlane as f, CsgPolygon as g, type CsgVertex as h, MEDIUM_TRIANGLES as i, MIDDLE_SEGMENTS as j, type Placement as k, type ScatterStroke as l, type SoundZone as m, THING_EFFECTS as n, THING_MIRRORS as o, THING_SHAPE_KINDS as p, type Thing as q, type ThingCombine as r, type ThingEffect as s, type ThingEffectKind as t, ThingError as u, type ThingLevel as v, type ThingMass as w, type ThingMesh as x, type ThingMeshGroup as y, type ThingMirror as z };

package/dist/types-D_f6UUxM.d.ts

@@ -0,0 +1,219 @@
+import { C as CompoundPartDesc, D as DeviceTier, B as BrushOp } from './backend-gUCzs5Kg.js';
+
+declare const CSG_EPSILON = 0.00001;
+interface CsgVertex {
+    readonly p: readonly [number, number, number];
+    readonly n: readonly [number, number, number];
+}
+declare class CsgPlane {
+    readonly normal: readonly [number, number, number];
+    readonly w: number;
+    constructor(normal: readonly [number, number, number], w: number);
+    static through(a: readonly number[], b: readonly number[], c: readonly number[]): CsgPlane | null;
+    flipped(): CsgPlane;
+    distance(p: readonly number[]): number;
+    split(polygon: CsgPolygon, coplanarFront: CsgPolygon[], coplanarBack: CsgPolygon[], front: CsgPolygon[], back: CsgPolygon[]): void;
+}
+declare class CsgPolygon {
+    readonly vertices: readonly CsgVertex[];
+    readonly shared: number;
+    readonly plane: CsgPlane;
+    constructor(vertices: readonly CsgVertex[], shared: number, plane: CsgPlane);
+    static of(vertices: readonly CsgVertex[], shared: number): CsgPolygon | null;
+    flipped(): CsgPolygon;
+}
+type CsgOperation = "union" | "subtract" | "intersect";
+declare function csg(a: readonly CsgPolygon[], b: readonly CsgPolygon[], operation: CsgOperation): CsgPolygon[];
+
+type Vec3 = readonly [number, number, number];
+type ThingShape = {
+    readonly kind: "box";
+    readonly size: Vec3;
+} | {
+    readonly kind: "sphere";
+    readonly radius: number;
+} | {
+    readonly kind: "cylinder";
+    readonly radius: number;
+    readonly height: number;
+} | {
+    readonly kind: "tube";
+    readonly radius: number;
+    readonly length: number;
+} | {
+    readonly kind: "rounded";
+    readonly size: Vec3;
+    readonly radius: number;
+};
+type ThingShapeKind = ThingShape["kind"];
+declare const THING_SHAPE_KINDS: readonly ThingShapeKind[];
+interface Placement {
+    readonly at: Vec3;
+    readonly turn: Vec3;
+    readonly mirror: 0 | 1 | 2 | -1;
+}
+type Matrix = readonly [number, number, number, number, number, number, number, number, number];
+declare function rotationMatrix(turn: Vec3): Matrix;
+declare function shapeFaces(shape: ThingShape, segments: number): CsgVertex[][];
+declare function shapePolygons(shape: ThingShape, placement: Placement, shared: number, segments: number): CsgPolygon[];
+declare function shapeRadius(shape: ThingShape): number;
+
+type ThingCombine = "join" | "cut" | "overlap";
+type ThingMirror = "none" | "x" | "y" | "z";
+type ThingEffectKind = "fire" | "smoke" | "steam" | "sparks" | "confetti" | "water" | "rain" | "break" | "sound";
+interface ThingPart {
+    readonly id: string;
+    readonly name: string;
+    readonly shape: ThingShape;
+    readonly at: Vec3;
+    readonly turn: Vec3;
+    readonly material: string;
+    readonly combine: ThingCombine;
+    readonly mirror: ThingMirror;
+}
+interface ThingEffect {
+    readonly kind: ThingEffectKind;
+    readonly at: Vec3;
+    readonly size: number;
+    readonly startsAfter?: number;
+    readonly lasts?: number;
+    readonly color?: number;
+    readonly sound?: string | null;
+}
+interface Thing {
+    readonly name: string;
+    readonly parts: readonly ThingPart[];
+    readonly effects: readonly ThingEffect[];
+}
+interface ThingMeshGroup {
+    readonly material: string;
+    readonly start: number;
+    readonly count: number;
+}
+interface ThingMesh {
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly indices: Uint32Array;
+    readonly groups: readonly ThingMeshGroup[];
+    readonly triangles: number;
+}
+interface ThingMass {
+    readonly volume: number;
+    readonly mass: number;
+    readonly centre: Vec3;
+}
+type PhoneCost = "light" | "medium" | "heavy";
+interface ThingLevel {
+    readonly name: "close" | "middle" | "far";
+    readonly mesh: ThingMesh;
+    readonly dropped: readonly string[];
+}
+interface CompiledThing {
+    readonly levels: readonly ThingLevel[];
+    readonly mass: ThingMass;
+    readonly collider: {
+        readonly kind: "compound";
+        readonly parts: readonly CompoundPartDesc[];
+    };
+    readonly bounds: {
+        readonly min: Vec3;
+        readonly max: Vec3;
+    };
+    readonly cost: PhoneCost;
+    readonly effects: readonly ThingEffect[];
+}
+declare const THING_COMBINES: readonly ThingCombine[];
+declare const THING_MIRRORS: readonly ThingMirror[];
+declare const THING_EFFECTS: readonly ThingEffectKind[];
+declare const CLOSE_SEGMENTS = 32;
+declare const MIDDLE_SEGMENTS = 12;
+declare const SMALL_PART_SHARE = 0.08;
+declare const LIGHT_TRIANGLES = 4000;
+declare const MEDIUM_TRIANGLES = 16000;
+declare const EFFECT_TRIANGLE_COST = 1000;
+declare const MAX_THING_PARTS = 64;
+declare class ThingError extends Error {
+    constructor(message: string);
+}
+declare function massOf(mesh: ThingMesh): ThingMass;
+declare function colliderOf(thing: Thing): {
+    readonly kind: "compound";
+    readonly parts: readonly CompoundPartDesc[];
+};
+declare function phoneCost(triangles: number, effects: number): PhoneCost;
+declare function compileThing(thing: Thing): CompiledThing;
+
+type Point2 = readonly [number, number];
+type WorldLayer = "ground" | "roads" | "buildings" | "props" | "crowds" | "lights" | "sounds";
+declare const WORLD_LAYERS: readonly WorldLayer[];
+interface WorldPlacement {
+    readonly kind: string;
+    readonly at: Point2;
+    readonly yaw: number;
+}
+interface GroundStroke {
+    readonly op: BrushOp;
+    readonly at: Point2;
+    readonly radius: number;
+    readonly strength: number;
+    readonly target: number | null;
+    readonly layer: number;
+}
+interface Road {
+    readonly points: readonly Point2[];
+    readonly width: number;
+}
+interface ScatterStroke {
+    readonly layer: "props" | "crowds";
+    readonly kinds: readonly string[];
+    readonly at: Point2;
+    readonly radius: number;
+    readonly count: number;
+    readonly spacing: number;
+    readonly seed: number;
+}
+interface CrowdArea {
+    readonly at: Point2;
+    readonly radius: number;
+    readonly count: number;
+    readonly kinds: readonly string[];
+}
+interface WorldLight {
+    readonly at: Point2;
+    readonly height: number;
+    readonly color: number;
+    readonly intensity: number;
+}
+interface SoundZone {
+    readonly at: Point2;
+    readonly radius: number;
+    readonly sound: string;
+}
+type WeatherPreset = "clear" | "overcast" | "fog" | "drizzle" | "heavy_rain" | "thunderstorm" | "snow" | "blizzard" | "desert_dust" | "monsoon" | "golden_hour" | "night" | "harmattan_haze" | "real_sky";
+interface WorldSky {
+    readonly hour: number;
+    readonly weather: WeatherPreset;
+    readonly dayMinutes: number;
+}
+type CrowdCaps = {
+    readonly [T in DeviceTier]?: number | null;
+};
+interface WorldDoc {
+    readonly name: string;
+    readonly place: string | null;
+    readonly size: Point2;
+    readonly ground: readonly GroundStroke[];
+    readonly roads: readonly Road[];
+    readonly buildings: readonly WorldPlacement[];
+    readonly props: readonly WorldPlacement[];
+    readonly scatters: readonly ScatterStroke[];
+    readonly crowds: readonly CrowdArea[];
+    readonly lights: readonly WorldLight[];
+    readonly sounds: readonly SoundZone[];
+    readonly gates: readonly Point2[];
+    readonly sky: WorldSky;
+    readonly crowdCaps?: CrowdCaps;
+}
+declare function emptyWorld(name: string, size: Point2, place?: string | null): WorldDoc;
+
+export { rotationMatrix as $, type ThingPart as A, type ThingShape as B, CLOSE_SEGMENTS as C, type ThingShapeKind as D, EFFECT_TRIANGLE_COST as E, type WeatherPreset as F, type GroundStroke as G, type WorldDoc as H, type WorldLayer as I, type WorldLight as J, type WorldPlacement as K, LIGHT_TRIANGLES as L, MAX_THING_PARTS as M, type Point2 as N, type WorldSky as O, type PhoneCost as P, colliderOf as Q, type Road as R, SMALL_PART_SHARE as S, THING_COMBINES as T, compileThing as U, type Vec3 as V, WORLD_LAYERS as W, csg as X, emptyWorld as Y, massOf as Z, phoneCost as _, CSG_EPSILON as a, shapeFaces as a0, shapePolygons as a1, shapeRadius as a2, type CompiledThing as b, type CrowdArea as c, type CrowdCaps as d, type CsgOperation as e, CsgPlane as f, CsgPolygon as g, type CsgVertex as h, MEDIUM_TRIANGLES as i, MIDDLE_SEGMENTS as j, type Placement as k, type ScatterStroke as l, type SoundZone as m, THING_EFFECTS as n, THING_MIRRORS as o, THING_SHAPE_KINDS as p, type Thing as q, type ThingCombine as r, type ThingEffect as s, type ThingEffectKind as t, ThingError as u, type ThingLevel as v, type ThingMass as w, type ThingMesh as x, type ThingMeshGroup as y, type ThingMirror as z };