@cimplify/sdk 0.108.0 → 0.110.2

package/dist/tick-transport-UjHY3xK1.d.ts

@@ -0,0 +1,50 @@
+import { C as ChannelSink, R as RoomClient, a as RoomClientOptions } from './client-Dytx_ZTC.js';
+import { R as RoomDialer } from './link-BUTqGmyi.js';
+import { T as TickStateReplica } from './state-replica-stMtdkVD.js';
+import { R as RoomTransport, D as Delivery, M as MessageReader } from './game-fgQy2YIm.js';
+
+type RawChannelSink = (view: DataView, offset: number, length: number) => void;
+interface RealtimeRoom {
+    readonly ticket: Uint8Array;
+    readonly primary: RoomDialer | null;
+    readonly fallback: RoomDialer | null;
+}
+interface TickRoomSource {
+    readonly realtime: RealtimeRoom | null;
+}
+interface TickRoomOptions {
+    readonly renew?: () => Promise<Uint8Array>;
+    readonly slots?: number;
+    readonly slotBytes?: number;
+    readonly physicsHz?: number;
+    readonly memory?: RoomClientOptions["memory"];
+    readonly network?: RoomClientOptions["network"];
+}
+declare class TickRoomTransport implements RoomTransport, ChannelSink {
+    readonly client: RoomClient;
+    private readonly names;
+    private readonly queues;
+    private readonly slotOf;
+    private readonly channelOf;
+    private readonly taps;
+    private readonly slots;
+    private readonly slotBytes;
+    private nextLatest;
+    private nextReliable;
+    readonly state: TickStateReplica;
+    constructor(client: Omit<RoomClientOptions, "channels">, options?: Pick<TickRoomOptions, "slots" | "slotBytes">);
+    get participant(): number;
+    open(channel: string, delivery: Delivery): number;
+    send(channel: number, bytes: Uint8Array, length: number): void;
+    receive(channel: number, reader: MessageReader): boolean;
+    channelSlot(channel: number): number;
+    tap(slot: number, sink: RawChannelSink | null): void;
+    deliver(slot: number, _sender: number, view: DataView, offset: number, length: number): void;
+    dropped(channel: number): number;
+    start(nowMs: number): void;
+    update(nowMs: number): void;
+    close(): void;
+}
+declare function joinTickRoom(room: TickRoomSource, options?: TickRoomOptions): TickRoomTransport;
+
+export { type RealtimeRoom as R, TickRoomTransport as T, type TickRoomOptions as a, type TickRoomSource as b, joinTickRoom as j };

package/dist/timeline-protocol-hp6e8zFB.d.mts

@@ -0,0 +1,47 @@
+declare const TIMELINE_PREFIX = "timeline.";
+/** Host to game: what desk asks of a playing preview, over the studio channel. */
+declare const TIMELINE_TOPIC: {
+    readonly record: "timeline.record";
+    readonly stop: "timeline.stop";
+    readonly seek: "timeline.seek";
+    readonly play: "timeline.play";
+    readonly moment: "timeline.moment";
+    readonly prove: "timeline.prove";
+};
+/** Game to host: what the preview reports back. */
+declare const TIMELINE_REPORT: {
+    readonly state: "timeline.state";
+    readonly moment: "timeline.moment_report";
+    readonly proof: "timeline.proof";
+    readonly refused: "timeline.refused";
+};
+interface TimelineState {
+    readonly recording: boolean;
+    readonly holding: boolean;
+    readonly tick: number;
+    readonly end: number;
+    readonly from: number;
+    readonly tickHz: number;
+}
+interface TimelineMoment {
+    readonly tick: number;
+    readonly digest: string;
+    readonly values: {
+        readonly [name: string]: string;
+    };
+}
+interface TimelineProof {
+    readonly exact: boolean;
+    readonly from: number;
+    readonly to: number;
+    readonly checked: number;
+    readonly firstDivergence: number | null;
+}
+interface TimelineRefused {
+    readonly action: string;
+    readonly message: string;
+}
+declare const CANNOT_REWIND = "This preview can't rewind.";
+declare const NOT_RECORDING = "Record a play first.";
+
+export { CANNOT_REWIND as C, NOT_RECORDING as N, TIMELINE_PREFIX as T, TIMELINE_REPORT as a, TIMELINE_TOPIC as b, type TimelineMoment as c, type TimelineProof as d, type TimelineRefused as e, type TimelineState as f };

package/dist/timeline-protocol-hp6e8zFB.d.ts

@@ -0,0 +1,47 @@
+declare const TIMELINE_PREFIX = "timeline.";
+/** Host to game: what desk asks of a playing preview, over the studio channel. */
+declare const TIMELINE_TOPIC: {
+    readonly record: "timeline.record";
+    readonly stop: "timeline.stop";
+    readonly seek: "timeline.seek";
+    readonly play: "timeline.play";
+    readonly moment: "timeline.moment";
+    readonly prove: "timeline.prove";
+};
+/** Game to host: what the preview reports back. */
+declare const TIMELINE_REPORT: {
+    readonly state: "timeline.state";
+    readonly moment: "timeline.moment_report";
+    readonly proof: "timeline.proof";
+    readonly refused: "timeline.refused";
+};
+interface TimelineState {
+    readonly recording: boolean;
+    readonly holding: boolean;
+    readonly tick: number;
+    readonly end: number;
+    readonly from: number;
+    readonly tickHz: number;
+}
+interface TimelineMoment {
+    readonly tick: number;
+    readonly digest: string;
+    readonly values: {
+        readonly [name: string]: string;
+    };
+}
+interface TimelineProof {
+    readonly exact: boolean;
+    readonly from: number;
+    readonly to: number;
+    readonly checked: number;
+    readonly firstDivergence: number | null;
+}
+interface TimelineRefused {
+    readonly action: string;
+    readonly message: string;
+}
+declare const CANNOT_REWIND = "This preview can't rewind.";
+declare const NOT_RECORDING = "Record a play first.";
+
+export { CANNOT_REWIND as C, NOT_RECORDING as N, TIMELINE_PREFIX as T, TIMELINE_REPORT as a, TIMELINE_TOPIC as b, type TimelineMoment as c, type TimelineProof as d, type TimelineRefused as e, type TimelineState as f };

package/dist/tokens-DhanQRQS.d.mts

@@ -0,0 +1,21 @@
+import { U as UiTheme, a as UiVarGroup, b as UiColor } from './vars-Dc_PrhBK.mjs';
+import { G as GameTheme } from './game-theme-CBTw1b_d.mjs';
+
+declare const TOKEN_NAMESPACE = "ui";
+declare const tokens: UiVarGroup<{
+    surface: UiColor;
+    raised: UiColor;
+    border: UiColor;
+    accent: UiColor;
+    onAccent: UiColor;
+    text: UiColor;
+    muted: UiColor;
+    track: UiColor;
+    danger: UiColor;
+    success: UiColor;
+    gold: UiColor;
+}>;
+type TokenName = keyof typeof tokens;
+declare function themeTokens(theme: GameTheme): UiTheme;
+
+export { TOKEN_NAMESPACE as T, type TokenName as a, tokens as b, themeTokens as t };

package/dist/tokens-K8yxwd6G.d.ts

@@ -0,0 +1,21 @@
+import { U as UiTheme, a as UiVarGroup, b as UiColor } from './vars-Dc_PrhBK.js';
+import { G as GameTheme } from './game-theme-Dg-ict5A.js';
+
+declare const TOKEN_NAMESPACE = "ui";
+declare const tokens: UiVarGroup<{
+    surface: UiColor;
+    raised: UiColor;
+    border: UiColor;
+    accent: UiColor;
+    onAccent: UiColor;
+    text: UiColor;
+    muted: UiColor;
+    track: UiColor;
+    danger: UiColor;
+    success: UiColor;
+    gold: UiColor;
+}>;
+type TokenName = keyof typeof tokens;
+declare function themeTokens(theme: GameTheme): UiTheme;
+
+export { TOKEN_NAMESPACE as T, type TokenName as a, tokens as b, themeTokens as t };

package/dist/tree-C-Io2Hbx.d.mts

@@ -0,0 +1,35 @@
+import { b as UiNode } from './local-D8_I6UeL.mjs';
+
+type TreePath = readonly number[];
+type TreePatch = {
+    readonly op: "root";
+    readonly node: UiNode | null;
+} | {
+    readonly op: "replace";
+    readonly at: TreePath;
+    readonly node: UiNode;
+} | {
+    readonly op: "props";
+    readonly at: TreePath;
+    readonly props: Record<string, unknown> | null;
+} | {
+    readonly op: "splice";
+    readonly at: TreePath;
+    readonly start: number;
+    readonly remove: number;
+    readonly insert: readonly UiNode[];
+};
+declare class TreeError extends Error {
+    constructor(message: string);
+}
+declare class TreeDiffer {
+    private shadow;
+    diff(next: UiNode | null): TreePatch[];
+}
+declare class TreeMirror {
+    private current;
+    get root(): UiNode | null;
+    apply(patches: readonly TreePatch[]): UiNode | null;
+}
+
+export { TreeDiffer as T, TreeError as a, TreeMirror as b, type TreePatch as c, type TreePath as d };

package/dist/tree-CP_qSW4H.d.ts

@@ -0,0 +1,35 @@
+import { b as UiNode } from './local-VZkqsCzR.js';
+
+type TreePath = readonly number[];
+type TreePatch = {
+    readonly op: "root";
+    readonly node: UiNode | null;
+} | {
+    readonly op: "replace";
+    readonly at: TreePath;
+    readonly node: UiNode;
+} | {
+    readonly op: "props";
+    readonly at: TreePath;
+    readonly props: Record<string, unknown> | null;
+} | {
+    readonly op: "splice";
+    readonly at: TreePath;
+    readonly start: number;
+    readonly remove: number;
+    readonly insert: readonly UiNode[];
+};
+declare class TreeError extends Error {
+    constructor(message: string);
+}
+declare class TreeDiffer {
+    private shadow;
+    diff(next: UiNode | null): TreePatch[];
+}
+declare class TreeMirror {
+    private current;
+    get root(): UiNode | null;
+    apply(patches: readonly TreePatch[]): UiNode | null;
+}
+
+export { TreeDiffer as T, TreeError as a, TreeMirror as b, type TreePatch as c, type TreePath as d };

package/dist/tycoon-B5KHk2Xx.d.mts

@@ -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-D8_I6UeL.mjs';
+import { L as LifecycleSource, K as KeySource } from './ports-B_0v_P3A.mjs';
+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-AhCdB1kW.mjs';
+import { G as Game } from './game-Bx8onkhX.mjs';
+import { G as GameScene } from './fluid-DLlEj2cs.mjs';
+
+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 };