@openora/core 0.4.1-canary.154 → 0.4.1-canary.156

package/dist/casino/lobby/schema/index.d.ts

@@ -291,6 +291,228 @@ export declare const featuredSlot: import("drizzle-orm/pg-core").PgTableWithColu
     };
     dialect: "pg";
 }>;
+export declare const lobbyLayout: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "lobby_layout";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "lobby_layout";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        layoutKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "layoutKey";
+            tableName: "lobby_layout";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "lobby_layout";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "lobby_layout";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "lobby_layout";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const lobbySection: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "lobby_section";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "lobby_section";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "lobby_section";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        config: import("drizzle-orm/pg-core").PgColumn<{
+            name: "config";
+            tableName: "lobby_section";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, import("zod").JSONType>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, import("zod").JSONType>;
+        }>;
+        sortOrder: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sortOrder";
+            tableName: "lobby_section";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isEnabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "isEnabled";
+            tableName: "lobby_section";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "lobby_section";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "lobby_section";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type LobbySection = typeof lobbySection.$inferSelect;
+export type LobbyLayout = typeof lobbyLayout.$inferSelect;
 export type LobbyCategory = typeof lobbyCategory.$inferSelect;
 export type LobbyCategoryGame = typeof lobbyCategoryGame.$inferSelect;
 export type FeaturedSlot = typeof featuredSlot.$inferSelect;

package/dist/casino/lobby/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/casino/lobby/schema/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUzB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW7B,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQvB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AACtE,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/casino/lobby/schema/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUzB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW7B,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQvB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAC5D,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AACtE,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC"}

package/dist/casino/lobby/schema/index.js

@@ -1,4 +1,4 @@
-import { pgTable, uuid, text, integer, boolean, timestamp, uniqueIndex, index, } from 'drizzle-orm/pg-core';
+import { pgTable, uuid, text, integer, boolean, timestamp, index, uniqueIndex, jsonb, } from 'drizzle-orm/pg-core';
 export const lobbyCategory = pgTable('lobby_category', {
     id: uuid().primaryKey().defaultRandom(),
     name: text().notNull(),
@@ -23,4 +23,24 @@ export const featuredSlot = pgTable('featured_slot', {
     isActive: boolean().notNull().default(true),
     createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
 });
+export const lobbyLayout = pgTable('lobby_layout', {
+    id: uuid().primaryKey().defaultRandom(),
+    layoutKey: text().notNull().default('global'),
+    version: integer().notNull().default(0),
+    updatedAt: timestamp({ withTimezone: true })
+        .notNull()
+        .$onUpdateFn(() => new Date()),
+    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+}, (t) => [uniqueIndex('lobby_layout_layout_key_key').on(t.layoutKey)]);
+export const lobbySection = pgTable('lobby_section', {
+    id: uuid().primaryKey().defaultRandom(),
+    type: text().notNull(),
+    config: jsonb().$type().notNull(),
+    sortOrder: integer().notNull().default(0),
+    isEnabled: boolean().notNull().default(true),
+    updatedAt: timestamp({ withTimezone: true })
+        .notNull()
+        .$onUpdateFn(() => new Date()),
+    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+}, (t) => [index('lobby_section_sort_order_idx').on(t.sortOrder)]);
 //# sourceMappingURL=index.js.map

package/dist/casino/lobby/schema/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/casino/lobby/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,OAAO,EACP,SAAS,EACT,WAAW,EACX,KAAK,GACN,MAAM,qBAAqB,CAAC;AAE7B,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAClC,gBAAgB,EAChB;IACE,EAAE,EAAE,IAAI,EAAE,CAAC,UAAU,EAAE,CAAC,aAAa,EAAE;IACvC,IAAI,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;IACtB,IAAI,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;IACtB,SAAS,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACzC,SAAS,EAAE,SAAS,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE;CACpE,EACD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACtD,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CACtC,qBAAqB,EACrB;IACE,EAAE,EAAE,IAAI,EAAE,CAAC,UAAU,EAAE,CAAC,aAAa,EAAE;IACvC,UAAU,EAAE,IAAI,EAAE;SACf,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IAC9D,MAAM,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;IACxB,SAAS,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;CAC1C,EACD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAClE,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC,eAAe,EAAE;IACnD,EAAE,EAAE,IAAI,EAAE,CAAC,UAAU,EAAE,CAAC,aAAa,EAAE;IACvC,MAAM,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;IACxB,KAAK,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;IACvB,SAAS,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;IAC3B,SAAS,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACzC,QAAQ,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3C,SAAS,EAAE,SAAS,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE;CACpE,CAAC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/casino/lobby/schema/index.ts"],"names":[],"mappings":"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"}

package/dist/casino/lobby/service/lobby.service.d.ts

@@ -1,12 +1,32 @@
-import { DrizzleService } from '@openora/core/server';
-import type { CacheAdapter } from '@openora/core/contracts';
+import { type DrizzleService, type EventBus } from '@openora/core/server';
+import type { CacheAdapter, ClientMeta, LobbySectionCatalog, User } from '@openora/core/contracts';
+import type { LobbyAdminLayout, ReplaceLobbyLayoutInput } from '../contract/index.js';
+export declare const LobbySectionNotFoundError: new (id: string) => Error & {
+    data?: Record<string, string>;
+};
 export declare const LobbyCategoryNotFoundError: new (slug: string) => Error & {
     data?: Record<string, string>;
 };
+export declare const LobbySectionFieldError: new (message: string) => Error & {
+    data?: Record<string, string>;
+};
+export declare const LobbyLayoutVersionConflictError: new (expectedVersion: number, actualVersion: number) => Error & {
+    data?: Record<string, string>;
+};
+type Actor = {
+    actorId?: User['id'];
+} & ClientMeta;
 export declare class LobbyService {
     private readonly drizzle;
+    private readonly events;
+    private readonly sectionCatalog;
     private readonly cache?;
-    constructor(drizzle: DrizzleService, cache?: CacheAdapter | undefined);
+    constructor(drizzle: DrizzleService, events: EventBus, sectionCatalog: LobbySectionCatalog, cache?: CacheAdapter | undefined);
+    getLayout(): Promise<{
+        id: string;
+        type: string;
+        data: import("zod").JSONType;
+    }[]>;
     listCategories(): Promise<{
         id: string;
         name: string;
@@ -72,5 +92,18 @@ export declare class LobbyService {
         }[];
         thumbnailUrl: string | null;
     }[]>;
+    getAdminLayout(): Promise<LobbyAdminLayout>;
+    replaceLayout(input: ReplaceLobbyLayoutInput & Actor): Promise<LobbyAdminLayout>;
+    private loadLayout;
+    private resolveSectionGroup;
+    private validateSections;
+    private parseConfig;
+    private groupSections;
+    private requireDefinition;
+    private loadAdminSections;
+    private assertUniqueSectionIds;
+    private assertExistingSectionIds;
+    private replaceSections;
 }
+export {};
 //# sourceMappingURL=lobby.service.d.ts.map

package/dist/casino/lobby/service/lobby.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lobby.service.d.ts","sourceRoot":"","sources":["../../../../src/casino/lobby/service/lobby.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EAIf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAU5D,eAAO,MAAM,0BAA0B;QAVoB,CAAC;CAa3D,CAAC;AA2BF,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;gBADN,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,YAAY,YAAA;IAGjC,cAAc;;;;;;;IA0Bd,gBAAgB,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8C7B,WAAW;;;;;;;;;IAyCX,MAAM,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;CAmB3B"}
+{"version":3,"file":"lobby.service.d.ts","sourceRoot":"","sources":["../../../../src/casino/lobby/service/lobby.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAWL,KAAK,cAAc,EAEnB,KAAK,QAAQ,EACd,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,mBAAmB,EAOnB,IAAI,EACL,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EACV,gBAAgB,EAGhB,uBAAuB,EACxB,MAAM,sBAAsB,CAAC;AAgB9B,eAAO,MAAM,yBAAyB;QA7CpC,CAAD;CA6CyE,CAAC;AAC3E,eAAO,MAAM,0BAA0B;QA9CrC,CAAD;CAiDA,CAAC;AACF,eAAO,MAAM,sBAAsB;QAlDjC,CAAD;CAqDA,CAAC;AACF,eAAO,MAAM,+BAA+B;QAtD1C,CAAD;CA4DA,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,OAAO,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;CACtB,GAAG,UAAU,CAAC;AAyCf,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAHN,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,QAAQ,EAChB,cAAc,EAAE,mBAAmB,EACnC,KAAK,CAAC,EAAE,YAAY,YAAA;IAGjC,SAAS;;;;;IAIT,cAAc;;;;;;;IA0Bd,gBAAgB,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4C7B,WAAW;;;;;;;;;IAuCX,MAAM,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;IAoBpB,cAAc,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAiB3C,aAAa,CAAC,KAAK,EAAE,uBAAuB,GAAG,KAAK,GAAG,OAAO,CAAC,gBAAgB,CAAC;YAmExE,UAAU;YAsBV,mBAAmB;YAuEnB,gBAAgB;IA4B9B,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,aAAa;IAerB,OAAO,CAAC,iBAAiB;YAUX,iBAAiB;IAW/B,OAAO,CAAC,sBAAsB;IAM9B,OAAO,CAAC,wBAAwB;YAyBlB,eAAe;CA8B9B"}

package/dist/casino/lobby/service/lobby.service.js

@@ -1,11 +1,20 @@
-import { createDomainError, findOneOrThrow, cached, likeContains, } from '@openora/core/server';
-import { eq, and, ilike, count, asc, inArray } from 'drizzle-orm';
-import { lobbyCategory, lobbyCategoryGame, featuredSlot } from '../schema/index.js';
+import { randomUUID } from 'node:crypto';
+import { and, asc, count, eq, ilike, inArray, notInArray, sql } from 'drizzle-orm';
+import { cached, createDomainError, createLogger, findOneOrThrow, invalidate, mapConcurrent, likeContains, makeNotFoundError, serializeRow, withAdvisoryXactLock, } from '@openora/core/server';
+import { LobbySectionDataSchema } from '@openora/core/contracts';
+import { featuredSlot, lobbyCategory, lobbyCategoryGame, lobbyLayout, lobbySection, } from '../schema/index.js';
 import { game, gameProvider } from '@openora/core/casino/schema/gaming';
 import { categoriesByGameIds, playableGameCondition, toCategorySummary, } from '../../shared/game-catalog.js';
+export const LobbySectionNotFoundError = makeNotFoundError('LobbySection');
 export const LobbyCategoryNotFoundError = createDomainError('LobbyCategoryNotFoundError', (slug) => `Lobby category not found: ${slug}`);
-// Feeds tolerate this much staleness; no invalidation wiring - TTL-only expiry.
+export const LobbySectionFieldError = createDomainError('LobbySectionFieldError', (message) => message);
+export const LobbyLayoutVersionConflictError = createDomainError('LobbyLayoutVersionConflictError', (expectedVersion, actualVersion) => `Lobby layout version ${expectedVersion} is stale; current version is ${actualVersion}`);
+const logger = createLogger('lobby');
+const GLOBAL_LAYOUT_KEY = 'global';
+const LAYOUT_LOCK_KEY = 'lobby:global-layout';
 const LOBBY_CACHE_TTL_MS = 30_000;
+const LAYOUT_CACHE_KEY = 'lobby:layout';
+const SECTION_OPERATION_CONCURRENCY = 5;
 const CATEGORIES_CACHE_KEY = 'lobby:categories';
 const FEATURED_CACHE_KEY = 'lobby:featured';
 function toGameSummary(row) {
@@ -25,11 +34,18 @@ function toGameSummary(row) {
 }
 export class LobbyService {
     drizzle;
+    events;
+    sectionCatalog;
     cache;
-    constructor(drizzle, cache) {
+    constructor(drizzle, events, sectionCatalog, cache) {
         this.drizzle = drizzle;
+        this.events = events;
+        this.sectionCatalog = sectionCatalog;
         this.cache = cache;
     }
+    async getLayout() {
+        return cached(this.cache, LAYOUT_CACHE_KEY, LOBBY_CACHE_TTL_MS, () => this.loadLayout());
+    }
     async listCategories() {
         return cached(this.cache, CATEGORIES_CACHE_KEY, LOBBY_CACHE_TTL_MS, async () => {
             const db = this.drizzle.db;
@@ -43,13 +59,13 @@ export class LobbyService {
                     .where(playableGameCondition())
                     .groupBy(lobbyCategoryGame.categoryId),
             ]);
-            const countMap = new Map(counts.map((r) => [r.categoryId, Number(r.n)]));
-            return categories.map((cat) => ({
-                id: cat.id,
-                name: cat.name,
-                slug: cat.slug,
-                sortOrder: cat.sortOrder,
-                gameCount: countMap.get(cat.id) ?? 0,
+            const countMap = new Map(counts.map((row) => [row.categoryId, Number(row.n)]));
+            return categories.map((category) => ({
+                id: category.id,
+                name: category.name,
+                slug: category.slug,
+                sortOrder: category.sortOrder,
+                gameCount: countMap.get(category.id) ?? 0,
             }));
         });
     }
@@ -89,7 +105,7 @@ export class LobbyService {
                 .from(featuredSlot)
                 .where(eq(featuredSlot.isActive, true))
                 .orderBy(asc(featuredSlot.placement), asc(featuredSlot.sortOrder));
-            const gameIds = [...new Set(slots.map((s) => s.gameId))];
+            const gameIds = [...new Set(slots.map((slot) => slot.gameId))];
             const games = gameIds.length > 0
                 ? await db
                     .select({ game })
@@ -129,5 +145,229 @@ export class LobbyService {
         const categories = await categoriesByGameIds(db, rows.map((r) => r.game.id), true);
         return rows.map((r) => toGameSummary({ ...r, categories: categories.get(r.game.id) ?? [] }));
     }
+    async getAdminLayout() {
+        return this.drizzle.db.transaction(async (tx) => {
+            const [layout] = await tx
+                .select({ version: lobbyLayout.version })
+                .from(lobbyLayout)
+                .where(eq(lobbyLayout.layoutKey, GLOBAL_LAYOUT_KEY));
+            return {
+                version: layout?.version ?? 0,
+                sections: await this.loadAdminSections(tx),
+            };
+        }, { isolationLevel: 'repeatable read', accessMode: 'read only' });
+    }
+    async replaceLayout(input) {
+        const { actorId, ip, userAgent } = input;
+        this.assertUniqueSectionIds(input.sections.flatMap((section) => section.id ?? []));
+        const preparedSections = input.sections.map((section, sortOrder) => {
+            const definition = this.requireDefinition(section.type);
+            return {
+                id: section.id ?? randomUUID(),
+                isNew: section.id === undefined,
+                type: section.type,
+                config: this.parseConfig(definition, section.config),
+                isEnabled: section.isEnabled,
+                sortOrder,
+            };
+        });
+        await this.validateSections(preparedSections);
+        const { before, after } = await this.drizzle.db.transaction((tx) => withAdvisoryXactLock(tx, LAYOUT_LOCK_KEY, async () => {
+            await tx
+                .insert(lobbyLayout)
+                .values({ layoutKey: GLOBAL_LAYOUT_KEY })
+                .onConflictDoNothing({ target: lobbyLayout.layoutKey });
+            const [layout] = await tx
+                .select()
+                .from(lobbyLayout)
+                .where(eq(lobbyLayout.layoutKey, GLOBAL_LAYOUT_KEY))
+                .for('update');
+            if (!layout) {
+                throw new Error('Lobby layout row missing after upsert');
+            }
+            if (layout.version !== input.version) {
+                throw new LobbyLayoutVersionConflictError(input.version, layout.version);
+            }
+            const before = { version: layout.version, sections: await this.loadAdminSections(tx) };
+            this.assertExistingSectionIds(before.sections, preparedSections);
+            await this.replaceSections(tx, preparedSections);
+            const nextVersion = layout.version + 1;
+            await tx
+                .update(lobbyLayout)
+                .set({ version: nextVersion })
+                .where(eq(lobbyLayout.id, layout.id));
+            const after = { version: nextVersion, sections: await this.loadAdminSections(tx) };
+            return { before, after };
+        }));
+        await invalidate(this.cache, LAYOUT_CACHE_KEY);
+        this.events.emit('lobby.layout.updated', {
+            actorId,
+            ip: ip ?? null,
+            userAgent: userAgent ?? null,
+            before,
+            after,
+        });
+        return after;
+    }
+    async loadLayout() {
+        const sections = await this.drizzle.db
+            .select()
+            .from(lobbySection)
+            .where(eq(lobbySection.isEnabled, true))
+            .orderBy(asc(lobbySection.sortOrder), asc(lobbySection.createdAt));
+        const groups = this.groupSections(sections);
+        const resolvedGroups = await mapConcurrent([...groups.entries()], SECTION_OPERATION_CONCURRENCY, ([type, group]) => this.resolveSectionGroup(type, group));
+        const byId = new Map(resolvedGroups.flatMap((group) => [...group]));
+        return sections.flatMap((section) => {
+            const resolved = byId.get(section.id);
+            return resolved ? [resolved] : [];
+        });
+    }
+    async resolveSectionGroup(type, group) {
+        const definition = this.sectionCatalog.get(type);
+        if (!definition) {
+            logger.warn({ type, sectionIds: group.map((section) => section.id) }, 'Skipping lobby sections with unknown type');
+            return new Map();
+        }
+        const validSections = [];
+        for (const section of group) {
+            try {
+                validSections.push({
+                    id: section.id,
+                    config: definition.parseConfig(section.config),
+                });
+            }
+            catch (err) {
+                logger.warn({ err, type, sectionId: section.id }, 'Skipping lobby section with invalid config');
+            }
+        }
+        if (validSections.length === 0) {
+            return new Map();
+        }
+        let data;
+        try {
+            data = await definition.resolve(validSections);
+        }
+        catch (err) {
+            logger.warn({ err, type }, 'Skipping lobby sections that failed to resolve');
+            return new Map();
+        }
+        const resolved = new Map();
+        for (const section of group) {
+            const sectionData = data.get(section.id);
+            if (sectionData === undefined) {
+                logger.warn({ type, sectionId: section.id }, 'Skipping lobby section that was not resolved');
+                continue;
+            }
+            const parsedData = LobbySectionDataSchema.safeParse(sectionData);
+            if (!parsedData.success) {
+                logger.warn({ issues: parsedData.error.issues, type, sectionId: section.id }, 'Skipping lobby section with invalid resolved data');
+                continue;
+            }
+            resolved.set(section.id, { id: section.id, type, data: parsedData.data });
+        }
+        return resolved;
+    }
+    async validateSections(sections) {
+        const groups = this.groupSections(sections);
+        await mapConcurrent([...groups.entries()], SECTION_OPERATION_CONCURRENCY, async ([type, group]) => {
+            const definition = this.requireDefinition(type);
+            let validation;
+            try {
+                validation = await definition.validate?.(group.map((section) => ({ id: section.id, config: section.config })));
+            }
+            catch (error) {
+                logger.error({ err: error, type }, 'Lobby section validation failed');
+                throw error;
+            }
+            if (validation && !validation.valid) {
+                throw new LobbySectionFieldError(`Invalid '${type}' section configuration: ${validation.message}`);
+            }
+        });
+    }
+    parseConfig(definition, config) {
+        try {
+            return definition.parseConfig(config);
+        }
+        catch (error) {
+            throw new LobbySectionFieldError(`Invalid '${definition.type}' section configuration: ${errorMessage(error)}`);
+        }
+    }
+    groupSections(sections) {
+        const groups = new Map();
+        for (const section of sections) {
+            const group = groups.get(section.type);
+            if (group) {
+                group.push(section);
+            }
+            else {
+                groups.set(section.type, [section]);
+            }
+        }
+        return groups;
+    }
+    requireDefinition(type) {
+        const definition = this.sectionCatalog.get(type);
+        if (!definition) {
+            throw new LobbySectionFieldError(`Unknown lobby section type: ${type}`);
+        }
+        return definition;
+    }
+    async loadAdminSections(tx) {
+        const sections = await tx
+            .select()
+            .from(lobbySection)
+            .orderBy(asc(lobbySection.sortOrder), asc(lobbySection.createdAt));
+        return sections.map((section) => serializeRow(section, { dateFields: ['createdAt', 'updatedAt'] }));
+    }
+    assertUniqueSectionIds(sectionIds) {
+        if (new Set(sectionIds).size !== sectionIds.length) {
+            throw new LobbySectionFieldError('Section ids must be unique');
+        }
+    }
+    assertExistingSectionIds(existingSections, preparedSections) {
+        const existingById = new Map(existingSections.map((section) => [section.id, section]));
+        for (const section of preparedSections) {
+            if (section.isNew) {
+                continue;
+            }
+            const existing = existingById.get(section.id);
+            if (!existing) {
+                throw new LobbySectionNotFoundError(section.id);
+            }
+            if (existing.type !== section.type) {
+                throw new LobbySectionFieldError(`Section type is '${existing.type}', not '${section.type}'`);
+            }
+        }
+    }
+    async replaceSections(tx, sections) {
+        const sectionIds = sections.map((section) => section.id);
+        if (sectionIds.length === 0) {
+            await tx.delete(lobbySection);
+            return;
+        }
+        await tx.delete(lobbySection).where(notInArray(lobbySection.id, sectionIds));
+        await tx
+            .insert(lobbySection)
+            .values(sections.map((section) => ({
+            id: section.id,
+            type: section.type,
+            config: section.config,
+            sortOrder: section.sortOrder,
+            isEnabled: section.isEnabled,
+        })))
+            .onConflictDoUpdate({
+            target: lobbySection.id,
+            set: {
+                config: sql `excluded.config`,
+                sortOrder: sql `excluded.sort_order`,
+                isEnabled: sql `excluded.is_enabled`,
+                updatedAt: sql `now()`,
+            },
+        });
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : 'validation failed';
 }
 //# sourceMappingURL=lobby.service.js.map