@battle-racing/br-common-lib 6.2.0-rc.9 → 6.2.0

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm whoami *)",
+      "Bash(npm config *)"
+    ]
+  }
+}

package/dist/domains/arcade/Arcade.const.d.ts

@@ -0,0 +1,9 @@
+export declare const ARCADE_SESSION_STATUS: {
+    readonly ACTIVE: "ACTIVE";
+    readonly FINISHED: "FINISHED";
+    readonly ABANDONED: "ABANDONED";
+};
+export declare const ARCADE_SESSION_ORIGIN: {
+    readonly QR: "QR";
+    readonly ANONYMOUS: "ANONYMOUS";
+};

package/dist/domains/arcade/Arcade.const.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARCADE_SESSION_ORIGIN = exports.ARCADE_SESSION_STATUS = void 0;
+exports.ARCADE_SESSION_STATUS = {
+    ACTIVE: 'ACTIVE',
+    FINISHED: 'FINISHED',
+    ABANDONED: 'ABANDONED',
+};
+exports.ARCADE_SESSION_ORIGIN = {
+    QR: 'QR',
+    ANONYMOUS: 'ANONYMOUS',
+};

package/dist/domains/arcade/Arcade.schema.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+export declare const arcadeSessionStatusSchema: z.ZodEnum<{
+    readonly ACTIVE: "ACTIVE";
+    readonly FINISHED: "FINISHED";
+    readonly ABANDONED: "ABANDONED";
+}>;
+export declare const arcadeSessionOriginSchema: z.ZodEnum<{
+    readonly QR: "QR";
+    readonly ANONYMOUS: "ANONYMOUS";
+}>;
+/** Readable id printed in the machine QR, e.g. "marble-table-01" */
+export declare const arcadeMachineIdSchema: z.ZodString;
+export declare const arcadeMachineSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    maxCoinsDelta: z.ZodNumber;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const createArcadeMachineInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    maxCoinsDelta: z.ZodNumber;
+}, z.core.$strip>;
+export declare const qrArcadeSessionSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    machineId: z.ZodString;
+    status: z.ZodEnum<{
+        readonly ACTIVE: "ACTIVE";
+        readonly FINISHED: "FINISHED";
+        readonly ABANDONED: "ABANDONED";
+    }>;
+    coinsDelta: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodDate;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    origin: z.ZodLiteral<"QR">;
+    userId: z.ZodUUID;
+    startingBalance: z.ZodNumber;
+}, z.core.$strip>;
+export declare const anonymousArcadeSessionSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    machineId: z.ZodString;
+    status: z.ZodEnum<{
+        readonly ACTIVE: "ACTIVE";
+        readonly FINISHED: "FINISHED";
+        readonly ABANDONED: "ABANDONED";
+    }>;
+    coinsDelta: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodDate;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    origin: z.ZodLiteral<"ANONYMOUS">;
+}, z.core.$strip>;
+export declare const arcadeSessionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodUUID;
+    machineId: z.ZodString;
+    status: z.ZodEnum<{
+        readonly ACTIVE: "ACTIVE";
+        readonly FINISHED: "FINISHED";
+        readonly ABANDONED: "ABANDONED";
+    }>;
+    coinsDelta: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodDate;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    origin: z.ZodLiteral<"QR">;
+    userId: z.ZodUUID;
+    startingBalance: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodUUID;
+    machineId: z.ZodString;
+    status: z.ZodEnum<{
+        readonly ACTIVE: "ACTIVE";
+        readonly FINISHED: "FINISHED";
+        readonly ABANDONED: "ABANDONED";
+    }>;
+    coinsDelta: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodDate;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    origin: z.ZodLiteral<"ANONYMOUS">;
+}, z.core.$strip>], "origin">;
+export declare const finishArcadeSessionInputSchema: z.ZodObject<{
+    sessionId: z.ZodUUID;
+    coinsDelta: z.ZodNumber;
+}, z.core.$strip>;

package/dist/domains/arcade/Arcade.schema.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finishArcadeSessionInputSchema = exports.arcadeSessionSchema = exports.anonymousArcadeSessionSchema = exports.qrArcadeSessionSchema = exports.createArcadeMachineInputSchema = exports.arcadeMachineSchema = exports.arcadeMachineIdSchema = exports.arcadeSessionOriginSchema = exports.arcadeSessionStatusSchema = void 0;
+const zod_1 = require("zod");
+const wallet_1 = require("../wallet");
+const Arcade_const_1 = require("./Arcade.const");
+exports.arcadeSessionStatusSchema = zod_1.z.enum(Arcade_const_1.ARCADE_SESSION_STATUS);
+exports.arcadeSessionOriginSchema = zod_1.z.enum(Arcade_const_1.ARCADE_SESSION_ORIGIN);
+/** Readable id printed in the machine QR, e.g. "marble-table-01" */
+exports.arcadeMachineIdSchema = zod_1.z
+    .string()
+    .regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, 'Machine id must use lowercase letters, numbers and dashes');
+exports.arcadeMachineSchema = zod_1.z.object({
+    id: exports.arcadeMachineIdSchema,
+    name: zod_1.z.string().min(1),
+    maxCoinsDelta: wallet_1.coinsAmountSchema.positive(),
+    isActive: zod_1.z.boolean().default(true),
+    createdAt: zod_1.z.date(),
+});
+exports.createArcadeMachineInputSchema = exports.arcadeMachineSchema.pick({
+    id: true,
+    name: true,
+    maxCoinsDelta: true,
+});
+const baseArcadeSessionSchema = zod_1.z.object({
+    id: zod_1.z.uuidv4(),
+    machineId: exports.arcadeMachineIdSchema,
+    status: exports.arcadeSessionStatusSchema,
+    coinsDelta: wallet_1.coinsAmountSchema.optional(),
+    startedAt: zod_1.z.date(),
+    finishedAt: zod_1.z.date().optional(),
+});
+exports.qrArcadeSessionSchema = baseArcadeSessionSchema.extend({
+    origin: zod_1.z.literal(Arcade_const_1.ARCADE_SESSION_ORIGIN.QR),
+    userId: zod_1.z.uuidv4(),
+    startingBalance: wallet_1.coinsAmountSchema.nonnegative(),
+});
+exports.anonymousArcadeSessionSchema = baseArcadeSessionSchema.extend({
+    origin: zod_1.z.literal(Arcade_const_1.ARCADE_SESSION_ORIGIN.ANONYMOUS),
+});
+exports.arcadeSessionSchema = zod_1.z.discriminatedUnion('origin', [
+    exports.qrArcadeSessionSchema,
+    exports.anonymousArcadeSessionSchema,
+]);
+exports.finishArcadeSessionInputSchema = zod_1.z.object({
+    sessionId: zod_1.z.uuidv4(),
+    coinsDelta: wallet_1.coinsAmountSchema,
+});

package/dist/domains/arcade/Arcade.types.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { anonymousArcadeSessionSchema, arcadeMachineIdSchema, arcadeMachineSchema, arcadeSessionOriginSchema, arcadeSessionSchema, arcadeSessionStatusSchema, createArcadeMachineInputSchema, finishArcadeSessionInputSchema, qrArcadeSessionSchema } from './Arcade.schema';
+export type ArcadeSessionStatus = z.infer<typeof arcadeSessionStatusSchema>;
+export type ArcadeSessionOrigin = z.infer<typeof arcadeSessionOriginSchema>;
+export type ArcadeMachineId = z.infer<typeof arcadeMachineIdSchema>;
+export type ArcadeMachine = z.infer<typeof arcadeMachineSchema>;
+export type CreateArcadeMachineInput = z.infer<typeof createArcadeMachineInputSchema>;
+export type QrArcadeSession = z.infer<typeof qrArcadeSessionSchema>;
+export type AnonymousArcadeSession = z.infer<typeof anonymousArcadeSessionSchema>;
+export type ArcadeSession = z.infer<typeof arcadeSessionSchema>;
+export type FinishArcadeSessionInput = z.infer<typeof finishArcadeSessionInputSchema>;

package/dist/domains/arcade/Arcade.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domains/arcade/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Arcade.const';
+export * from './Arcade.schema';
+export * from './Arcade.types';

package/dist/domains/arcade/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Arcade.const"), exports);
+__exportStar(require("./Arcade.schema"), exports);
+__exportStar(require("./Arcade.types"), exports);

package/dist/domains/command/Command.schema.d.ts

@@ -336,6 +336,10 @@ export declare const rgbModuleCommandSchema: z.ZodUnion<readonly [z.ZodObject<{
         }>;
         brightness: z.ZodNumber;
         effectTime: z.ZodNumber;
+        targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            readonly FRONT: "front";
+            readonly BACK: "back";
+        }>>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     module: z.ZodLiteral<"rgb">;
@@ -361,6 +365,10 @@ export declare const rgbModuleCommandSchema: z.ZodUnion<readonly [z.ZodObject<{
             readonly EMERGENCY_EFFECT: "Emergency Effect";
             readonly WAIT_EFFECT: "Wait Effect";
         }>;
+        targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            readonly FRONT: "front";
+            readonly BACK: "back";
+        }>>>;
     }, z.core.$strip>;
 }, z.core.$strip>]>;
 export declare const leftStarBackLaserModuleCommandSchema: z.ZodUnion<readonly [z.ZodObject<{
@@ -1271,6 +1279,10 @@ export declare const allCommandsConfigSchema: z.ZodIntersection<z.ZodUnion<reado
         }>;
         brightness: z.ZodNumber;
         effectTime: z.ZodNumber;
+        targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            readonly FRONT: "front";
+            readonly BACK: "back";
+        }>>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     module: z.ZodLiteral<"rgb">;
@@ -1296,6 +1308,10 @@ export declare const allCommandsConfigSchema: z.ZodIntersection<z.ZodUnion<reado
             readonly EMERGENCY_EFFECT: "Emergency Effect";
             readonly WAIT_EFFECT: "Wait Effect";
         }>;
+        targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            readonly FRONT: "front";
+            readonly BACK: "back";
+        }>>>;
     }, z.core.$strip>;
 }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
     module: z.ZodLiteral<"speed">;

package/dist/domains/flow/Flow.schema.d.ts

@@ -244,6 +244,10 @@ export declare const flowSchema: z.ZodObject<{
             }>;
             brightness: z.ZodNumber;
             effectTime: z.ZodNumber;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         module: z.ZodLiteral<"rgb">;
@@ -269,6 +273,10 @@ export declare const flowSchema: z.ZodObject<{
                 readonly EMERGENCY_EFFECT: "Emergency Effect";
                 readonly WAIT_EFFECT: "Wait Effect";
             }>;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
         module: z.ZodLiteral<"speed">;

package/dist/domains/hardware/KartHardwareState.schema.d.ts

@@ -13,7 +13,10 @@ export declare const kartHardwareStateSchema: z.ZodObject<{
         current: z.ZodNumber;
         configured: z.ZodNumber;
     }, z.core.$strip>>;
-    rgb: z.ZodNullable<z.ZodEnum<{
+    rgb: z.ZodRecord<z.ZodEnum<{
+        readonly FRONT: "front";
+        readonly BACK: "back";
+    }> & z.core.$partial, z.ZodEnum<{
         readonly SHOWING_COLOR: "Showing Color";
         readonly NOT_CONFIGURED: "Not Configured";
         readonly CONFIGURING_RGB: "Configuring RGB";

package/dist/domains/hardware/KartHardwareState.schema.js

@@ -16,7 +16,8 @@ exports.kartHardwareStateSchema = zod_1.z.object({
         configured: zod_1.z.number(),
     })
         .nullable(),
-    rgb: rgb_1.rgbStatusSchema.nullable(),
+    // Only the configured RGB modules have a key
+    rgb: zod_1.z.partialRecord(rgb_1.rgbModuleLabelSchema, rgb_1.rgbStatusSchema),
     flag: zod_1.z
         .object({
         status: flag_1.flagStatusSchema,

package/dist/domains/hardware/ModuleStatus.schema.d.ts

@@ -28,6 +28,11 @@ export declare const moduleStatusSchema: z.ZodUnion<readonly [z.ZodObject<{
     DACVoltage: z.ZodNumber;
     currentDefaultSpeedConfig: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
+    label: z.ZodEnum<{
+        readonly FRONT: "front";
+        readonly BACK: "back";
+    }>;
+    address: z.ZodNumber;
     rgbStatus: z.ZodEnum<{
         readonly SHOWING_COLOR: "Showing Color";
         readonly NOT_CONFIGURED: "Not Configured";

package/dist/domains/hardware/rgb/RGB.const.d.ts

@@ -10,3 +10,7 @@ export declare const RGB_ACTION_COMMANDS: {
     readonly EXEC: "Exec";
     readonly CONFIGURE: "Configure";
 };
+export declare const RGB_MODULE_LABEL: {
+    readonly FRONT: "front";
+    readonly BACK: "back";
+};

package/dist/domains/hardware/rgb/RGB.const.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RGB_ACTION_COMMANDS = exports.RGB_STATUS = void 0;
+exports.RGB_MODULE_LABEL = exports.RGB_ACTION_COMMANDS = exports.RGB_STATUS = void 0;
 exports.RGB_STATUS = {
     SHOWING_COLOR: 'Showing Color',
     NOT_CONFIGURED: 'Not Configured',
@@ -13,3 +13,7 @@ exports.RGB_ACTION_COMMANDS = {
     EXEC: 'Exec',
     CONFIGURE: 'Configure',
 };
+exports.RGB_MODULE_LABEL = {
+    FRONT: 'front',
+    BACK: 'back',
+};

package/dist/domains/hardware/rgb/RGB.schema.d.ts

@@ -11,7 +11,20 @@ export declare const rgbActionCommandSchema: z.ZodEnum<{
     readonly EXEC: "Exec";
     readonly CONFIGURE: "Configure";
 }>;
+export declare const rgbModuleLabelSchema: z.ZodEnum<{
+    readonly FRONT: "front";
+    readonly BACK: "back";
+}>;
+export declare const rgbTargetsSchema: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    readonly FRONT: "front";
+    readonly BACK: "back";
+}>>>;
 export declare const rgbModuleStatusSchema: z.ZodObject<{
+    label: z.ZodEnum<{
+        readonly FRONT: "front";
+        readonly BACK: "back";
+    }>;
+    address: z.ZodNumber;
     rgbStatus: z.ZodEnum<{
         readonly SHOWING_COLOR: "Showing Color";
         readonly NOT_CONFIGURED: "Not Configured";
@@ -52,6 +65,10 @@ export declare const rgbConfigurationOptionsSchema: z.ZodObject<{
     }>;
     brightness: z.ZodNumber;
     effectTime: z.ZodNumber;
+    targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        readonly FRONT: "front";
+        readonly BACK: "back";
+    }>>>;
 }, z.core.$strip>;
 export declare const rgbShowEffectOptionsSchema: z.ZodObject<{
     effect: z.ZodEnum<{
@@ -74,4 +91,8 @@ export declare const rgbShowEffectOptionsSchema: z.ZodObject<{
         readonly EMERGENCY_EFFECT: "Emergency Effect";
         readonly WAIT_EFFECT: "Wait Effect";
     }>;
+    targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        readonly FRONT: "front";
+        readonly BACK: "back";
+    }>>>;
 }, z.core.$strip>;

package/dist/domains/hardware/rgb/RGB.schema.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rgbShowEffectOptionsSchema = exports.rgbConfigurationOptionsSchema = exports.rgbModuleStatusSchema = exports.rgbActionCommandSchema = exports.rgbStatusSchema = void 0;
+exports.rgbShowEffectOptionsSchema = exports.rgbConfigurationOptionsSchema = exports.rgbModuleStatusSchema = exports.rgbTargetsSchema = exports.rgbModuleLabelSchema = exports.rgbActionCommandSchema = exports.rgbStatusSchema = void 0;
 const zod_1 = require("zod");
 const color_1 = require("../../color");
 const kart_effect_1 = require("../../hardware/kart-effect");
 const RGB_const_1 = require("./RGB.const");
 exports.rgbStatusSchema = zod_1.z.enum(RGB_const_1.RGB_STATUS);
 exports.rgbActionCommandSchema = zod_1.z.enum(RGB_const_1.RGB_ACTION_COMMANDS);
+exports.rgbModuleLabelSchema = zod_1.z.enum(RGB_const_1.RGB_MODULE_LABEL);
+// When targets is missing the command goes to every configured RGB module
+exports.rgbTargetsSchema = zod_1.z.array(exports.rgbModuleLabelSchema).min(1).optional();
 exports.rgbModuleStatusSchema = zod_1.z.object({
+    label: exports.rgbModuleLabelSchema,
+    address: zod_1.z.number(),
     rgbStatus: exports.rgbStatusSchema,
     kartColor: color_1.colorNameSchema,
 });
@@ -15,7 +20,9 @@ exports.rgbConfigurationOptionsSchema = zod_1.z.object({
     kartColor: color_1.colorNameSchema,
     brightness: zod_1.z.number().min(0).max(100),
     effectTime: zod_1.z.number().min(1).max(25),
+    targets: exports.rgbTargetsSchema,
 });
 exports.rgbShowEffectOptionsSchema = zod_1.z.object({
     effect: kart_effect_1.kartEffectSchema,
+    targets: exports.rgbTargetsSchema,
 });

package/dist/domains/hardware/rgb/RGB.types.d.ts

@@ -1,7 +1,9 @@
 import { z } from 'zod';
-import { rgbActionCommandSchema, rgbConfigurationOptionsSchema, rgbModuleStatusSchema, rgbShowEffectOptionsSchema, rgbStatusSchema } from './RGB.schema';
+import { rgbActionCommandSchema, rgbConfigurationOptionsSchema, rgbModuleLabelSchema, rgbModuleStatusSchema, rgbShowEffectOptionsSchema, rgbStatusSchema, rgbTargetsSchema } from './RGB.schema';
 export type RGBStatus = z.infer<typeof rgbStatusSchema>;
 export type RGBModuleStatus = z.infer<typeof rgbModuleStatusSchema>;
 export type RGBConfigurationOptions = z.infer<typeof rgbConfigurationOptionsSchema>;
 export type RGBShowEffectOptions = z.infer<typeof rgbShowEffectOptionsSchema>;
 export type RGBActionCommand = z.infer<typeof rgbActionCommandSchema>;
+export type RGBModuleLabel = z.infer<typeof rgbModuleLabelSchema>;
+export type RGBTargets = z.infer<typeof rgbTargetsSchema>;

package/dist/domains/hardware/screen/ScreenDebug.schema.d.ts

@@ -13,7 +13,10 @@ export declare const screenDebugViewInputSchema: z.ZodObject<{
         current: z.ZodNumber;
         configured: z.ZodNumber;
     }, z.core.$strip>>;
-    rgb: z.ZodNullable<z.ZodEnum<{
+    rgb: z.ZodRecord<z.ZodEnum<{
+        readonly FRONT: "front";
+        readonly BACK: "back";
+    }> & z.core.$partial, z.ZodEnum<{
         readonly SHOWING_COLOR: "Showing Color";
         readonly NOT_CONFIGURED: "Not Configured";
         readonly CONFIGURING_RGB: "Configuring RGB";

package/dist/domains/kart/Kart.schema.d.ts

@@ -79,7 +79,10 @@ export declare const kartSchema: z.ZodObject<{
             current: z.ZodNumber;
             configured: z.ZodNumber;
         }, z.core.$strip>>;
-        rgb: z.ZodNullable<z.ZodEnum<{
+        rgb: z.ZodRecord<z.ZodEnum<{
+            readonly FRONT: "front";
+            readonly BACK: "back";
+        }> & z.core.$partial, z.ZodEnum<{
             readonly SHOWING_COLOR: "Showing Color";
             readonly NOT_CONFIGURED: "Not Configured";
             readonly CONFIGURING_RGB: "Configuring RGB";

package/dist/domains/powerUp/PowerUp.schema.d.ts

@@ -240,6 +240,10 @@ export declare const powerUpCommandSchema: z.ZodIntersection<z.ZodUnion<readonly
         }>;
         brightness: z.ZodNumber;
         effectTime: z.ZodNumber;
+        targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            readonly FRONT: "front";
+            readonly BACK: "back";
+        }>>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     module: z.ZodLiteral<"rgb">;
@@ -265,6 +269,10 @@ export declare const powerUpCommandSchema: z.ZodIntersection<z.ZodUnion<readonly
             readonly EMERGENCY_EFFECT: "Emergency Effect";
             readonly WAIT_EFFECT: "Wait Effect";
         }>;
+        targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            readonly FRONT: "front";
+            readonly BACK: "back";
+        }>>>;
     }, z.core.$strip>;
 }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
     module: z.ZodLiteral<"speed">;
@@ -1244,6 +1252,10 @@ export declare const powerUpSchema: z.ZodObject<{
             }>;
             brightness: z.ZodNumber;
             effectTime: z.ZodNumber;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         module: z.ZodLiteral<"rgb">;
@@ -1269,6 +1281,10 @@ export declare const powerUpSchema: z.ZodObject<{
                 readonly EMERGENCY_EFFECT: "Emergency Effect";
                 readonly WAIT_EFFECT: "Wait Effect";
             }>;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
         module: z.ZodLiteral<"speed">;
@@ -2228,6 +2244,10 @@ export declare const powerUpSchema: z.ZodObject<{
             }>;
             brightness: z.ZodNumber;
             effectTime: z.ZodNumber;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         module: z.ZodLiteral<"rgb">;
@@ -2253,6 +2273,10 @@ export declare const powerUpSchema: z.ZodObject<{
                 readonly EMERGENCY_EFFECT: "Emergency Effect";
                 readonly WAIT_EFFECT: "Wait Effect";
             }>;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
         module: z.ZodLiteral<"speed">;

package/dist/domains/socket/clientToServer/SocketArcadeMachineClientToServerEventsParams.d.ts

@@ -0,0 +1,13 @@
+import type { ArcadeSession, FinishArcadeSessionInput } from '../../arcade';
+import type { Response } from '../../response';
+import type { ArcadeSessionStartedPayload } from '../serverToClient';
+export interface SocketArcadeMachineClientToServerEventsParams {
+    'arcade-machine:session:start-anonymous': undefined;
+    'arcade-machine:session:finish': FinishArcadeSessionInput;
+}
+export interface SocketArcadeMachineClientToServerAckResponses {
+    'arcade-machine:session:start-anonymous': Response<ArcadeSessionStartedPayload>;
+    'arcade-machine:session:finish': Response<{
+        session: ArcadeSession;
+    }>;
+}

package/dist/domains/socket/clientToServer/SocketArcadeMachineClientToServerEventsParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domains/socket/inputs/SocketArcadeMachineAuthInput.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** Sent by the arcade machine in the socket.io handshake `auth` field */
+export declare const socketArcadeMachineAuthInputSchema: z.ZodObject<{
+    machineId: z.ZodString;
+    secret: z.ZodString;
+}, z.core.$strip>;
+export type SocketArcadeMachineAuthInput = z.infer<typeof socketArcadeMachineAuthInputSchema>;

package/dist/domains/socket/inputs/SocketArcadeMachineAuthInput.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socketArcadeMachineAuthInputSchema = void 0;
+const zod_1 = require("zod");
+const arcade_1 = require("../../arcade");
+/** Sent by the arcade machine in the socket.io handshake `auth` field */
+exports.socketArcadeMachineAuthInputSchema = zod_1.z.object({
+    machineId: arcade_1.arcadeMachineIdSchema,
+    secret: zod_1.z.string().min(1),
+});

package/dist/domains/socket/serverToClient/SocketArcadeMachineServerToClientEventsParams.d.ts

@@ -0,0 +1,9 @@
+import type { ArcadeSession } from '../../arcade';
+export type ArcadeSessionStartedPayload = {
+    session: ArcadeSession;
+    playerName?: string;
+};
+export interface SocketArcadeMachineServerToClientEventsParams {
+    /** A session was opened for this machine (e.g. a user scanned the machine QR) */
+    'arcade-machine:session:started': ArcadeSessionStartedPayload;
+}

package/dist/domains/socket/serverToClient/SocketArcadeMachineServerToClientEventsParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domains/socket/utils/SocketParamsToEventsWithAck.d.ts

@@ -0,0 +1,5 @@
+export type SocketAck<Response> = (response: Response) => void;
+/** Like SocketParamsToEvents, but every event receives an ack callback as last argument */
+export type SocketParamsToEventsWithAck<Event, Ack extends Record<keyof Event, unknown>> = {
+    [EventKey in keyof Event]: Event[EventKey] extends undefined ? (ack: SocketAck<Ack[EventKey]>) => void : (payload: Event[EventKey], ack: SocketAck<Ack[EventKey]>) => void;
+};

package/dist/domains/socket/utils/SocketParamsToEventsWithAck.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domains/tutorial/TutorialConfig.schema.d.ts

@@ -324,6 +324,10 @@ export declare const tutorialStepConfigSchema: z.ZodObject<{
             }>;
             brightness: z.ZodNumber;
             effectTime: z.ZodNumber;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         module: z.ZodLiteral<"rgb">;
@@ -349,6 +353,10 @@ export declare const tutorialStepConfigSchema: z.ZodObject<{
                 readonly EMERGENCY_EFFECT: "Emergency Effect";
                 readonly WAIT_EFFECT: "Wait Effect";
             }>;
+            targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                readonly FRONT: "front";
+                readonly BACK: "back";
+            }>>>;
         }, z.core.$strip>;
     }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
         module: z.ZodLiteral<"speed">;
@@ -1363,6 +1371,10 @@ export declare const tutorialPhaseConfigSchema: z.ZodObject<{
                 }>;
                 brightness: z.ZodNumber;
                 effectTime: z.ZodNumber;
+                targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    readonly FRONT: "front";
+                    readonly BACK: "back";
+                }>>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{
             module: z.ZodLiteral<"rgb">;
@@ -1388,6 +1400,10 @@ export declare const tutorialPhaseConfigSchema: z.ZodObject<{
                     readonly EMERGENCY_EFFECT: "Emergency Effect";
                     readonly WAIT_EFFECT: "Wait Effect";
                 }>;
+                targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    readonly FRONT: "front";
+                    readonly BACK: "back";
+                }>>>;
             }, z.core.$strip>;
         }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
             module: z.ZodLiteral<"speed">;
@@ -2406,6 +2422,10 @@ export declare const tutorialMasterConfigSchema: z.ZodObject<{
                     }>;
                     brightness: z.ZodNumber;
                     effectTime: z.ZodNumber;
+                    targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        readonly FRONT: "front";
+                        readonly BACK: "back";
+                    }>>>;
                 }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
                 module: z.ZodLiteral<"rgb">;
@@ -2431,6 +2451,10 @@ export declare const tutorialMasterConfigSchema: z.ZodObject<{
                         readonly EMERGENCY_EFFECT: "Emergency Effect";
                         readonly WAIT_EFFECT: "Wait Effect";
                     }>;
+                    targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        readonly FRONT: "front";
+                        readonly BACK: "back";
+                    }>>>;
                 }, z.core.$strip>;
             }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
                 module: z.ZodLiteral<"speed">;

package/dist/domains/wallet/Wallet.const.d.ts

@@ -0,0 +1,4 @@
+export declare const WALLET_TRANSACTION_TYPE: {
+    readonly ADMIN_ADJUSTMENT: "ADMIN_ADJUSTMENT";
+    readonly ARCADE_SESSION: "ARCADE_SESSION";
+};

package/dist/domains/wallet/Wallet.const.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WALLET_TRANSACTION_TYPE = void 0;
+exports.WALLET_TRANSACTION_TYPE = {
+    ADMIN_ADJUSTMENT: 'ADMIN_ADJUSTMENT',
+    ARCADE_SESSION: 'ARCADE_SESSION',
+};

package/dist/domains/wallet/Wallet.schema.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export declare const walletTransactionTypeSchema: z.ZodEnum<{
+    readonly ADMIN_ADJUSTMENT: "ADMIN_ADJUSTMENT";
+    readonly ARCADE_SESSION: "ARCADE_SESSION";
+}>;
+export declare const coinsAmountSchema: z.ZodNumber;
+export declare const walletSchema: z.ZodObject<{
+    userId: z.ZodUUID;
+    balance: z.ZodNumber;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const adminAdjustmentTransactionSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodUUID;
+    amount: z.ZodNumber;
+    balanceAfter: z.ZodNumber;
+    createdAt: z.ZodDate;
+    type: z.ZodLiteral<"ADMIN_ADJUSTMENT">;
+    adminUserId: z.ZodUUID;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const arcadeSessionTransactionSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodUUID;
+    amount: z.ZodNumber;
+    balanceAfter: z.ZodNumber;
+    createdAt: z.ZodDate;
+    type: z.ZodLiteral<"ARCADE_SESSION">;
+    arcadeSessionId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const walletTransactionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodUUID;
+    amount: z.ZodNumber;
+    balanceAfter: z.ZodNumber;
+    createdAt: z.ZodDate;
+    type: z.ZodLiteral<"ADMIN_ADJUSTMENT">;
+    adminUserId: z.ZodUUID;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodUUID;
+    amount: z.ZodNumber;
+    balanceAfter: z.ZodNumber;
+    createdAt: z.ZodDate;
+    type: z.ZodLiteral<"ARCADE_SESSION">;
+    arcadeSessionId: z.ZodUUID;
+}, z.core.$strip>], "type">;
+export declare const walletTransactionsFilterSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export declare const walletAdjustmentInputSchema: z.ZodObject<{
+    userId: z.ZodUUID;
+    amount: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strip>;

package/dist/domains/wallet/Wallet.schema.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walletAdjustmentInputSchema = exports.walletTransactionsFilterSchema = exports.walletTransactionSchema = exports.arcadeSessionTransactionSchema = exports.adminAdjustmentTransactionSchema = exports.walletSchema = exports.coinsAmountSchema = exports.walletTransactionTypeSchema = void 0;
+const zod_1 = require("zod");
+const Wallet_const_1 = require("./Wallet.const");
+exports.walletTransactionTypeSchema = zod_1.z.enum(Wallet_const_1.WALLET_TRANSACTION_TYPE);
+exports.coinsAmountSchema = zod_1.z.number().int();
+exports.walletSchema = zod_1.z.object({
+    userId: zod_1.z.uuidv4(),
+    balance: exports.coinsAmountSchema.nonnegative(),
+    updatedAt: zod_1.z.date(),
+});
+const baseWalletTransactionSchema = zod_1.z.object({
+    id: zod_1.z.uuidv4(),
+    userId: zod_1.z.uuidv4(),
+    /** Positive adds coins, negative removes coins */
+    amount: exports.coinsAmountSchema,
+    balanceAfter: exports.coinsAmountSchema.nonnegative(),
+    createdAt: zod_1.z.date(),
+});
+exports.adminAdjustmentTransactionSchema = baseWalletTransactionSchema.extend({
+    type: zod_1.z.literal(Wallet_const_1.WALLET_TRANSACTION_TYPE.ADMIN_ADJUSTMENT),
+    adminUserId: zod_1.z.uuidv4(),
+    reason: zod_1.z.string().min(1),
+});
+exports.arcadeSessionTransactionSchema = baseWalletTransactionSchema.extend({
+    type: zod_1.z.literal(Wallet_const_1.WALLET_TRANSACTION_TYPE.ARCADE_SESSION),
+    arcadeSessionId: zod_1.z.uuidv4(),
+});
+exports.walletTransactionSchema = zod_1.z.discriminatedUnion('type', [
+    exports.adminAdjustmentTransactionSchema,
+    exports.arcadeSessionTransactionSchema,
+]);
+exports.walletTransactionsFilterSchema = zod_1.z.object({
+    limit: zod_1.z.coerce.number().int().min(1).max(100).default(20),
+    /** `createdAt` of the last item from the previous page */
+    cursor: zod_1.z.iso.datetime().optional(),
+});
+exports.walletAdjustmentInputSchema = zod_1.z.object({
+    userId: zod_1.z.uuidv4(),
+    amount: exports.coinsAmountSchema.refine((value) => value !== 0, { message: 'Amount must not be zero' }),
+    reason: zod_1.z.string().min(1, 'Reason is required'),
+});

package/dist/domains/wallet/Wallet.types.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { adminAdjustmentTransactionSchema, arcadeSessionTransactionSchema, walletAdjustmentInputSchema, walletSchema, walletTransactionSchema, walletTransactionTypeSchema, walletTransactionsFilterSchema } from './Wallet.schema';
+export type WalletTransactionType = z.infer<typeof walletTransactionTypeSchema>;
+export type Wallet = z.infer<typeof walletSchema>;
+export type AdminAdjustmentTransaction = z.infer<typeof adminAdjustmentTransactionSchema>;
+export type ArcadeSessionTransaction = z.infer<typeof arcadeSessionTransactionSchema>;
+export type WalletTransaction = z.infer<typeof walletTransactionSchema>;
+export type WalletAdjustmentInput = z.infer<typeof walletAdjustmentInputSchema>;
+export type WalletTransactionsFilter = z.infer<typeof walletTransactionsFilterSchema>;

package/dist/domains/wallet/Wallet.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domains/wallet/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Wallet.const';
+export * from './Wallet.schema';
+export * from './Wallet.types';

package/dist/domains/wallet/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Wallet.const"), exports);
+__exportStar(require("./Wallet.schema"), exports);
+__exportStar(require("./Wallet.types"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@battle-racing/br-common-lib",
-  "version": "6.2.0-rc.9",
+  "version": "6.2.0",
   "description": "Common library for all Battle Racing Repositorios",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/src/domains/hardware/KartHardwareState.schema.ts

@@ -1,6 +1,6 @@
 import { checkpointTypeSchema } from '../checkpoint/Checkpoint.schema';
 import { flagStatusSchema } from './flag';
-import { rgbStatusSchema } from './rgb';
+import { rgbModuleLabelSchema, rgbStatusSchema } from './rgb';
 import { steeringWheelModuleStatusSchema } from './steering-wheel';
 import { screenStatusSchema } from './screen';
 import { speedStatusSchema } from './speed';
@@ -14,7 +14,8 @@ export const kartHardwareStateSchema = z.object({
       configured: z.number(),
     })
     .nullable(),
-  rgb: rgbStatusSchema.nullable(),
+  // Only the configured RGB modules have a key
+  rgb: z.partialRecord(rgbModuleLabelSchema, rgbStatusSchema),
   flag: z
     .object({
       status: flagStatusSchema,

package/src/domains/hardware/rgb/RGB.const.ts

@@ -11,3 +11,8 @@ export const RGB_ACTION_COMMANDS = {
   EXEC: 'Exec',
   CONFIGURE: 'Configure',
 } as const;
+
+export const RGB_MODULE_LABEL = {
+  FRONT: 'front',
+  BACK: 'back',
+} as const;

package/src/domains/hardware/rgb/RGB.schema.ts

@@ -1,13 +1,20 @@
 import { z } from 'zod';
 import { colorNameSchema } from '../../color';
 import { kartEffectSchema } from '../../hardware/kart-effect';
-import { RGB_STATUS, RGB_ACTION_COMMANDS } from './RGB.const';
+import { RGB_STATUS, RGB_ACTION_COMMANDS, RGB_MODULE_LABEL } from './RGB.const';
 
 export const rgbStatusSchema = z.enum(RGB_STATUS);
 
 export const rgbActionCommandSchema = z.enum(RGB_ACTION_COMMANDS);
 
+export const rgbModuleLabelSchema = z.enum(RGB_MODULE_LABEL);
+
+// When targets is missing the command goes to every configured RGB module
+export const rgbTargetsSchema = z.array(rgbModuleLabelSchema).min(1).optional();
+
 export const rgbModuleStatusSchema = z.object({
+  label: rgbModuleLabelSchema,
+  address: z.number(),
   rgbStatus: rgbStatusSchema,
   kartColor: colorNameSchema,
 });
@@ -16,8 +23,10 @@ export const rgbConfigurationOptionsSchema = z.object({
   kartColor: colorNameSchema,
   brightness: z.number().min(0).max(100),
   effectTime: z.number().min(1).max(25),
+  targets: rgbTargetsSchema,
 });
 
 export const rgbShowEffectOptionsSchema = z.object({
   effect: kartEffectSchema,
+  targets: rgbTargetsSchema,
 });

package/src/domains/hardware/rgb/RGB.types.ts

@@ -2,9 +2,11 @@ import { z } from 'zod';
 import {
   rgbActionCommandSchema,
   rgbConfigurationOptionsSchema,
+  rgbModuleLabelSchema,
   rgbModuleStatusSchema,
   rgbShowEffectOptionsSchema,
   rgbStatusSchema,
+  rgbTargetsSchema,
 } from './RGB.schema';
 
 export type RGBStatus = z.infer<typeof rgbStatusSchema>;
@@ -12,3 +14,5 @@ export type RGBModuleStatus = z.infer<typeof rgbModuleStatusSchema>;
 export type RGBConfigurationOptions = z.infer<typeof rgbConfigurationOptionsSchema>;
 export type RGBShowEffectOptions = z.infer<typeof rgbShowEffectOptionsSchema>;
 export type RGBActionCommand = z.infer<typeof rgbActionCommandSchema>;
+export type RGBModuleLabel = z.infer<typeof rgbModuleLabelSchema>;
+export type RGBTargets = z.infer<typeof rgbTargetsSchema>;