@orakl/shared 0.1.0

package/dist/solo-entitlements.js

@@ -0,0 +1,56 @@
+const GUEST = {
+    maxCategories: 3,
+    maxQuestions: 10,
+    difficulty: "all",
+    builtInOnly: true,
+    leaderboardEligible: false,
+};
+const AUTH = {
+    maxCategories: null,
+    maxQuestions: null,
+    difficulty: "all",
+    builtInOnly: false,
+    leaderboardEligible: true,
+};
+export function getEntitlements(isGuest) {
+    return isGuest ? GUEST : AUTH;
+}
+export function checkEntitlements(config, entitlements) {
+    // Endless is a signed-in mode: it's variable-length (no question cap) and
+    // would otherwise let a guest bypass the per-session question limit.
+    if (config.mode === "endless" && entitlements.builtInOnly) {
+        return {
+            code: "entitlement_exceeded",
+            message: "Endless mode is for signed-in players.",
+            upgradeHint: "Sign in to brave the endless gauntlet.",
+        };
+    }
+    if (entitlements.maxCategories !== null &&
+        config.categoryIds.length > entitlements.maxCategories) {
+        return {
+            code: "entitlement_exceeded",
+            message: `Guests may select up to ${entitlements.maxCategories} categories.`,
+            upgradeHint: "Sign in to unlock all categories.",
+        };
+    }
+    if (entitlements.maxQuestions !== null &&
+        config.mode !== "endless" &&
+        config.questionCount > entitlements.maxQuestions) {
+        return {
+            code: "entitlement_exceeded",
+            message: `Guests may play up to ${entitlements.maxQuestions} questions per session.`,
+            upgradeHint: "Sign in to unlock longer sessions.",
+        };
+    }
+    if (entitlements.difficulty !== "all" ||
+        (entitlements.maxCategories !== null && config.difficulty !== "all")) {
+        if (config.difficulty !== "all" && entitlements.builtInOnly) {
+            return {
+                code: "entitlement_exceeded",
+                message: "Guests cannot filter by difficulty.",
+                upgradeHint: "Sign in to target specific difficulty levels.",
+            };
+        }
+    }
+    return null;
+}

package/dist/theme.d.ts

@@ -0,0 +1,39 @@
+export { DEFAULT_THEME, LOGO_SCHEDULE, PHASE_COLORS, PHASE_CONFIG, PHASE_TIMES, SKY_PHASES, SKY_SCHEDULE, SYSTEM_PREF_COOKIE, THEME_COOKIE, THEME_LABELS, } from "./constants/theme.constants.ts";
+export type SkyPhase = "night" | "dawn" | "morning" | "noon" | "evening" | "sunset" | "dusk";
+/** Core modes plus every sky phase as a fixed time-of-day override. */
+export type ThemeMode = "dark" | "light" | "system" | "dynamic" | SkyPhase;
+export type ResolvedTheme = {
+    readonly mode: ThemeMode;
+    /** Effective dark/light for body & CSS token switching. */
+    readonly effective: "dark" | "light";
+    readonly phase: SkyPhase;
+    readonly showStars: boolean;
+    readonly showSky: boolean;
+    readonly showBirds: boolean;
+    /** Sky gradient name passed to Sky component. */
+    readonly skyTimeOfDay: "dawn" | "morning" | "noon" | "evening" | "sunset" | "dusk";
+    /**
+     * For system mode the SSR renders both backgrounds in the DOM so the
+     * ThemeScript / CSS can show the correct one without a full reload.
+     */
+    readonly renderBoth: boolean;
+};
+/** A sky phase is dark once its star opacity rises above zero. */
+export declare function effectiveThemeForPhase(phase: SkyPhase): "dark" | "light";
+export declare function getSkyPhase(hour: number): SkyPhase;
+/**
+ * Compact lookup for the inline blocking script in app.html.
+ * Comma-separated "phase:effective" for hours 0–23, derived from
+ * HOUR_TO_PHASE + PHASE_CONFIG so it stays in sync automatically.
+ */
+export declare const DYNAMIC_LOOKUP_STRING: string;
+/**
+ * Resolve what background to show.
+ * Optimized with O(1) lookups and zero allocations on the hot path.
+ * @param mode    User-chosen theme mode (including optional sky-phase override)
+ * @param hour    Current local 24h hour (0–23)
+ * @param sysPref 'dark' | 'light' from client hint or cookie, system mode only
+ */
+export declare function resolveTheme(mode: ThemeMode, hour: number, sysPref?: "dark" | "light"): ResolvedTheme;
+export declare function parseThemeMode(value: string | undefined): ThemeMode;
+export declare function parseSystemPref(value: string | undefined): "dark" | "light" | undefined;

package/dist/theme.js

@@ -0,0 +1,139 @@
+import { DEFAULT_THEME, PHASE_CONFIG, SKY_PHASES, SKY_SCHEDULE, } from "./constants/theme.constants.js";
+export { DEFAULT_THEME, LOGO_SCHEDULE, PHASE_COLORS, PHASE_CONFIG, PHASE_TIMES, SKY_PHASES, SKY_SCHEDULE, SYSTEM_PREF_COOKIE, THEME_COOKIE, THEME_LABELS, } from "./constants/theme.constants.js";
+function toSkyTimeOfDay(phase) {
+    if (phase === "night")
+        return "morning";
+    return phase;
+}
+/** A sky phase is dark once its star opacity rises above zero. */
+export function effectiveThemeForPhase(phase) {
+    // A phase outside the table (a stale stored mode) reads as light.
+    const config = PHASE_CONFIG[phase];
+    return config && config.starOpacity > 0 ? "dark" : "light";
+}
+const SKY_PHASE_SET = new Set(SKY_PHASES);
+/** Pre-calculated 24-hour phase table for O(1) lookup. */
+const HOUR_TO_PHASE = Array.from({ length: 24 }, (_, hour) => {
+    for (const [phase, [start, end]] of Object.entries(SKY_SCHEDULE)) {
+        if (start > end) {
+            if (hour >= start || hour < end)
+                return phase;
+        }
+        else if (hour >= start && hour < end) {
+            return phase;
+        }
+    }
+    return "night";
+});
+export function getSkyPhase(hour) {
+    return HOUR_TO_PHASE[hour % 24] ?? "night";
+}
+/** Pre-calculated theme results for all fixed sky phases. */
+const THEME_BY_SKY_PHASE = Object.fromEntries(SKY_PHASES.map((p) => [
+    p,
+    {
+        mode: p,
+        effective: effectiveThemeForPhase(p),
+        phase: p,
+        showStars: PHASE_CONFIG[p].starOpacity > 0,
+        showSky: PHASE_CONFIG[p].showSky,
+        showBirds: PHASE_CONFIG[p].birdOpacity > 0,
+        skyTimeOfDay: toSkyTimeOfDay(p),
+        renderBoth: false,
+    },
+]));
+const THEME_DARK = {
+    mode: "dark",
+    effective: "dark",
+    phase: "night",
+    showStars: true,
+    showSky: false,
+    showBirds: false,
+    skyTimeOfDay: "morning",
+    renderBoth: false,
+};
+const THEME_LIGHT = {
+    mode: "light",
+    effective: "light",
+    phase: "morning",
+    showStars: false,
+    showSky: true,
+    showBirds: true,
+    skyTimeOfDay: "morning",
+    renderBoth: false,
+};
+const THEME_SYSTEM_DARK = {
+    mode: "system",
+    effective: "dark",
+    phase: "night",
+    showStars: true,
+    showSky: true,
+    showBirds: true,
+    skyTimeOfDay: "morning",
+    renderBoth: true,
+};
+const THEME_SYSTEM_LIGHT = {
+    mode: "system",
+    effective: "light",
+    phase: "morning",
+    showStars: true,
+    showSky: true,
+    showBirds: true,
+    skyTimeOfDay: "morning",
+    renderBoth: true,
+};
+/** Pre-calculated theme results for dynamic mode by hour. */
+const THEME_DYNAMIC_BY_HOUR = HOUR_TO_PHASE.map((p) => ({
+    ...THEME_BY_SKY_PHASE[p],
+    mode: "dynamic",
+}));
+/**
+ * Compact lookup for the inline blocking script in app.html.
+ * Comma-separated "phase:effective" for hours 0–23, derived from
+ * HOUR_TO_PHASE + PHASE_CONFIG so it stays in sync automatically.
+ */
+export const DYNAMIC_LOOKUP_STRING = HOUR_TO_PHASE.map((p) => `${p}:${effectiveThemeForPhase(p)}`).join(",");
+/**
+ * Resolve what background to show.
+ * Optimized with O(1) lookups and zero allocations on the hot path.
+ * @param mode    User-chosen theme mode (including optional sky-phase override)
+ * @param hour    Current local 24h hour (0–23)
+ * @param sysPref 'dark' | 'light' from client hint or cookie, system mode only
+ */
+export function resolveTheme(mode, hour, sysPref) {
+    // 1. Check fixed sky phase overrides first (e.g. mode === 'sunset')
+    if (SKY_PHASE_SET.has(mode)) {
+        return THEME_BY_SKY_PHASE[mode];
+    }
+    // 2. Main mode switching
+    switch (mode) {
+        case "dark":
+            return THEME_DARK;
+        case "light":
+            return THEME_LIGHT;
+        case "system":
+            return sysPref === "light" ? THEME_SYSTEM_LIGHT : THEME_SYSTEM_DARK;
+        case "dynamic":
+            return THEME_DYNAMIC_BY_HOUR[hour % 24] ?? THEME_DYNAMIC_BY_HOUR[0];
+        default:
+            // Unreachable given parseThemeMode() validation
+            return THEME_DARK;
+    }
+}
+const VALID_MODES = new Set([
+    "dark",
+    "light",
+    "system",
+    "dynamic",
+    ...SKY_PHASES,
+]);
+export function parseThemeMode(value) {
+    if (value && VALID_MODES.has(value))
+        return value;
+    return DEFAULT_THEME;
+}
+export function parseSystemPref(value) {
+    if (value === "dark" || value === "light")
+        return value;
+    return undefined;
+}

package/dist/types/auth.d.ts

@@ -0,0 +1,143 @@
+import type { PowerShape } from "../constants/auth.constants.ts";
+import { ALL_POWERS, ANON_USER, powerDescription, powerShape, ROLE_HIERARCHY } from "../constants/auth.constants.ts";
+export type { PowerShape };
+export { ALL_POWERS, ANON_USER, powerDescription, powerShape, ROLE_HIERARCHY };
+/**
+ * Account role. `anonymous`/`display` hold no account. `member` is the base
+ * signed-in tier. `curator` and `admin` hold elevated grants.
+ */
+export type UserRole = "anonymous" | "display" | "member" | "curator" | "admin";
+/**
+ * A capability granted to an account, independent of its role. Every name here
+ * is declared at a site that reads it: most are access gates, and the one that
+ * is not (`is-power-user`) changes what the UI renders. A grantable name that
+ * nothing reads at all is not access control, however much it looks like it.
+ *
+ * A gating power either **supplements** a role gate or **replaces** it — each
+ * is annotated below, and the enforcement site is the authority.
+ */
+export type UserPower = 
+/**
+ * Replaces the role gate on `/mimic/*` in production, which 404s for
+ * everyone else. Dev is unconditional.
+ */
+"can-access-mimic"
+/**
+ * Replaces the role gate on the feedback widget — both the FAB's visibility
+ * and `POST /api/feedback`. The `FEEDBACK_WIDGET` flag applies on top.
+ */
+ | "can-send-feedback"
+/**
+ * Replaces the role gate on `/manage/import`, `POST /api/manage/import-questions`
+ * and `POST /api/manage/check-fingerprints`. The `ENABLE_IMPORTS` flag applies
+ * on top.
+ */
+ | "can-import-quizzes"
+/** Supplements the admin role on `/admin/feature-flags` and its endpoint. */
+ | "can-manage-features"
+/**
+ * Supplements the curator role on question authoring: `/curator/questions`,
+ * `/api/custom-questions` (every method), `POST /api/upload-image`, and the
+ * authoring form's inline category create (`POST /api/categories` and its
+ * `/api/topics` alias). The `/curator` row in `ROUTE_GUARDS` refuses a
+ * non-curator first, so this narrows who among curators may author — it
+ * opens the surface to nobody else. Category *management* is a different
+ * trust: `can-manage-categories`.
+ */
+ | "can-add-questions"
+/**
+ * Replaces the role gate on the quiz taxonomy: `/manage/categories` and
+ * `/api/manage/categories` (every method).
+ */
+ | "can-manage-categories"
+/**
+ * Replaces the role gate on review of player-reported questions:
+ * `/manage/flagged-questions` and `/api/manage/flagged-questions/*`. Separate
+ * from `can-manage-categories` — reviewing a report is not the same trust as
+ * editing what every quiz draws from.
+ */
+ | "can-moderate-questions"
+/**
+ * Replaces the role gate on the authored-questions dashboard:
+ * `/manage/questions`, `GET /api/manage/questions`,
+ * `GET /api/manage/questions/[id]`,
+ * `POST /api/manage/questions/[id]/publish`,
+ * `POST /api/manage/questions/[id]/unpublish`,
+ * `POST /api/manage/questions/[id]/republish`,
+ * `POST /api/manage/questions/publish` and
+ * `GET /api/manage/questions/[id]/revisions`. Every curator's questions,
+ * with their author; promotes one or several into the shared bank,
+ * withdraws one, or reconfirms one an author edited since promotion; reads
+ * a question's revision history with each edit's actor.
+ */
+ | "can-publish-questions"
+/**
+ * Collapses every `FieldDescription` info-i to nothing, for an operator who
+ * knows the fields and wants the setup forms bare. Gates no route and no
+ * data — the only power that grants nothing.
+ */
+ | "is-power-user"
+/**
+ * Replaces the role gate on avatar curation: `/manage/avatars`,
+ * `PUT /api/avatars` and `POST /api/manage/sync-avatars`.
+ */
+ | "can-manage-avatars"
+/**
+ * Supplements the member role on the curation-request card and
+ * `POST /api/profile/curation-request`. A member without it never sees the
+ * apply control.
+ */
+ | "can-apply-for-curation"
+/** Lets a curator start a game with fewer than two other players. */
+ | "can-1v1";
+export interface AuthUser {
+    id: string;
+    email: string | null;
+    nickname: string | null;
+    avatar: string | null;
+    role: UserRole;
+    powers: UserPower[];
+    /** Lobby a player token was issued for; null for accounts/anonymous. */
+    lobbyCode: string | null;
+    /**
+     * Set when the game token behind this identity was minted as the curator
+     * token of `lobbyCode` (lobby creation re-mints it, map #1184 decision on
+     * #1210). `role` stays the account role, so a member hosting on the free
+     * allowance is a curator for their lobby and a member everywhere else.
+     */
+    lobbyRole?: "curator";
+    /**
+     * The account role as the DB row or the token's `accountRole` claim
+     * states it — never the fail-safe fallback to the lobby role. Absent when
+     * neither is known, so a re-mint carries no claim rather than a guess.
+     */
+    accountRole?: UserRole;
+    /** Account email confirmed via OTP. Always false for anonymous/rowless tokens. */
+    emailVerified: boolean;
+    /** Session id of the account token backing this identity (#824); null for
+     *  rowless/anonymous. Lets routes that re-mint an account token (lobby
+     *  create) keep it bound to the same session row. */
+    sid: string | null;
+    /** The `users.id` this identity resolves to: the row behind a
+     *  session-backed token, or the account a rowless lobby player token was
+     *  minted for (a signed claim carried from the join, #953 — not a session;
+     *  session-only gates read `sid`). Absent for anonymous, display and guest
+     *  players. */
+    accountUserId?: string;
+}
+/**
+ * Narrow an untrusted value — a DB column, a token claim, a query param — to a
+ * declared role. Both predicates read the same constants the unions are built
+ * from, so neither can accept a name the type does not.
+ */
+export declare function isUserRole(value: unknown): value is UserRole;
+export declare function isUserPower(value: unknown): value is UserPower;
+/** An untrusted role, or `anonymous` — an undeclared name grants nothing. */
+export declare function parseRole(value: unknown): UserRole;
+/** Every declared power in an untrusted list; undeclared names are dropped. */
+export declare function parsePowerList(value: unknown): UserPower[];
+export declare function hasRole(userRole: UserRole, required: UserRole): boolean;
+/** Takes anything carrying powers, so nav config and route guards can share it. */
+export declare function hasPower(user: {
+    powers: UserPower[];
+}, power: UserPower): boolean;

package/dist/types/auth.js

@@ -0,0 +1,28 @@
+import { ALL_POWERS, ANON_USER, powerDescription, powerShape, ROLE_HIERARCHY, } from "../constants/auth.constants.js";
+export { ALL_POWERS, ANON_USER, powerDescription, powerShape, ROLE_HIERARCHY };
+/**
+ * Narrow an untrusted value — a DB column, a token claim, a query param — to a
+ * declared role. Both predicates read the same constants the unions are built
+ * from, so neither can accept a name the type does not.
+ */
+export function isUserRole(value) {
+    return typeof value === "string" && Object.hasOwn(ROLE_HIERARCHY, value);
+}
+export function isUserPower(value) {
+    return typeof value === "string" && ALL_POWERS.includes(value);
+}
+/** An untrusted role, or `anonymous` — an undeclared name grants nothing. */
+export function parseRole(value) {
+    return isUserRole(value) ? value : "anonymous";
+}
+/** Every declared power in an untrusted list; undeclared names are dropped. */
+export function parsePowerList(value) {
+    return Array.isArray(value) ? value.filter(isUserPower) : [];
+}
+export function hasRole(userRole, required) {
+    return ROLE_HIERARCHY[userRole] >= ROLE_HIERARCHY[required];
+}
+/** Takes anything carrying powers, so nav config and route guards can share it. */
+export function hasPower(user, power) {
+    return user.powers.includes(power);
+}

package/dist/utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Create a URL-friendly slug from a string.
+ * Converts to lowercase, removes diacritics, and replaces spaces with hyphens.
+ * @param text - The text to slugify.
+ * @returns A URL-friendly slug.
+ */
+export declare function slugify(text: string): string;
+/**
+ * Get a formatted date for a given date.
+ * @param date - The date to display.
+ * @returns The formatted date.
+ */
+export declare function getFormattedDate(date: string): string;
+/**
+ * Get a formatted time for a given date.
+ * @param date - The date to display.
+ * @returns The formatted time.
+ */
+export declare function getFormattedTime(date: string): string;
+/**
+ * Get a relative date for a given date.
+ * @param date - The date to display.
+ * @returns The relative date.
+ */
+export declare function getRelativeDate(date: string): string;
+/**
+ * Get a display date for a given date.
+ * @param date - The date to display.
+ * @returns The display date.
+ */
+export declare function getDisplayDate(date: string): string;
+/** Fisher-Yates shuffle (returns new array, does not mutate). */
+export declare function shuffleArray<T>(arr: T[]): T[];
+/** Throws if URL is not http/https. */
+export declare function validateMediaUrl(url: string): void;
+/** Returns validated URL or undefined if invalid (logs security warning). */
+export declare function sanitizeMediaUrl(url: string | undefined): string | undefined;
+/**
+ * Parse **bold** markdown syntax into <strong> tags.
+ * Strips HTML first so no raw markup can pass through.
+ * Optimized with an early exit.
+ */
+export declare function parseBold(text: string): string;
+/**
+ * A timestamp column as an ISO string. SQLite's CURRENT_TIMESTAMP and
+ * datetime('now') write "YYYY-MM-DD HH:MM:SS" in UTC, which `new Date()`
+ * reads as local time in V8 and refuses outright in Safari; an ISO string
+ * (JS-written created_at) passes through unchanged.
+ */
+export declare function toIsoTimestamp(value: string): string;

package/dist/utils.js

@@ -0,0 +1,133 @@
+import { addDays, formatRelative, parseISO } from "date-fns";
+import { HTML_TAGS_RE } from "./constants/patterns.constants.js";
+// Hoisted to avoid recompiling on every slugify() call (called 100s of times during bulk imports)
+const RE_DIACRITICS = /[\u0300-\u036F]/g;
+const RE_WHITESPACE = /\s+/g;
+const RE_NON_SLUG = /[^a-z0-9-]/g;
+const RE_MULTI_HYPHEN = /-+/g;
+const RE_TRIM_HYPHEN = /^-|-$/g;
+/**
+ * Create a URL-friendly slug from a string.
+ * Converts to lowercase, removes diacritics, and replaces spaces with hyphens.
+ * @param text - The text to slugify.
+ * @returns A URL-friendly slug.
+ */
+export function slugify(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFD")
+        .replaceAll(RE_DIACRITICS, "")
+        .replaceAll(RE_WHITESPACE, "-")
+        .replaceAll(RE_NON_SLUG, "")
+        .replaceAll(RE_MULTI_HYPHEN, "-")
+        .replaceAll(RE_TRIM_HYPHEN, "");
+}
+// Hoist formatters to avoid expensive re-initialization on every call
+const DATE_FORMATTER = new Intl.DateTimeFormat("ro-RO", {
+    month: "long",
+    day: "numeric",
+    year: "numeric",
+});
+const TIME_FORMATTER = new Intl.DateTimeFormat("ro-RO", {
+    hour: "numeric",
+    minute: "numeric",
+});
+/**
+ * Get a formatted date for a given date.
+ * @param date - The date to display.
+ * @returns The formatted date.
+ */
+export function getFormattedDate(date) {
+    return DATE_FORMATTER.format(parseISO(date));
+}
+/**
+ * Get a formatted time for a given date.
+ * @param date - The date to display.
+ * @returns The formatted time.
+ */
+export function getFormattedTime(date) {
+    return TIME_FORMATTER.format(parseISO(date));
+}
+/**
+ * Get a relative date for a given date.
+ * @param date - The date to display.
+ * @returns The relative date.
+ */
+export function getRelativeDate(date) {
+    return formatRelative(parseISO(date), new Date());
+}
+/**
+ * Get a display date for a given date.
+ * @param date - The date to display.
+ * @returns The display date.
+ */
+export function getDisplayDate(date) {
+    const parsedDate = parseISO(date);
+    const today = new Date();
+    const weekAgo = addDays(today, -7);
+    return parsedDate < weekAgo
+        ? formatRelative(parsedDate, today)
+        : getFormattedDate(date);
+}
+/** Fisher-Yates shuffle (returns new array, does not mutate). */
+export function shuffleArray(arr) {
+    const a = [...arr];
+    for (let i = a.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+}
+/** Throws if URL is not http/https. */
+export function validateMediaUrl(url) {
+    const trimmed = url.trim();
+    if (!trimmed)
+        throw new Error("Media URL is required");
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            throw new Error("Media URL must use http or https protocol");
+        }
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.includes("protocol"))
+            throw e;
+        throw new Error("Invalid media URL");
+    }
+}
+/** Returns validated URL or undefined if invalid (logs security warning). */
+export function sanitizeMediaUrl(url) {
+    if (!url)
+        return undefined;
+    try {
+        validateMediaUrl(url);
+        return url;
+    }
+    catch {
+        console.warn(`[Security] Blocked non-http media URL: ${url}`);
+        return undefined;
+    }
+}
+/**
+ * Parse **bold** markdown syntax into <strong> tags.
+ * Strips HTML first so no raw markup can pass through.
+ * Optimized with an early exit.
+ */
+export function parseBold(text) {
+    if (!text.includes("<") && !text.includes("**"))
+        return text;
+    return text
+        .replace(HTML_TAGS_RE, "")
+        .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+}
+/**
+ * A timestamp column as an ISO string. SQLite's CURRENT_TIMESTAMP and
+ * datetime('now') write "YYYY-MM-DD HH:MM:SS" in UTC, which `new Date()`
+ * reads as local time in V8 and refuses outright in Safari; an ISO string
+ * (JS-written created_at) passes through unchanged.
+ */
+export function toIsoTimestamp(value) {
+    return /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d+)?$/.test(value)
+        ? `${value.replace(" ", "T")}Z`
+        : value;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@orakl/shared",
+  "version": "0.1.0",
+  "description": "Orakl runtime helpers shared by the web client and the engine.",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robcsaszar/orakl.git",
+    "directory": "packages/shared"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@orakl/protocol": "0.1.0",
+    "date-fns": "^4.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.0",
+    "effect": "^3.22.1"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": "^3.22.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "generate:avatars": "node scripts/generate-avatars.mjs",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}