@cimplify/sdk 0.108.0 → 0.110.2

package/dist/game/kit/slots.d.ts

@@ -0,0 +1,392 @@
+import { G as GameTheme } from '../../game-theme-Dg-ict5A.js';
+export { t as slotUiTheme } from '../../tokens-K8yxwd6G.js';
+export { U as UiTheme } from '../../vars-Dc_PrhBK.js';
+
+type SlotJson = null | boolean | number | string | readonly SlotJson[] | {
+    readonly [key: string]: SlotJson;
+};
+type SlotColor = string | readonly [number, number, number];
+type SlotRange = readonly [number, number];
+type Vec3Tuple = readonly [number, number, number];
+interface SceneAnchor {
+    readonly role: string;
+    readonly position: Vec3Tuple;
+    readonly size?: readonly [number, number];
+}
+interface SceneBounds {
+    readonly min: Vec3Tuple;
+    readonly max: Vec3Tuple;
+}
+interface SlotScene<K extends string = string> {
+    readonly id: string;
+    readonly kind: K;
+    readonly anchors: readonly SceneAnchor[];
+    readonly bounds?: SceneBounds;
+}
+interface SlotCharacter {
+    readonly id: string;
+    readonly rig: string;
+    readonly clips: readonly string[];
+    readonly model?: string;
+    readonly tint?: SlotColor;
+}
+interface SlotTrack {
+    readonly id: string;
+    readonly seconds: number;
+    readonly loop: boolean;
+    readonly bpm?: number;
+    readonly asset?: string;
+}
+type ThemeValue = {
+    readonly [K in keyof GameTheme]?: GameTheme[K];
+};
+interface AnchorRule {
+    readonly min: number;
+    readonly max: number;
+    readonly width?: SlotRange;
+    readonly height?: SlotRange;
+}
+interface SpanRule {
+    readonly from: string;
+    readonly to: string;
+    readonly distance: SlotRange;
+}
+type ParamField = {
+    readonly type: "int";
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly type: "number";
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly type: "boolean";
+} | {
+    readonly type: "choice";
+    readonly options: readonly string[];
+};
+type ParamFieldValue<F extends ParamField> = F extends {
+    readonly type: "boolean";
+} ? boolean : F extends {
+    readonly type: "choice";
+    readonly options: readonly (infer O)[];
+} ? O : number;
+type ParamFields = {
+    readonly [key: string]: ParamField;
+};
+type ParamValues<F extends ParamFields> = {
+    readonly [K in keyof F]: ParamFieldValue<F[K]>;
+};
+interface SlotBase<V> {
+    readonly __value?: V;
+}
+interface ThemeSlot extends SlotBase<GameTheme> {
+    readonly kind: "theme";
+    readonly textContrast: number;
+    readonly accentContrast: number;
+}
+interface PaletteSlot<K extends string = string> extends SlotBase<{
+    readonly [P in K]: SlotColor;
+}> {
+    readonly kind: "palette";
+    readonly keys: readonly K[];
+}
+interface CharacterSlot extends SlotBase<SlotCharacter> {
+    readonly kind: "character";
+    readonly rig: string;
+    readonly clips: readonly string[];
+}
+interface SceneSlotType<K extends string = string> extends SlotBase<SlotScene<K>> {
+    readonly kind: "scene";
+    readonly scene: K;
+    readonly anchors: {
+        readonly [role: string]: AnchorRule;
+    };
+    readonly spans: readonly SpanRule[];
+}
+interface TrackSlot extends SlotBase<SlotTrack> {
+    readonly kind: "track";
+    readonly seconds: SlotRange;
+    readonly loop: boolean;
+    readonly bpm?: SlotRange;
+}
+interface ParamsSlot<F extends ParamFields = ParamFields> extends SlotBase<ParamValues<F>> {
+    readonly kind: "params";
+    readonly fields: F;
+}
+type SlotType = ThemeSlot | PaletteSlot | CharacterSlot | SceneSlotType | TrackSlot | ParamsSlot;
+type SlotKind = SlotType["kind"];
+type SlotMap = {
+    readonly [name: string]: SlotType;
+};
+type SlotValue<T> = T extends SlotBase<infer V> ? V : never;
+type SlotInput<T> = T extends ThemeSlot ? ThemeValue : SlotValue<T>;
+type SlotValues<S extends SlotMap> = {
+    readonly [K in keyof S]: SlotValue<S[K]>;
+};
+type SlotInputs<S extends SlotMap> = {
+    readonly [K in keyof S]: SlotInput<S[K]>;
+};
+type SlotPresets<S extends SlotMap> = {
+    readonly [K in keyof S]?: {
+        readonly [name: string]: SlotInput<S[K]>;
+    };
+};
+interface SlotIssue {
+    readonly slot: string;
+    readonly path: string;
+    readonly reason: string;
+}
+declare class TemplateSlotError extends Error {
+    readonly issues: readonly SlotIssue[];
+    constructor(issues: readonly SlotIssue[]);
+}
+declare function describeIssue(issue: SlotIssue): string;
+
+declare const Theme: ThemeSlot;
+declare function Palette<const K extends string>(keys: readonly K[]): PaletteSlot<K>;
+interface CharacterRequirements {
+    readonly rig: string;
+    readonly clips: readonly string[];
+}
+declare function Character(requirements: CharacterRequirements): CharacterSlot;
+interface SceneRequirements {
+    readonly anchors: {
+        readonly [role: string]: AnchorRule;
+    };
+    readonly spans?: readonly SpanRule[];
+}
+declare function SceneSlot<const K extends string>(scene: K, requirements: SceneRequirements): SceneSlotType<K>;
+interface TrackRequirements {
+    readonly seconds: SlotRange;
+    readonly loop: boolean;
+    readonly bpm?: SlotRange;
+}
+declare function Track(requirements: TrackRequirements): TrackSlot;
+declare function Params<const F extends ParamFields>(fields: F): ParamsSlot<F>;
+declare function Int(min: number, max: number): {
+    readonly type: "int";
+    readonly min: number;
+    readonly max: number;
+};
+declare function Num(min: number, max: number): {
+    readonly type: "number";
+    readonly min: number;
+    readonly max: number;
+};
+declare function Bool(): {
+    readonly type: "boolean";
+};
+declare function Choice<const O extends string>(...options: O[]): {
+    readonly type: "choice";
+    readonly options: readonly O[];
+};
+declare function anchors(min: number, max?: number, size?: Pick<AnchorRule, "width" | "height">): AnchorRule;
+
+interface SlotCheck<V = unknown> {
+    readonly issues: readonly SlotIssue[];
+    readonly value: V | null;
+}
+type Rgb = readonly [number, number, number];
+declare function parseColor(value: unknown): Rgb | null;
+declare function colorInt(value: unknown): number;
+declare function contrastRatio(a: Rgb, b: Rgb): number;
+declare function checkSlot<T extends SlotType>(name: string, slot: T, value: unknown): SlotCheck;
+declare function describeSlot(slot: SlotType): string;
+
+declare const TEMPLATE_SCHEMA_FORMAT = "cimplify.template/1";
+interface TemplateDefinition<S extends SlotMap> {
+    readonly id: string;
+    readonly version: number;
+    readonly title: string;
+    readonly slots: S;
+    readonly defaults: SlotInputs<S>;
+    readonly presets?: SlotPresets<S>;
+}
+interface SlotTemplate<S extends SlotMap = SlotMap> {
+    readonly id: string;
+    readonly version: number;
+    readonly title: string;
+    readonly ref: string;
+    readonly slots: S;
+    readonly defaults: SlotInputs<S>;
+    readonly presets: SlotPresets<S>;
+    readonly values: SlotValues<S>;
+}
+interface TemplateSchema {
+    readonly format: typeof TEMPLATE_SCHEMA_FORMAT;
+    readonly id: string;
+    readonly version: number;
+    readonly title: string;
+    readonly slots: {
+        readonly [name: string]: SlotJson;
+    };
+    readonly defaults: {
+        readonly [name: string]: SlotJson;
+    };
+    readonly presets: {
+        readonly [name: string]: {
+            readonly [preset: string]: SlotJson;
+        };
+    };
+}
+declare function templateRef(id: string, version: number): string;
+declare function slotPresets(t: SlotTemplate, slot: string): {
+    readonly [name: string]: unknown;
+};
+declare function template<const S extends SlotMap>(definition: TemplateDefinition<S>): SlotTemplate<S>;
+declare function templateSchema(t: SlotTemplate): TemplateSchema;
+declare function templateFromSchema(schema: unknown): SlotTemplate;
+
+declare const shootoutSlots: SlotTemplate<{
+    readonly theme: ThemeSlot;
+    readonly music: TrackSlot;
+    readonly rules: ParamsSlot<{
+        readonly kicksPerSeries: {
+            readonly type: "int";
+            readonly min: number;
+            readonly max: number;
+        };
+        readonly seriesPauseSeconds: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+    }>;
+}>;
+declare const runnerSlots: SlotTemplate<{
+    readonly theme: ThemeSlot;
+    readonly hero: CharacterSlot;
+    readonly music: TrackSlot;
+    readonly rules: ParamsSlot<{
+        readonly startSpeed: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+        readonly maxSpeed: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+        readonly jumpVelocity: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+    }>;
+}>;
+declare const SLOT_TEMPLATES: {
+    readonly [id: string]: SlotTemplate;
+};
+
+declare const THEME_PRESETS: {
+    readonly [name: string]: ThemeValue;
+};
+
+interface ScenePlacement {
+    readonly group: string;
+    readonly kind: string;
+    readonly at: Vec3Tuple;
+}
+interface ScenePlacementReport {
+    readonly version: number;
+    readonly scene: string;
+    readonly status: string;
+    readonly placements: readonly ScenePlacement[];
+}
+interface SceneCatalogueKind {
+    readonly footprint: readonly [number, number];
+    readonly height: number;
+}
+interface SlotSceneOptions {
+    readonly area?: readonly [number, number];
+    readonly points?: {
+        readonly [name: string]: readonly [number, number];
+    };
+    readonly roles?: {
+        readonly [groupOrPoint: string]: string;
+    };
+    readonly catalogue?: {
+        readonly [kind: string]: SceneCatalogueKind;
+    };
+}
+declare class SceneReportError extends Error {
+    constructor(message: string);
+}
+declare function slotSceneFromReport<const K extends string>(kind: K, report: ScenePlacementReport, options?: SlotSceneOptions): SlotScene<K>;
+
+declare const REMIX_FORMAT = 1;
+declare const DIGEST_PREFIX = "sha256:";
+declare const INLINE_VALUE_BYTES = 256;
+declare const MAX_REMIX_DEPTH = 64;
+type SlotRef = string | {
+    readonly value: SlotJson;
+} | {
+    readonly content: string;
+};
+interface RemixManifest {
+    readonly remix: typeof REMIX_FORMAT;
+    readonly template: string;
+    readonly parent: string | null;
+    readonly slots: {
+        readonly [slot: string]: SlotRef;
+    };
+}
+interface RemixSources {
+    manifest?(digest: string): RemixManifest | undefined;
+    content?(digest: string): unknown;
+}
+interface Remix {
+    readonly manifest: RemixManifest;
+    readonly digest: string;
+    readonly content: {
+        readonly [digest: string]: SlotJson;
+    };
+}
+interface RemixLineage {
+    readonly template: string;
+    readonly digest: string;
+    readonly ancestors: readonly string[];
+}
+declare class RemixError extends Error {
+    constructor(message: string);
+}
+declare class ContentRef {
+    readonly digest: string;
+    constructor(digest: string);
+}
+declare function slotContent(digest: string): ContentRef;
+declare function canonicalSlotJson(value: unknown): string;
+declare function slotDigest(value: unknown): string;
+declare function encodeRemix(manifest: RemixManifest): string;
+declare function remixDigest(manifest: RemixManifest): string;
+declare function decodeRemix(input: string | unknown): RemixManifest;
+declare function remixLineage(manifest: RemixManifest, sources?: RemixSources): RemixLineage;
+declare function resolveRemix<S extends SlotMap>(t: SlotTemplate<S>, manifest: RemixManifest, sources?: RemixSources): SlotValues<S>;
+type RemixSet<S extends SlotMap> = {
+    readonly [K in keyof S]?: string | ContentRef | SlotInput<S[K]>;
+};
+interface RemixOptions {
+    readonly parent?: RemixManifest | null;
+    readonly sources?: RemixSources;
+}
+declare function remix<S extends SlotMap>(t: SlotTemplate<S>, set: RemixSet<S>, options?: RemixOptions): Remix;
+declare function memoryRemixSources(remixes?: readonly Remix[]): RemixSources & {
+    add(remix: Remix): void;
+};
+
+declare const TEMPLATE_SLOTS_FLAG = "CIMPLIFY_TEMPLATE_SLOTS";
+declare function templateSlotsEnabled(env: {
+    readonly [name: string]: string | undefined;
+}): boolean;
+interface AssignOptions {
+    readonly base?: {
+        readonly [slot: string]: unknown;
+    };
+    readFile?(path: string): string;
+}
+declare function slotChoices(t: SlotTemplate, slot: string): string;
+declare function assignSlots(t: SlotTemplate, pairs: readonly string[], options?: AssignOptions): RemixSet<SlotMap>;
+
+export { type AnchorRule, type AssignOptions, Bool, Character, type CharacterRequirements, type CharacterSlot, Choice, ContentRef, DIGEST_PREFIX, GameTheme, INLINE_VALUE_BYTES, Int, MAX_REMIX_DEPTH, Num, Palette, type PaletteSlot, type ParamField, type ParamFieldValue, type ParamFields, type ParamValues, Params, type ParamsSlot, REMIX_FORMAT, type Remix, RemixError, type RemixLineage, type RemixManifest, type RemixOptions, type RemixSet, type RemixSources, SLOT_TEMPLATES, type SceneAnchor, type SceneBounds, type SceneCatalogueKind, type ScenePlacement, type ScenePlacementReport, SceneReportError, type SceneRequirements, SceneSlot, type SceneSlotType, type SlotCharacter, type SlotCheck, type SlotColor, type SlotInput, type SlotInputs, type SlotIssue, type SlotJson, type SlotKind, type SlotMap, type SlotPresets, type SlotRange, type SlotRef, type SlotScene, type SlotSceneOptions, type SlotTemplate, type SlotTrack, type SlotType, type SlotValue, type SlotValues, type SpanRule, TEMPLATE_SCHEMA_FORMAT, TEMPLATE_SLOTS_FLAG, THEME_PRESETS, type TemplateDefinition, type TemplateSchema, TemplateSlotError, Theme, type ThemeSlot, type ThemeValue, Track, type TrackRequirements, type TrackSlot, type Vec3Tuple, anchors, assignSlots, canonicalSlotJson, checkSlot, colorInt, contrastRatio, decodeRemix, describeIssue, describeSlot, encodeRemix, memoryRemixSources, parseColor, remix, remixDigest, remixLineage, resolveRemix, runnerSlots, shootoutSlots, slotChoices, slotContent, slotDigest, slotPresets, slotSceneFromReport, template, templateFromSchema, templateRef, templateSchema, templateSlotsEnabled };

package/dist/game/kit/slots.js

@@ -0,0 +1,215 @@
+'use strict';
+
+var chunk6VVXXX7S_js = require('../../chunk-6VVXXX7S.js');
+var chunk5SXDH3Y7_js = require('../../chunk-5SXDH3Y7.js');
+require('../../chunk-VRBDAS5I.js');
+require('../../chunk-TJI3K6RP.js');
+require('../../chunk-MEXP6DA6.js');
+require('../../chunk-JGBCIKJV.js');
+
+
+
+Object.defineProperty(exports, "Bool", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Bool; }
+});
+Object.defineProperty(exports, "Character", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Character; }
+});
+Object.defineProperty(exports, "Choice", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Choice; }
+});
+Object.defineProperty(exports, "ContentRef", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.ContentRef; }
+});
+Object.defineProperty(exports, "DIGEST_PREFIX", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.DIGEST_PREFIX; }
+});
+Object.defineProperty(exports, "INLINE_VALUE_BYTES", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.INLINE_VALUE_BYTES; }
+});
+Object.defineProperty(exports, "Int", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Int; }
+});
+Object.defineProperty(exports, "MAX_REMIX_DEPTH", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.MAX_REMIX_DEPTH; }
+});
+Object.defineProperty(exports, "Num", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Num; }
+});
+Object.defineProperty(exports, "Palette", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Palette; }
+});
+Object.defineProperty(exports, "Params", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Params; }
+});
+Object.defineProperty(exports, "REMIX_FORMAT", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.REMIX_FORMAT; }
+});
+Object.defineProperty(exports, "RemixError", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.RemixError; }
+});
+Object.defineProperty(exports, "SLOT_TEMPLATES", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.SLOT_TEMPLATES; }
+});
+Object.defineProperty(exports, "SceneReportError", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.SceneReportError; }
+});
+Object.defineProperty(exports, "SceneSlot", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.SceneSlot; }
+});
+Object.defineProperty(exports, "TEMPLATE_SCHEMA_FORMAT", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.TEMPLATE_SCHEMA_FORMAT; }
+});
+Object.defineProperty(exports, "TEMPLATE_SLOTS_FLAG", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.TEMPLATE_SLOTS_FLAG; }
+});
+Object.defineProperty(exports, "THEME_PRESETS", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.THEME_PRESETS; }
+});
+Object.defineProperty(exports, "TemplateSlotError", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.TemplateSlotError; }
+});
+Object.defineProperty(exports, "Theme", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Theme; }
+});
+Object.defineProperty(exports, "Track", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.Track; }
+});
+Object.defineProperty(exports, "anchors", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.anchors; }
+});
+Object.defineProperty(exports, "assignSlots", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.assignSlots; }
+});
+Object.defineProperty(exports, "canonicalSlotJson", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.canonicalSlotJson; }
+});
+Object.defineProperty(exports, "checkSlot", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.checkSlot; }
+});
+Object.defineProperty(exports, "colorInt", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.colorInt; }
+});
+Object.defineProperty(exports, "contrastRatio", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.contrastRatio; }
+});
+Object.defineProperty(exports, "decodeRemix", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.decodeRemix; }
+});
+Object.defineProperty(exports, "describeIssue", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.describeIssue; }
+});
+Object.defineProperty(exports, "describeSlot", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.describeSlot; }
+});
+Object.defineProperty(exports, "encodeRemix", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.encodeRemix; }
+});
+Object.defineProperty(exports, "memoryRemixSources", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.memoryRemixSources; }
+});
+Object.defineProperty(exports, "parseColor", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.parseColor; }
+});
+Object.defineProperty(exports, "remix", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.remix; }
+});
+Object.defineProperty(exports, "remixDigest", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.remixDigest; }
+});
+Object.defineProperty(exports, "remixLineage", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.remixLineage; }
+});
+Object.defineProperty(exports, "resolveRemix", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.resolveRemix; }
+});
+Object.defineProperty(exports, "runnerSlots", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.runnerSlots; }
+});
+Object.defineProperty(exports, "shootoutSlots", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.shootoutSlots; }
+});
+Object.defineProperty(exports, "slotChoices", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.slotChoices; }
+});
+Object.defineProperty(exports, "slotContent", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.slotContent; }
+});
+Object.defineProperty(exports, "slotDigest", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.slotDigest; }
+});
+Object.defineProperty(exports, "slotPresets", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.slotPresets; }
+});
+Object.defineProperty(exports, "slotSceneFromReport", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.slotSceneFromReport; }
+});
+Object.defineProperty(exports, "template", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.template; }
+});
+Object.defineProperty(exports, "templateFromSchema", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.templateFromSchema; }
+});
+Object.defineProperty(exports, "templateRef", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.templateRef; }
+});
+Object.defineProperty(exports, "templateSchema", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.templateSchema; }
+});
+Object.defineProperty(exports, "templateSlotsEnabled", {
+  enumerable: true,
+  get: function () { return chunk6VVXXX7S_js.templateSlotsEnabled; }
+});
+Object.defineProperty(exports, "slotUiTheme", {
+  enumerable: true,
+  get: function () { return chunk5SXDH3Y7_js.themeTokens; }
+});

package/dist/game/kit/slots.mjs

@@ -0,0 +1,6 @@
+export { Bool, Character, Choice, ContentRef, DIGEST_PREFIX, INLINE_VALUE_BYTES, Int, MAX_REMIX_DEPTH, Num, Palette, Params, REMIX_FORMAT, RemixError, SLOT_TEMPLATES, SceneReportError, SceneSlot, TEMPLATE_SCHEMA_FORMAT, TEMPLATE_SLOTS_FLAG, THEME_PRESETS, TemplateSlotError, Theme, Track, anchors, assignSlots, canonicalSlotJson, checkSlot, colorInt, contrastRatio, decodeRemix, describeIssue, describeSlot, encodeRemix, memoryRemixSources, parseColor, remix, remixDigest, remixLineage, resolveRemix, runnerSlots, shootoutSlots, slotChoices, slotContent, slotDigest, slotPresets, slotSceneFromReport, template, templateFromSchema, templateRef, templateSchema, templateSlotsEnabled } from '../../chunk-NMQT4HG3.mjs';
+export { themeTokens as slotUiTheme } from '../../chunk-WLMINRC4.mjs';
+import '../../chunk-RFVRPYR2.mjs';
+import '../../chunk-5YWN6H5Q.mjs';
+import '../../chunk-JKGTBMU7.mjs';
+import '../../chunk-25T4JHEA.mjs';

package/dist/game/kit/tycoon.d.mts

@@ -0,0 +1,16 @@
+export { B as BANK_BUY, n as BANK_COINS, p as BANK_COLLECT, J as JollofTycoon, q as LedgerTycoonBank, r as LocalTycoonBank, s as STALLS, v as STALL_NAMES, w as TYCOON_CHALLENGES, x as TycoonBank, y as TycoonBankFactory, z as TycoonChallenge, F as TycoonSave, G as buyChefHat, H as buyStall, I as chefHat, K as coinPack, N as coins, O as festivalBanner, P as gemPouch, Q as gems, R as goldenPot, U as jollofTycoonTemplate, V as spiceCrate, W as spiceCrateForGems, X as stallEarnings, Y as tycoonEconomy, Z as tycoonSaveSchema } from '../../tycoon-B5KHk2Xx.mjs';
+import '../../local-D8_I6UeL.mjs';
+import '../../link-BUTqGmyi.mjs';
+import '../../schema-BrWxzKp6.mjs';
+import '../../ui-DwHicuFv.mjs';
+import '../../vars-Dc_PrhBK.mjs';
+import '../../network-ZXLD7l1b.mjs';
+import '../../ports-B_0v_P3A.mjs';
+import '../../template-AhCdB1kW.mjs';
+import '../../backend-gUCzs5Kg.mjs';
+import '../../game-Bx8onkhX.mjs';
+import '../../world-qekkXjJv.mjs';
+import '../../library-DXYaMFhi.mjs';
+import '../../audio-DhvyjqdA.mjs';
+import '../../client-hTKbCuhG.mjs';
+import '../../fluid-DLlEj2cs.mjs';

package/dist/game/kit/tycoon.d.ts

@@ -0,0 +1,16 @@
+export { B as BANK_BUY, n as BANK_COINS, p as BANK_COLLECT, J as JollofTycoon, q as LedgerTycoonBank, r as LocalTycoonBank, s as STALLS, v as STALL_NAMES, w as TYCOON_CHALLENGES, x as TycoonBank, y as TycoonBankFactory, z as TycoonChallenge, F as TycoonSave, G as buyChefHat, H as buyStall, I as chefHat, K as coinPack, N as coins, O as festivalBanner, P as gemPouch, Q as gems, R as goldenPot, U as jollofTycoonTemplate, V as spiceCrate, W as spiceCrateForGems, X as stallEarnings, Y as tycoonEconomy, Z as tycoonSaveSchema } from '../../tycoon-hmHo-3HX.js';
+import '../../local-VZkqsCzR.js';
+import '../../link-BUTqGmyi.js';
+import '../../schema-BrWxzKp6.js';
+import '../../ui-hi7S2YcH.js';
+import '../../vars-Dc_PrhBK.js';
+import '../../network-ZXLD7l1b.js';
+import '../../ports-CGU_3e_0.js';
+import '../../template-BkEGVTQj.js';
+import '../../backend-gUCzs5Kg.js';
+import '../../game-fgQy2YIm.js';
+import '../../world-PvILHDR1.js';
+import '../../library-DXYaMFhi.js';
+import '../../audio-m0w8cnxq.js';
+import '../../client-Dytx_ZTC.js';
+import '../../fluid-ARr0qUIL.js';