@cimplify/sdk 0.108.0 → 0.110.2

package/dist/web-transport-C7MkBL0a.d.ts

@@ -0,0 +1,19 @@
+import { R as RoomDialer, B as Bytes, L as LinkHandler, D as Dialed } from './link-BUTqGmyi.js';
+
+declare class WebSocketDialer implements RoomDialer {
+    readonly transport: "web_socket";
+    private readonly url;
+    constructor(url: string);
+    dial(request: Bytes, handler: LinkHandler): Promise<Dialed | null>;
+}
+
+declare class WebTransportDialer implements RoomDialer {
+    readonly transport: "web_transport";
+    private readonly url;
+    private readonly options;
+    constructor(url: string, options?: WebTransportOptions);
+    static available(): boolean;
+    dial(request: Bytes, handler: LinkHandler): Promise<Dialed | null>;
+}
+
+export { WebSocketDialer as W, WebTransportDialer as a };

package/dist/web-transport-aYEqXMd9.d.mts

@@ -0,0 +1,19 @@
+import { R as RoomDialer, B as Bytes, L as LinkHandler, D as Dialed } from './link-BUTqGmyi.mjs';
+
+declare class WebSocketDialer implements RoomDialer {
+    readonly transport: "web_socket";
+    private readonly url;
+    constructor(url: string);
+    dial(request: Bytes, handler: LinkHandler): Promise<Dialed | null>;
+}
+
+declare class WebTransportDialer implements RoomDialer {
+    readonly transport: "web_transport";
+    private readonly url;
+    private readonly options;
+    constructor(url: string, options?: WebTransportOptions);
+    static available(): boolean;
+    dial(request: Bytes, handler: LinkHandler): Promise<Dialed | null>;
+}
+
+export { WebSocketDialer as W, WebTransportDialer as a };

package/dist/weight-CPGjsgjV.d.ts

@@ -0,0 +1,92 @@
+import { F as FluidMaterial } from './fluid-ARr0qUIL.js';
+import { D as DeviceTier } from './backend-gUCzs5Kg.js';
+import { I as WorldLayer, d as CrowdCaps, H as WorldDoc } from './types-D_f6UUxM.js';
+
+type ThingBreak = "never" | "dents" | "shatters" | "splinters" | "tears";
+interface ThingLook {
+    readonly color: number;
+    readonly roughness: number;
+    readonly metalness: number;
+    readonly opacity: number;
+}
+interface ThingMaterial {
+    readonly id: string;
+    readonly label: string;
+    readonly density: number;
+    readonly friction: number;
+    readonly restitution: number;
+    readonly look: ThingLook;
+    readonly species: string | null;
+    readonly fluid: FluidMaterial | null;
+    readonly burns: boolean;
+    readonly conductsHeat: boolean;
+    readonly breaks: ThingBreak;
+}
+declare const THING_MATERIALS: readonly ThingMaterial[];
+declare const DEFAULT_THING_MATERIAL = "plastic";
+declare function thingMaterial(id: string): ThingMaterial;
+declare function thingMaterialIds(): string[];
+declare function thingBreaks(materialIds: readonly string[]): ThingBreak;
+
+declare const LAYER_COST: {
+    readonly [L in WorldLayer]: number;
+};
+declare const GROUND_AREA_UNIT = 1000;
+declare const TIER_BUDGET: {
+    readonly [T in DeviceTier]: number;
+};
+declare const LIGHT_SHARE = 0.6;
+declare const FIT_HEADROOM = 0.95;
+type TierVerdict = "light" | "fine" | "heavy";
+interface LayerWeight {
+    readonly layer: WorldLayer;
+    readonly count: number;
+    readonly cost: number;
+    readonly share: number;
+}
+interface WorldWeight {
+    readonly total: number;
+    readonly layers: readonly LayerWeight[];
+    readonly tiers: {
+        readonly [T in DeviceTier]: TierVerdict;
+    };
+    readonly tierTotals: {
+        readonly [T in DeviceTier]: number;
+    };
+    readonly tierPeople: {
+        readonly [T in DeviceTier]: number;
+    };
+}
+interface Lightening {
+    readonly tier: DeviceTier;
+    readonly layer: WorldLayer;
+    readonly from: number;
+    readonly to: number;
+}
+declare function layerCounts(doc: WorldDoc, scattered: {
+    readonly props: number;
+    readonly crowds: number;
+}): {
+    readonly [L in WorldLayer]: number;
+};
+declare function verdict(total: number, tier: DeviceTier): TierVerdict;
+declare function peopleOn(people: number, caps: CrowdCaps, tier: DeviceTier): number;
+declare function worldWeight(counts: {
+    readonly [L in WorldLayer]: number;
+}, caps?: CrowdCaps): WorldWeight;
+declare function lighten(weight: WorldWeight, tier: DeviceTier, layer?: WorldLayer): Lightening | null;
+interface HeavyWithoutPeople {
+    readonly tier: DeviceTier;
+    readonly withoutPeople: number;
+    readonly budget: number;
+    readonly layers: readonly LayerWeight[];
+}
+interface FewerPeople {
+    readonly caps: CrowdCaps;
+    readonly fixes: readonly Lightening[];
+    readonly stillHeavy: readonly HeavyWithoutPeople[];
+}
+declare function heavyWithoutPeople(weight: WorldWeight, tier: DeviceTier): HeavyWithoutPeople | null;
+declare function fewerPeople(weight: WorldWeight, caps?: CrowdCaps): FewerPeople | null;
+
+export { DEFAULT_THING_MATERIAL as D, FIT_HEADROOM as F, GROUND_AREA_UNIT as G, type HeavyWithoutPeople as H, LAYER_COST as L, THING_MATERIALS as T, type WorldWeight as W, type FewerPeople as a, LIGHT_SHARE as b, type LayerWeight as c, type Lightening as d, TIER_BUDGET as e, type ThingBreak as f, type ThingLook as g, type ThingMaterial as h, type TierVerdict as i, fewerPeople as j, heavyWithoutPeople as k, layerCounts as l, lighten as m, thingMaterial as n, thingMaterialIds as o, peopleOn as p, thingBreaks as t, verdict as v, worldWeight as w };

package/dist/weight-tF1ODR1p.d.mts

@@ -0,0 +1,92 @@
+import { F as FluidMaterial } from './fluid-DLlEj2cs.mjs';
+import { D as DeviceTier } from './backend-gUCzs5Kg.mjs';
+import { I as WorldLayer, d as CrowdCaps, H as WorldDoc } from './types-BQkxPwZP.mjs';
+
+type ThingBreak = "never" | "dents" | "shatters" | "splinters" | "tears";
+interface ThingLook {
+    readonly color: number;
+    readonly roughness: number;
+    readonly metalness: number;
+    readonly opacity: number;
+}
+interface ThingMaterial {
+    readonly id: string;
+    readonly label: string;
+    readonly density: number;
+    readonly friction: number;
+    readonly restitution: number;
+    readonly look: ThingLook;
+    readonly species: string | null;
+    readonly fluid: FluidMaterial | null;
+    readonly burns: boolean;
+    readonly conductsHeat: boolean;
+    readonly breaks: ThingBreak;
+}
+declare const THING_MATERIALS: readonly ThingMaterial[];
+declare const DEFAULT_THING_MATERIAL = "plastic";
+declare function thingMaterial(id: string): ThingMaterial;
+declare function thingMaterialIds(): string[];
+declare function thingBreaks(materialIds: readonly string[]): ThingBreak;
+
+declare const LAYER_COST: {
+    readonly [L in WorldLayer]: number;
+};
+declare const GROUND_AREA_UNIT = 1000;
+declare const TIER_BUDGET: {
+    readonly [T in DeviceTier]: number;
+};
+declare const LIGHT_SHARE = 0.6;
+declare const FIT_HEADROOM = 0.95;
+type TierVerdict = "light" | "fine" | "heavy";
+interface LayerWeight {
+    readonly layer: WorldLayer;
+    readonly count: number;
+    readonly cost: number;
+    readonly share: number;
+}
+interface WorldWeight {
+    readonly total: number;
+    readonly layers: readonly LayerWeight[];
+    readonly tiers: {
+        readonly [T in DeviceTier]: TierVerdict;
+    };
+    readonly tierTotals: {
+        readonly [T in DeviceTier]: number;
+    };
+    readonly tierPeople: {
+        readonly [T in DeviceTier]: number;
+    };
+}
+interface Lightening {
+    readonly tier: DeviceTier;
+    readonly layer: WorldLayer;
+    readonly from: number;
+    readonly to: number;
+}
+declare function layerCounts(doc: WorldDoc, scattered: {
+    readonly props: number;
+    readonly crowds: number;
+}): {
+    readonly [L in WorldLayer]: number;
+};
+declare function verdict(total: number, tier: DeviceTier): TierVerdict;
+declare function peopleOn(people: number, caps: CrowdCaps, tier: DeviceTier): number;
+declare function worldWeight(counts: {
+    readonly [L in WorldLayer]: number;
+}, caps?: CrowdCaps): WorldWeight;
+declare function lighten(weight: WorldWeight, tier: DeviceTier, layer?: WorldLayer): Lightening | null;
+interface HeavyWithoutPeople {
+    readonly tier: DeviceTier;
+    readonly withoutPeople: number;
+    readonly budget: number;
+    readonly layers: readonly LayerWeight[];
+}
+interface FewerPeople {
+    readonly caps: CrowdCaps;
+    readonly fixes: readonly Lightening[];
+    readonly stillHeavy: readonly HeavyWithoutPeople[];
+}
+declare function heavyWithoutPeople(weight: WorldWeight, tier: DeviceTier): HeavyWithoutPeople | null;
+declare function fewerPeople(weight: WorldWeight, caps?: CrowdCaps): FewerPeople | null;
+
+export { DEFAULT_THING_MATERIAL as D, FIT_HEADROOM as F, GROUND_AREA_UNIT as G, type HeavyWithoutPeople as H, LAYER_COST as L, THING_MATERIALS as T, type WorldWeight as W, type FewerPeople as a, LIGHT_SHARE as b, type LayerWeight as c, type Lightening as d, TIER_BUDGET as e, type ThingBreak as f, type ThingLook as g, type ThingMaterial as h, type TierVerdict as i, fewerPeople as j, heavyWithoutPeople as k, layerCounts as l, lighten as m, thingMaterial as n, thingMaterialIds as o, peopleOn as p, thingBreaks as t, verdict as v, worldWeight as w };

package/dist/word-BcX9Jcmv.d.mts

@@ -0,0 +1,70 @@
+import { G as Game } from './game-Bx8onkhX.mjs';
+import { G as GameScene } from './fluid-DLlEj2cs.mjs';
+import { h as GenreTemplate } from './template-AhCdB1kW.mjs';
+
+declare const WORD: {
+    readonly length: 5;
+    readonly attempts: 6;
+    readonly alphabet: 26;
+    readonly nextRoundSeconds: 2;
+};
+declare const Mark: {
+    readonly None: 0;
+    readonly Absent: 1;
+    readonly Present: 2;
+    readonly Correct: 3;
+};
+type WordStatus = "playing" | "won" | "lost";
+declare const WORD_LIST: Uint8Array<ArrayBufferLike>;
+declare const WORD_COUNT: number;
+declare function evaluate(guess: Uint8Array, guessOffset: number, answer: Uint8Array, answerOffset: number, out: Uint8Array, outOffset: number): boolean;
+interface WordResultSink {
+    roundEnded(won: boolean, guesses: number): void;
+}
+declare class WordPuzzle implements GameScene<Game> {
+    readonly name = "word-puzzle";
+    readonly grid: Uint8Array<ArrayBuffer>;
+    readonly marks: Uint8Array<ArrayBuffer>;
+    readonly keyboard: Uint8Array<ArrayBuffer>;
+    readonly answer: Uint8Array<ArrayBuffer>;
+    status: WordStatus;
+    row: number;
+    col: number;
+    rounds: number;
+    wins: number;
+    private readonly results;
+    private readonly fixedAnswer;
+    private readonly actions;
+    private readonly slots;
+    private roundSlot;
+    private tiles;
+    private waitSeconds;
+    constructor(results?: WordResultSink | null, answerIndex?: number);
+    enter(game: Game): void;
+    fixedUpdate(game: Game): void;
+    update(): void;
+    type(game: Game, letter: number): void;
+    erase(game: Game): void;
+    submit(game: Game): void;
+    private finish;
+    private newRound;
+}
+declare function consistent(scene: WordPuzzle, candidate: number): boolean;
+declare const wordPuzzleTemplate: GenreTemplate<WordPuzzle>;
+
+declare const word_Mark: typeof Mark;
+declare const word_WORD: typeof WORD;
+declare const word_WORD_COUNT: typeof WORD_COUNT;
+declare const word_WORD_LIST: typeof WORD_LIST;
+type word_WordPuzzle = WordPuzzle;
+declare const word_WordPuzzle: typeof WordPuzzle;
+type word_WordResultSink = WordResultSink;
+type word_WordStatus = WordStatus;
+declare const word_consistent: typeof consistent;
+declare const word_evaluate: typeof evaluate;
+declare const word_wordPuzzleTemplate: typeof wordPuzzleTemplate;
+declare namespace word {
+  export { word_Mark as Mark, word_WORD as WORD, word_WORD_COUNT as WORD_COUNT, word_WORD_LIST as WORD_LIST, word_WordPuzzle as WordPuzzle, type word_WordResultSink as WordResultSink, type word_WordStatus as WordStatus, word_consistent as consistent, word_evaluate as evaluate, word_wordPuzzleTemplate as wordPuzzleTemplate };
+}
+
+export { Mark as M, WORD as W, WORD_COUNT as a, WORD_LIST as b, WordPuzzle as c, type WordResultSink as d, type WordStatus as e, consistent as f, evaluate as g, wordPuzzleTemplate as h, word as w };

package/dist/word-C7sVPLHm.d.ts

@@ -0,0 +1,70 @@
+import { G as Game } from './game-fgQy2YIm.js';
+import { G as GameScene } from './fluid-ARr0qUIL.js';
+import { h as GenreTemplate } from './template-BkEGVTQj.js';
+
+declare const WORD: {
+    readonly length: 5;
+    readonly attempts: 6;
+    readonly alphabet: 26;
+    readonly nextRoundSeconds: 2;
+};
+declare const Mark: {
+    readonly None: 0;
+    readonly Absent: 1;
+    readonly Present: 2;
+    readonly Correct: 3;
+};
+type WordStatus = "playing" | "won" | "lost";
+declare const WORD_LIST: Uint8Array<ArrayBufferLike>;
+declare const WORD_COUNT: number;
+declare function evaluate(guess: Uint8Array, guessOffset: number, answer: Uint8Array, answerOffset: number, out: Uint8Array, outOffset: number): boolean;
+interface WordResultSink {
+    roundEnded(won: boolean, guesses: number): void;
+}
+declare class WordPuzzle implements GameScene<Game> {
+    readonly name = "word-puzzle";
+    readonly grid: Uint8Array<ArrayBuffer>;
+    readonly marks: Uint8Array<ArrayBuffer>;
+    readonly keyboard: Uint8Array<ArrayBuffer>;
+    readonly answer: Uint8Array<ArrayBuffer>;
+    status: WordStatus;
+    row: number;
+    col: number;
+    rounds: number;
+    wins: number;
+    private readonly results;
+    private readonly fixedAnswer;
+    private readonly actions;
+    private readonly slots;
+    private roundSlot;
+    private tiles;
+    private waitSeconds;
+    constructor(results?: WordResultSink | null, answerIndex?: number);
+    enter(game: Game): void;
+    fixedUpdate(game: Game): void;
+    update(): void;
+    type(game: Game, letter: number): void;
+    erase(game: Game): void;
+    submit(game: Game): void;
+    private finish;
+    private newRound;
+}
+declare function consistent(scene: WordPuzzle, candidate: number): boolean;
+declare const wordPuzzleTemplate: GenreTemplate<WordPuzzle>;
+
+declare const word_Mark: typeof Mark;
+declare const word_WORD: typeof WORD;
+declare const word_WORD_COUNT: typeof WORD_COUNT;
+declare const word_WORD_LIST: typeof WORD_LIST;
+type word_WordPuzzle = WordPuzzle;
+declare const word_WordPuzzle: typeof WordPuzzle;
+type word_WordResultSink = WordResultSink;
+type word_WordStatus = WordStatus;
+declare const word_consistent: typeof consistent;
+declare const word_evaluate: typeof evaluate;
+declare const word_wordPuzzleTemplate: typeof wordPuzzleTemplate;
+declare namespace word {
+  export { word_Mark as Mark, word_WORD as WORD, word_WORD_COUNT as WORD_COUNT, word_WORD_LIST as WORD_LIST, word_WordPuzzle as WordPuzzle, type word_WordResultSink as WordResultSink, type word_WordStatus as WordStatus, word_consistent as consistent, word_evaluate as evaluate, word_wordPuzzleTemplate as wordPuzzleTemplate };
+}
+
+export { Mark as M, WORD as W, WORD_COUNT as a, WORD_LIST as b, WordPuzzle as c, type WordResultSink as d, type WordStatus as e, consistent as f, evaluate as g, wordPuzzleTemplate as h, word as w };