@orakl/shared 0.1.0

package/dist/lobby.js

@@ -0,0 +1,50 @@
+import { ADJECTIVES, NOUNS } from "./constants/lobby.constants.js";
+import { murmurhash } from "./murmurhash.js";
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .trim()
+        .replace(/\s+/g, "-");
+}
+/**
+ * Deterministic lobby code from quiz name + category IDs.
+ * Same name + same categories always produces the same adj-noun code.
+ */
+export function generateLobbyCode(name, categoryIds) {
+    const key = `${slugify(name)},${[...categoryIds].sort().join(",")}`;
+    const h1 = murmurhash(key);
+    const h2 = murmurhash(`${key}\x00`);
+    const adj = ADJECTIVES[h1 % ADJECTIVES.length];
+    const noun = NOUNS[h2 % NOUNS.length];
+    return `${adj}-${noun}`;
+}
+/**
+ * Cryptographically-random integer in [0, max).
+ */
+function cryptoRandInt(max) {
+    const buf = new Uint32Array(1);
+    crypto.getRandomValues(buf);
+    return buf[0] % max;
+}
+/**
+ * Finds the player with the given id in a player list.
+ * Returns the first match, or undefined when no player has that id.
+ */
+export function findPlayer(players, id) {
+    return players.find((p) => p.id === id);
+}
+/**
+ * Random lobby code for tests / fallback when no quiz meta is available.
+ */
+export function generateRandomLobbyCode(existingCodes) {
+    const maxAttempts = 100;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const adj = ADJECTIVES[cryptoRandInt(ADJECTIVES.length)];
+        const noun = NOUNS[cryptoRandInt(NOUNS.length)];
+        const code = `${adj}-${noun}`;
+        if (!existingCodes || !existingCodes.has(code))
+            return code;
+    }
+    throw new Error("Unable to generate unique lobby code");
+}

package/dist/manage-questions.d.ts

@@ -0,0 +1,52 @@
+import type { AuthoredQuestionFilters, OperatorQuestionRevision, Question, QuestionSnapshot } from "@orakl/protocol";
+/**
+ * Wire shape of `GET /api/manage/questions/[id]` — what the dashboard's
+ * details view renders. `snapshot` is the same frozen shape the flag review
+ * uses; `matchItems` carries the pairs of an image-matching question in
+ * stored order, since the snapshot flattens them to `left|right` strings.
+ */
+export interface AuthoredQuestionDto {
+    id: string;
+    category: string;
+    created_at: string;
+    updated_at: string | null;
+    author: {
+        id: string | null;
+        nickname: string | null;
+        email: string | null;
+    };
+    published_at: string | null;
+    published_by: string | null;
+    unpublished_at: string | null;
+    unpublished_by: string | null;
+    unpublish_reason: string | null;
+    unpublisher: {
+        nickname: string | null;
+        email: string | null;
+    } | null;
+    changed_since_publish: number;
+    snapshot: QuestionSnapshot;
+    matchItems?: {
+        left: string[];
+        right: string[];
+        correctPairIndex: number;
+    };
+}
+/** Wire shape of `GET /api/manage/questions/[id]/revisions`: the question
+ *  as it is now, and every prior version newest first. */
+export interface RevisionsDto {
+    current: Question;
+    revisions: OperatorQuestionRevision[];
+}
+/** How the dashboard names a question's author: nickname, else email, else
+ *  "Deleted account" once the account is gone (`id` null), else "Unknown". */
+export declare function authorLabel(author: {
+    id: string | null;
+    nickname: string | null;
+    email: string | null;
+}): string;
+/** Rows per page on `/manage/questions` and its list endpoint. */
+export declare const AUTHORED_QUESTIONS_PAGE_SIZE = 20;
+/** `?author=&category=&published=&q=&changed=` from an untrusted query
+ *  string; the page load and the list endpoint both parse through here. */
+export declare function parseAuthoredFilters(params: URLSearchParams): AuthoredQuestionFilters;

package/dist/manage-questions.js

@@ -0,0 +1,26 @@
+/** How the dashboard names a question's author: nickname, else email, else
+ *  "Deleted account" once the account is gone (`id` null), else "Unknown". */
+export function authorLabel(author) {
+    if (author.nickname)
+        return author.nickname;
+    if (author.email)
+        return author.email;
+    return author.id === null ? "Deleted account" : "Unknown";
+}
+/** Rows per page on `/manage/questions` and its list endpoint. */
+export const AUTHORED_QUESTIONS_PAGE_SIZE = 20;
+const Q_MAX_LEN = 100;
+/** `?author=&category=&published=&q=&changed=` from an untrusted query
+ *  string; the page load and the list endpoint both parse through here. */
+export function parseAuthoredFilters(params) {
+    const authorId = params.get("author") || undefined;
+    const category = params.get("category") || undefined;
+    const publishedRaw = params.get("published");
+    const published = publishedRaw === "shared" || publishedRaw === "private"
+        ? publishedRaw
+        : "all";
+    const q = (params.get("q") ?? "").trim().slice(0, Q_MAX_LEN) || undefined;
+    const changedRaw = params.get("changed");
+    const changed = changedRaw === "1" || changedRaw === "true" ? true : undefined;
+    return { authorId, category, published, q, changed };
+}

package/dist/math.d.ts

@@ -0,0 +1,27 @@
+export interface PercentageOffsetOptions {
+    defaultOffset?: number;
+    min?: number;
+    max?: number;
+}
+/**
+ * Helper function to calculate clamped values within a specified range.
+ * @param value - The value to clamp.
+ * @param min - The minimum allowed value.
+ * @param max - The maximum allowed value.
+ */
+export declare const calculateClamped: (value: number, min: number, max: number) => number;
+/**
+ * Rounds a ratio to a whole percentage.
+ * @param numerator - The part, or an already-computed ratio when `denominator` is omitted.
+ * @param denominator - The whole; defaults to 1.
+ * @returns `Math.round((numerator / denominator) * 100)`.
+ */
+export declare const percent: (numerator: number, denominator?: number) => number;
+/**
+ * Calculates a percentage offset based on a dimension and clamps it within a range.
+ * @param offset - The offset distance.
+ * @param dimension - The dimension (width or height) to calculate percentage against.
+ * @param options - Configuration options for default, min, and max values.
+ * @returns The calculated and clamped percentage.
+ */
+export declare const calculatePercentageOffset: (offset: number, dimension: number, options?: PercentageOffsetOptions) => number;

package/dist/math.js

@@ -0,0 +1,30 @@
+/**
+ * Helper function to calculate clamped values within a specified range.
+ * @param value - The value to clamp.
+ * @param min - The minimum allowed value.
+ * @param max - The maximum allowed value.
+ */
+export const calculateClamped = (value, min, max) => {
+    return Math.max(min, Math.min(max, value));
+};
+/**
+ * Rounds a ratio to a whole percentage.
+ * @param numerator - The part, or an already-computed ratio when `denominator` is omitted.
+ * @param denominator - The whole; defaults to 1.
+ * @returns `Math.round((numerator / denominator) * 100)`.
+ */
+export const percent = (numerator, denominator = 1) => {
+    return Math.round((numerator / denominator) * 100);
+};
+/**
+ * Calculates a percentage offset based on a dimension and clamps it within a range.
+ * @param offset - The offset distance.
+ * @param dimension - The dimension (width or height) to calculate percentage against.
+ * @param options - Configuration options for default, min, and max values.
+ * @returns The calculated and clamped percentage.
+ */
+export const calculatePercentageOffset = (offset, dimension, options = {}) => {
+    const { defaultOffset = 50, min = 0, max = 100 } = options;
+    const percentage = defaultOffset + (offset / dimension) * 100;
+    return calculateClamped(percentage, min, max);
+};

package/dist/murmurhash.d.ts

@@ -0,0 +1,9 @@
+/**
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
+ * @see http://sites.google.com/site/murmurhash/
+ */
+export declare function murmurhash(key: string): number;

package/dist/murmurhash.js

@@ -0,0 +1,52 @@
+/**
+ * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+ *
+ * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
+ * @see http://sites.google.com/site/murmurhash/
+ */
+export function murmurhash(key) {
+    const remainder = key.length & 3;
+    const bytes = key.length - remainder;
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+    let h1 = 0;
+    let i = 0;
+    while (i < bytes) {
+        let k1 = (key.charCodeAt(i) & 0xff) |
+            ((key.charCodeAt(++i) & 0xff) << 8) |
+            ((key.charCodeAt(++i) & 0xff) << 16) |
+            ((key.charCodeAt(++i) & 0xff) << 24);
+        ++i;
+        // Optimized with Math.imul for 32-bit integer multiplication
+        k1 = Math.imul(k1, c1);
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1 = (Math.imul(h1, 5) + 0xe6546b64) | 0;
+    }
+    let k2 = 0;
+    switch (remainder) {
+        // biome-ignore lint/suspicious/noFallthroughSwitchClause: intentional cascade in MurmurHash
+        case 3:
+            k2 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+        // biome-ignore lint/suspicious/noFallthroughSwitchClause: intentional cascade in MurmurHash
+        case 2:
+            k2 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+        case 1:
+            k2 ^= key.charCodeAt(i) & 0xff;
+            k2 = Math.imul(k2, c1);
+            k2 = (k2 << 15) | (k2 >>> 17);
+            k2 = Math.imul(k2, c2);
+            h1 ^= k2;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x85ebca6b);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 0xc2b2ae35);
+    h1 ^= h1 >>> 16;
+    return h1 >>> 0;
+}

package/dist/pricing.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Subscription prices, in cents, for the two Polar products (decision 7,
+ * issue #1190).
+ */
+export declare const PRICES: {
+    readonly monthly: 500;
+    readonly lifetime: 10000;
+};
+/** Romanian VAT, the rate the estimate assumes; Polar charges the buyer's
+ *  own rate at checkout. */
+export declare const VAT_RATE = 0.21;
+/** Polar Pro's percentage fee on the gross price (Polar Pro pricing, 2026-09). */
+export declare const POLAR_FEE_RATE = 0.038;
+/** Polar Pro's fixed fee per order, in US cents (Polar Pro pricing, 2026-09). */
+export declare const POLAR_FEE_FIXED_USD = 40;
+/** Fixed USD→EUR rate for the fixed fee; an estimate, not a live rate. */
+export declare const USD_EUR = 0.92;
+/**
+ * Splits a gross EUR price, in cents, into VAT, Polar's fee, and what
+ * reaches Orakl. VAT is extracted from the VAT-inclusive gross
+ * (`gross × 21/121`); the fee is Polar Pro's 3.8% + $0.40 fixed fee,
+ * converted to EUR at a fixed rate; the net is the remainder. Each figure
+ * is rounded to the cent before the net is taken, so the three sum to the
+ * gross exactly.
+ */
+export declare function estimateBreakdown(grossCents: number): {
+    vat: number;
+    fee: number;
+    net: number;
+};
+/** Formats a cent amount as a euro figure, e.g. `357` → `"€3.57"`. */
+export declare function formatEur(cents: number): string;

package/dist/pricing.js

@@ -0,0 +1,32 @@
+/**
+ * Subscription prices, in cents, for the two Polar products (decision 7,
+ * issue #1190).
+ */
+export const PRICES = { monthly: 500, lifetime: 10000 };
+/** Romanian VAT, the rate the estimate assumes; Polar charges the buyer's
+ *  own rate at checkout. */
+export const VAT_RATE = 0.21;
+/** Polar Pro's percentage fee on the gross price (Polar Pro pricing, 2026-09). */
+export const POLAR_FEE_RATE = 0.038;
+/** Polar Pro's fixed fee per order, in US cents (Polar Pro pricing, 2026-09). */
+export const POLAR_FEE_FIXED_USD = 40;
+/** Fixed USD→EUR rate for the fixed fee; an estimate, not a live rate. */
+export const USD_EUR = 0.92;
+/**
+ * Splits a gross EUR price, in cents, into VAT, Polar's fee, and what
+ * reaches Orakl. VAT is extracted from the VAT-inclusive gross
+ * (`gross × 21/121`); the fee is Polar Pro's 3.8% + $0.40 fixed fee,
+ * converted to EUR at a fixed rate; the net is the remainder. Each figure
+ * is rounded to the cent before the net is taken, so the three sum to the
+ * gross exactly.
+ */
+export function estimateBreakdown(grossCents) {
+    const vat = Math.round((grossCents * VAT_RATE) / (1 + VAT_RATE));
+    const fee = Math.round(grossCents * POLAR_FEE_RATE + POLAR_FEE_FIXED_USD * USD_EUR);
+    const net = grossCents - vat - fee;
+    return { vat, fee, net };
+}
+/** Formats a cent amount as a euro figure, e.g. `357` → `"€3.57"`. */
+export function formatEur(cents) {
+    return `€${(cents / 100).toFixed(2)}`;
+}

package/dist/profile-tabs.d.ts

@@ -0,0 +1,8 @@
+import type { UserPower, UserRole } from "./types/auth.ts";
+export declare const TABS: readonly ["account", "appearance", "privacy", "tools"];
+export type ProfileTab = (typeof TABS)[number];
+/** Admins, any Management/Mimic power holder, or a non-production build sees the Tools tab. */
+export declare function showsToolsTab(user: {
+    role: UserRole;
+    powers: UserPower[];
+}): boolean;

package/dist/profile-tabs.js

@@ -0,0 +1,18 @@
+import { isProduction } from "./env.js";
+import { hasPower, hasRole } from "./types/auth.js";
+export const TABS = ["account", "appearance", "privacy", "tools"];
+/** The Management and Mimic powers that unlock the Tools tab. */
+const TOOLS_POWERS = [
+    "can-manage-categories",
+    "can-manage-avatars",
+    "can-moderate-questions",
+    "can-publish-questions",
+    "can-manage-features",
+    "can-access-mimic",
+];
+/** Admins, any Management/Mimic power holder, or a non-production build sees the Tools tab. */
+export function showsToolsTab(user) {
+    return (!isProduction() ||
+        hasRole(user.role, "admin") ||
+        TOOLS_POWERS.some((power) => hasPower(user, power)));
+}

package/dist/quiz-routes.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Phase-derived route resolver — the single source of truth for "which URL
+ * does a given actor belong at, for a given Phase + membership" (ADR 0004).
+ *
+ * Pure and dependency-free: imported by both the server (`load` redirects) and
+ * the client (SSE-driven `goto`). Phase→route logic lives here and nowhere else.
+ */
+import type { ActiveGamePhase } from "@orakl/protocol";
+/** Who is watching the Game lifecycle. Each maps the same Phase differently. */
+export type Actor = "player" | "curator" | "display";
+/** A token-holder's relationship to the current Lobby. */
+export type Membership = "none" | "pending" | "active";
+/** Phase as reported by `GameStore.getPhase()` (pre-start lobby + active phases). */
+export type ServerPhase = "lobby" | ActiveGamePhase;
+/**
+ * The gated journey state a route corresponds to: the server-authoritative
+ * Phase, plus the pre-membership / approval markers that are not Phases.
+ */
+export type JourneyState = "code-entry" | "setup" | "pending" | "lobby" | "playing" | "role_selection" | "final_scores";
+/**
+ * Derive the journey state from membership + Phase. Pure; shared by the server
+ * guard and the client navigation effect so they can never disagree.
+ */
+export declare function journeyState(membership: Membership, phase: ServerPhase | null): JourneyState;
+/** The canonical route for an actor in a given journey state. */
+export declare function routeForState(actor: Actor, state: JourneyState): string;
+/** Convenience: membership + Phase → route, in one hop. */
+export declare function routeForPhase(actor: Actor, membership: Membership, phase: ServerPhase | null): string;

package/dist/quiz-routes.js

@@ -0,0 +1,65 @@
+/**
+ * Derive the journey state from membership + Phase. Pure; shared by the server
+ * guard and the client navigation effect so they can never disagree.
+ */
+export function journeyState(membership, phase) {
+    if (membership === "none")
+        return phase ? "setup" : "code-entry";
+    if (membership === "pending")
+        return "pending";
+    // active member — route follows the live Phase
+    switch (phase) {
+        case "playing":
+        case "round_results":
+            return "playing";
+        case "role_selection":
+            return "role_selection";
+        case "final_scores":
+            return "final_scores";
+        default:
+            return "lobby";
+    }
+}
+/**
+ * Per-actor route table. `player` and `curator` share the "has a live lobby"
+ * states (lobby/playing/role_selection/final_scores) — a curator playing (or
+ * observing) their own quiz walks the identical journey through the identical
+ * `/quiz/*` routes (ADR 0019 route unification). The "no lobby yet" states
+ * differ: a stray player belongs at `/join` (enter a code); a curator with no
+ * lobby of their own belongs at `/curator/create` (host one), never `/join`.
+ * `display` is stubbed until that journey migrates (ADR 0004).
+ */
+const PLAYER_ROUTES = {
+    "code-entry": "/join",
+    setup: "/quiz/setup",
+    pending: "/quiz/setup",
+    lobby: "/quiz/lobby",
+    playing: "/quiz/play",
+    role_selection: "/quiz/roles",
+    final_scores: "/quiz/results",
+};
+const CURATOR_ROUTES = {
+    ...PLAYER_ROUTES,
+    // Unreachable in practice (a curator's own row is never pending, and only
+    // exists once their lobby does) — routed home defensively regardless.
+    "code-entry": "/curator/create",
+    setup: "/curator/create",
+    pending: "/curator/create",
+};
+const ROUTES = {
+    player: PLAYER_ROUTES,
+    curator: CURATOR_ROUTES,
+    display: {},
+};
+/** The canonical route for an actor in a given journey state. */
+export function routeForState(actor, state) {
+    const route = ROUTES[actor][state];
+    if (!route) {
+        throw new Error(`No route mapped for actor="${actor}" state="${state}"`);
+    }
+    return route;
+}
+/** Convenience: membership + Phase → route, in one hop. */
+export function routeForPhase(actor, membership, phase) {
+    return routeForState(actor, journeyState(membership, phase));
+}

package/dist/sanitize.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Input sanitization utilities for user-generated content
+ */
+export declare function isValidHexColor(color: string): boolean;
+/**
+ * Strip all HTML tags from a string
+ * This prevents stored XSS by removing any HTML markup.
+ * Optimized with an early exit.
+ */
+export declare function stripHtmlTags(text: string): string;
+/**
+ * Validate and sanitize question text
+ * - Strips HTML tags
+ * - Enforces max length
+ * - Trims whitespace
+ */
+export declare function sanitizeQuestionText(text: string): string;
+/**
+ * Validate and sanitize answer text
+ * - Strips HTML tags
+ * - Enforces max length
+ * - Trims whitespace
+ */
+export declare function sanitizeAnswerText(text: string): string;
+/**
+ * Sanitize match item text (for image_matching questions)
+ * - Strips HTML tags
+ * - Enforces max length (same as answer text)
+ * - Trims whitespace
+ */
+export declare function sanitizeMatchItemText(text: string): string;
+/**
+ * Sanitize nickname
+ * - Strips HTML tags to prevent XSS
+ * - Enforces max length from game settings
+ * - Trims whitespace
+ */
+export declare function sanitizeNickname(text: string | null | undefined): string;

package/dist/sanitize.js

@@ -0,0 +1,109 @@
+/**
+ * Input sanitization utilities for user-generated content
+ */
+import { GAME } from "@orakl/protocol";
+import { HEX_COLOR_RE, HTML_TAGS_RE } from "./constants/patterns.constants.js";
+const MAX_QUESTION_TEXT_LENGTH = 500;
+const MAX_ANSWER_TEXT_LENGTH = 200;
+export function isValidHexColor(color) {
+    return HEX_COLOR_RE.test(color);
+}
+/**
+ * Strip all HTML tags from a string
+ * This prevents stored XSS by removing any HTML markup.
+ * Optimized with an early exit.
+ */
+export function stripHtmlTags(text) {
+    if (!text || !text.includes("<"))
+        return text;
+    return text.replace(HTML_TAGS_RE, "");
+}
+/**
+ * Validate and sanitize question text
+ * - Strips HTML tags
+ * - Enforces max length
+ * - Trims whitespace
+ */
+export function sanitizeQuestionText(text) {
+    if (!text || typeof text !== "string") {
+        throw new Error("Question text must be a non-empty string");
+    }
+    // Strip HTML first
+    const stripped = stripHtmlTags(text);
+    // Trim whitespace
+    const trimmed = stripped.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Question text cannot be empty");
+    }
+    if (trimmed.length > MAX_QUESTION_TEXT_LENGTH) {
+        throw new Error(`Question text exceeds maximum length of ${MAX_QUESTION_TEXT_LENGTH} characters`);
+    }
+    return trimmed;
+}
+/**
+ * Validate and sanitize answer text
+ * - Strips HTML tags
+ * - Enforces max length
+ * - Trims whitespace
+ */
+export function sanitizeAnswerText(text) {
+    if (!text || typeof text !== "string") {
+        throw new Error("Answer text must be a non-empty string");
+    }
+    // Strip HTML first
+    const stripped = stripHtmlTags(text);
+    // Trim whitespace
+    const trimmed = stripped.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Answer text cannot be empty");
+    }
+    if (trimmed.length > MAX_ANSWER_TEXT_LENGTH) {
+        throw new Error(`Answer text exceeds maximum length of ${MAX_ANSWER_TEXT_LENGTH} characters`);
+    }
+    return trimmed;
+}
+/**
+ * Sanitize match item text (for image_matching questions)
+ * - Strips HTML tags
+ * - Enforces max length (same as answer text)
+ * - Trims whitespace
+ */
+export function sanitizeMatchItemText(text) {
+    if (!text || typeof text !== "string") {
+        throw new Error("Match item text must be a non-empty string");
+    }
+    // Strip HTML first
+    const stripped = stripHtmlTags(text);
+    // Trim whitespace
+    const trimmed = stripped.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Match item text cannot be empty");
+    }
+    if (trimmed.length > MAX_ANSWER_TEXT_LENGTH) {
+        throw new Error(`Match item text exceeds maximum length of ${MAX_ANSWER_TEXT_LENGTH} characters`);
+    }
+    return trimmed;
+}
+/**
+ * Sanitize nickname
+ * - Strips HTML tags to prevent XSS
+ * - Enforces max length from game settings
+ * - Trims whitespace
+ */
+export function sanitizeNickname(text) {
+    if (text === null ||
+        text === undefined ||
+        typeof text !== "string" ||
+        text.trim().length === 0) {
+        throw new Error("Missing or invalid nickname");
+    }
+    const stripped = stripHtmlTags(text);
+    const trimmed = stripped.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Nickname cannot be empty after sanitization");
+    }
+    if (trimmed.length > GAME.player.maxNicknameLength) {
+        throw new Error(`Nickname too long (max ${GAME.player.maxNicknameLength} characters)`);
+    }
+    return trimmed;
+}

package/dist/schemas/question.schema.d.ts

@@ -0,0 +1 @@
+export { type Difficulty, DifficultySchema, type ImageChoiceQuestion, type ImageMatchingQuestion, isHttpsUrl, type Media, MediaSchema, type MediaType, MediaTypeSchema, PostAnswerNoteSchema, type Question, QuestionSchema, type QuestionSource, QuestionSourceSchema, type QuestionType, QuestionTypeSchema, type Source, SourceSchema, type TextChoiceQuestion, type TrueFalseQuestion, } from "@orakl/protocol";

package/dist/schemas/question.schema.js

@@ -0,0 +1 @@
+export { DifficultySchema, isHttpsUrl, MediaSchema, MediaTypeSchema, PostAnswerNoteSchema, QuestionSchema, QuestionSourceSchema, QuestionTypeSchema, SourceSchema, } from "@orakl/protocol";

package/dist/solo-entitlements.d.ts

@@ -0,0 +1,28 @@
+export interface GuestEntitlements {
+    maxCategories: 3;
+    maxQuestions: 10;
+    difficulty: "all";
+    builtInOnly: true;
+    leaderboardEligible: false;
+}
+export interface AuthEntitlements {
+    maxCategories: null;
+    maxQuestions: null;
+    difficulty: "all" | "easy" | "medium" | "hard";
+    builtInOnly: false;
+    leaderboardEligible: true;
+}
+export type SoloEntitlements = GuestEntitlements | AuthEntitlements;
+export declare function getEntitlements(isGuest: boolean): SoloEntitlements;
+export interface SoloStartConfig {
+    categoryIds: string[];
+    questionCount: number;
+    mode: "normal" | "endless";
+    difficulty: "all" | "easy" | "medium" | "hard";
+}
+export interface EntitlementViolation {
+    code: "entitlement_exceeded";
+    message: string;
+    upgradeHint: string;
+}
+export declare function checkEntitlements(config: SoloStartConfig, entitlements: SoloEntitlements): EntitlementViolation | null;