vanaheimr 0.4.0

package/lib/entityRegistryStorage.ts

@@ -0,0 +1,75 @@
+import {
+  type BlobLane,
+  isBlobStoreConfigured,
+  readEntityRegistryFromBlob,
+  writeEntityRegistryToBlob,
+} from "./db/studioBlobStore";
+import { randomUUID } from "crypto";
+import {
+  defaultEntityRegistry,
+  entityClassSlugFromName,
+  type EntityClassRegistry,
+} from "./entityTypes";
+
+function requireStudioId(studioId: string | undefined, op: string): asserts studioId is string {
+  if (!studioId?.trim()) {
+    throw new Error(`${op}: studioId is required.`);
+  }
+}
+
+function requireRemoteStorage(op: string): void {
+  if (!isBlobStoreConfigured()) {
+    throw new Error(`${op}: Remote storage is not configured.`);
+  }
+}
+
+export function normalizeEntityRegistry(registry: EntityClassRegistry): EntityClassRegistry {
+  const classes = Array.isArray(registry.classes) ? registry.classes : [];
+  const seen = new Set<string>();
+  const out = [];
+  for (const c of classes) {
+    const name = typeof c.name === "string" ? c.name.trim() : "";
+    if (!name) continue;
+    const slug = entityClassSlugFromName(name);
+    if (!slug || seen.has(slug)) continue;
+    seen.add(slug);
+    out.push({
+      id: typeof c.id === "string" && c.id.trim() ? c.id : randomUUID(),
+      slug,
+      name,
+      recordLabelSingular:
+        typeof c.recordLabelSingular === "string" && c.recordLabelSingular.trim()
+          ? c.recordLabelSingular.trim()
+          : undefined,
+    });
+  }
+  return { classes: out };
+}
+
+export async function readEntityRegistry(
+  studioId?: string,
+  lane: BlobLane = "draft"
+): Promise<EntityClassRegistry> {
+  requireStudioId(studioId, "readEntityRegistry");
+  requireRemoteStorage("readEntityRegistry");
+
+  try {
+    const fromBlob = await readEntityRegistryFromBlob(studioId, lane);
+    if (fromBlob) return normalizeEntityRegistry(fromBlob);
+  } catch (err) {
+    console.error("[entityRegistryStorage] read failed", err);
+    throw err;
+  }
+
+  return defaultEntityRegistry();
+}
+
+export async function writeEntityRegistry(
+  registry: EntityClassRegistry,
+  studioId?: string,
+  lane: BlobLane = "draft"
+): Promise<void> {
+  requireStudioId(studioId, "writeEntityRegistry");
+  requireRemoteStorage("writeEntityRegistry");
+  await writeEntityRegistryToBlob(studioId, normalizeEntityRegistry(registry), lane);
+}

package/lib/entityRuntimeBundle.ts

@@ -0,0 +1,31 @@
+import { readEntityClassStore } from "./entityClassStorage";
+import { readEntityRegistry } from "./entityRegistryStorage";
+import type { EntityClass } from "./entityTypes";
+import { buildAllyByPrimaryKey } from "./sdk/allyMap";
+import type { AllyTree } from "./sdk/allyMap";
+import type { SchemaField } from "./types";
+import type { BlobLane } from "./db/studioBlobStore";
+
+export type EntityRuntimeBundle = {
+  classes: EntityClass[];
+  entities: Record<string, AllyTree>;
+  playerSchemas: Record<string, SchemaField[]>;
+};
+
+/** Published (live) entity classes and PK-keyed rows for game runtime. */
+export async function fetchEntityRuntimeBundle(
+  studioId: string,
+  lane: BlobLane = "live"
+): Promise<EntityRuntimeBundle> {
+  const registry = await readEntityRegistry(studioId, lane);
+  const entities: Record<string, AllyTree> = {};
+  const playerSchemas: Record<string, SchemaField[]> = {};
+
+  for (const c of registry.classes) {
+    const store = await readEntityClassStore(studioId, c.slug, lane);
+    entities[c.slug] = buildAllyByPrimaryKey(store);
+    playerSchemas[c.slug] = store.playerSchema.fields;
+  }
+
+  return { classes: registry.classes, entities, playerSchemas };
+}

package/lib/entityTypes.ts

@@ -0,0 +1,60 @@
+/** One authorable entity class (e.g. allies, enemies, NPCs). */
+export type EntityClass = {
+  id: string;
+  /** Blob filename stem and analytics variant key (e.g. `allies`, `enemies`). */
+  slug: string;
+  /** Display name in the console (e.g. `Allies`). */
+  name: string;
+  /** Singular label for buttons (e.g. `ally`). Defaults from name. */
+  recordLabelSingular?: string;
+};
+
+export type EntityClassRegistry = {
+  classes: EntityClass[];
+};
+
+export const BUILTIN_ENTITY_SLUGS = ["allies", "enemies"] as const;
+export type BuiltinEntitySlug = (typeof BUILTIN_ENTITY_SLUGS)[number];
+
+export function defaultEntityRegistry(): EntityClassRegistry {
+  return { classes: [] };
+}
+
+/** Legacy localStorage / analytics keys mapped to class slugs. */
+export const LEGACY_VARIANT_TO_SLUG: Record<string, string> = {
+  ally: "allies",
+  enemy: "enemies",
+};
+
+const SLUG_RE = /^[a-z][a-z0-9_-]{0,47}$/;
+
+export function normalizeEntitySlug(raw: string): string | null {
+  const s = raw.trim().toLowerCase().replace(/\s+/g, "_");
+  if (!SLUG_RE.test(s)) return null;
+  return s;
+}
+
+/** Slug = lowercase display name with whitespace replaced by `_`. */
+export function slugFromDisplayName(name: string): string {
+  return name
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+}
+
+/** Validated slug derived from display name (for storage / APIs). */
+export function entityClassSlugFromName(name: string): string | null {
+  const slug = slugFromDisplayName(name);
+  if (!slug) return null;
+  return normalizeEntitySlug(slug);
+}
+
+export function recordLabelForClass(c: EntityClass): string {
+  return c.recordLabelSingular?.trim() || c.name.trim().toLowerCase().replace(/s$/, "") || "record";
+}
+
+export function pluralRecordsLabel(c: EntityClass): string {
+  return c.name.trim() || c.slug;
+}

package/lib/entry.ts

@@ -0,0 +1,20 @@
+export type { AllyProps } from "./sdk/allyProps";
+export type { AllyTree } from "./sdk/allyMap";
+export type { SchemaField } from "./types";
+export type { EntityClass, EntityClassRegistry } from "./entityTypes";
+export {
+  getEntityClasses,
+  getEntities,
+  getEntityPlayerSchema,
+  resolveEntityClassSlug,
+  getAllies,
+  getEnemies,
+  getVersion,
+  getAllyPlayerSchema,
+  getEnemyPlayerSchema,
+  getGameContentProvider,
+  setGameContentProvider,
+  setGameContentState,
+  type GameContentProvider,
+  type GameContentState,
+} from "./content/gameContent";

package/lib/equipmentStorage.ts

@@ -0,0 +1,68 @@
+import type { EquipmentStore } from "./equipmentTypes";
+import { emptyEquipmentStore } from "./equipmentTypes";
+import {
+  type BlobLane,
+  isBlobStoreConfigured,
+  migrateLegacyToLanes,
+  readEquipmentStoreFromBlob,
+  writeEquipmentStoreToBlob,
+} from "./db/studioBlobStore";
+
+function requireStudioId(studioId: string | undefined, op: string): asserts studioId is string {
+  if (!studioId?.trim()) {
+    throw new Error(`${op}: studioId is required (enemy data is only stored in remote object storage).`);
+  }
+}
+
+function requireRemoteStorage(op: string): void {
+  if (!isBlobStoreConfigured()) {
+    throw new Error(
+      `${op}: Remote storage is not configured. Set R2_ENDPOINT, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY, and R2_BUCKET_NAME — or BLOB_READ_WRITE_TOKEN — then restart the dev server or redeploy.`
+    );
+  }
+}
+
+export function normalizeEquipmentStore(store: EquipmentStore): EquipmentStore {
+  return {
+    schema: { fields: store.schema.fields },
+    playerSchema: { fields: store.playerSchema?.fields ?? [] },
+    equipment: Array.isArray(store.equipment) ? store.equipment : [],
+  };
+}
+
+export async function readEquipmentStore(studioId?: string, lane: BlobLane = "draft"): Promise<EquipmentStore> {
+  requireStudioId(studioId, "readEquipmentStore");
+  requireRemoteStorage("readEquipmentStore");
+
+  try {
+    let fromBlob = await readEquipmentStoreFromBlob(studioId, lane);
+
+    if (!fromBlob && lane === "draft") {
+      const migrated = await migrateLegacyToLanes(studioId);
+      if (migrated) fromBlob = await readEquipmentStoreFromBlob(studioId, lane);
+    }
+
+    if (fromBlob && fromBlob.schema && Array.isArray(fromBlob.schema.fields)) {
+      if (!Array.isArray(fromBlob.equipment)) {
+        return normalizeEquipmentStore({ ...fromBlob, equipment: [] });
+      }
+      return normalizeEquipmentStore(fromBlob);
+    }
+  } catch (err) {
+    console.error("[equipmentStorage] Remote read failed", err);
+    throw err;
+  }
+
+  return emptyEquipmentStore();
+}
+
+export async function writeEquipmentStore(
+  store: EquipmentStore,
+  studioId?: string,
+  lane: BlobLane = "draft"
+): Promise<void> {
+  requireStudioId(studioId, "writeEquipmentStore");
+  requireRemoteStorage("writeEquipmentStore");
+  const normalized = normalizeEquipmentStore(store);
+  await writeEquipmentStoreToBlob(studioId, normalized, lane);
+}

package/lib/equipmentTypes.ts

@@ -0,0 +1,14 @@
+import type { AllyRow, AllySchema } from "./types";
+
+/** Same row shape as allies; keyed lookup uses schema primary key. */
+export type EquipmentRow = AllyRow;
+
+export type EquipmentStore = {
+  schema: AllySchema;
+  playerSchema: AllySchema;
+  equipment: EquipmentRow[];
+};
+
+export function emptyEquipmentStore(): EquipmentStore {
+  return { schema: { fields: [] }, playerSchema: { fields: [] }, equipment: [] };
+}

package/lib/generated/ally.ts

@@ -0,0 +1,18 @@
+import { buildAllyByPrimaryKey, type AllyTree } from "../sdk/allyMap";
+import type { AllyProps } from "../sdk/allyProps";
+import { getPrimaryAllyProps } from "../sdk/allyProps";
+import { emptyStore } from "../types";
+
+/** Empty defaults at build time; studio/API/runtime provider supplies real data. */
+const store = emptyStore();
+
+/**
+ * Nested by the **first schema field** (primary key value), e.g. `Ally["Nurse"]["FullBody"]`.
+ * Otherwise `{}`.
+ */
+export const Ally: AllyTree = buildAllyByPrimaryKey(store);
+
+/**
+ * First row as a flat object (`id` + fields). For keyed access prefer `Ally["…"]`.
+ */
+export const ally: AllyProps = getPrimaryAllyProps(store) ?? { id: "" };

package/lib/generated/enemy.ts

@@ -0,0 +1,23 @@
+import type { EquipmentStore } from "../equipmentTypes";
+import { emptyEquipmentStore } from "../equipmentTypes";
+import { buildAllyByPrimaryKey, type AllyTree } from "../sdk/allyMap";
+import type { AllyProps } from "../sdk/allyProps";
+import { getPrimaryAllyProps } from "../sdk/allyProps";
+import type { AllyStore } from "../types";
+
+/** Empty defaults at build time; studio/API/runtime provider supplies real data. */
+const store: EquipmentStore = emptyEquipmentStore();
+
+const asAllyShape: AllyStore = {
+  schema: store.schema,
+  playerSchema: store.playerSchema,
+  allies: store.equipment,
+};
+
+/**
+ * Enemy rows keyed by primary-key field value.
+ */
+export const Enemies: AllyTree = buildAllyByPrimaryKey(asAllyShape);
+
+/** First enemy row as flat props. */
+export const enemyPrimary: AllyProps = getPrimaryAllyProps(asAllyShape) ?? { id: "" };

package/lib/sdk/allyMap.ts

@@ -0,0 +1,37 @@
+import type { AllySchema, AllyStore } from "../types";
+import { toAllyProps, type AllyProps } from "./allyProps";
+
+/** `Ally["Nurse"]["FullBody"]` — outer key from the **first** schema field’s value; inner keys are all fields (+ `id`). */
+export type AllyTree = Record<string, AllyProps>;
+
+/** First non-empty field key in schema order — used as outer `Ally["…"]` key. */
+export function getPrimaryKeyFieldKey(schema: AllySchema): string | null {
+  for (const f of schema.fields) {
+    const k = f.key.trim();
+    if (k) return k;
+  }
+  return null;
+}
+
+/**
+ * Nested lookup keyed by the **first** schema field’s value (the primary key).
+ * Duplicates overwrite (last wins). Empty primary values fall back to row `id`.
+ */
+export function buildAllyByPrimaryKey(store: AllyStore): AllyTree {
+  const pk = getPrimaryKeyFieldKey(store.schema);
+  if (!pk) return {};
+
+  const out: AllyTree = {};
+  for (const row of store.allies) {
+    const raw = row.values[pk];
+    const label =
+      raw != null && String(raw).trim() !== "" ? String(raw).trim() : row.id;
+    out[label] = toAllyProps(row);
+  }
+  return out;
+}
+
+/** True when there is at least one schema field with a non-empty key (PK defined). */
+export function isPrimaryKeyConfigured(schema: AllySchema): boolean {
+  return getPrimaryKeyFieldKey(schema) !== null;
+}

package/lib/sdk/allyProps.ts

@@ -0,0 +1,72 @@
+import type { AllyRow, AllySchema, AllyStore } from "../types";
+
+/** Flat view: `id` plus every schema value keyed by field name (use `ally["Full Body"]` when keys contain spaces). */
+export type AllyProps = { id: string } & Record<string, string | number | boolean | null>;
+
+function schemaKeys(schema: AllySchema): string[] {
+  const keys: string[] = [];
+  for (const f of schema.fields) {
+    const k = f.key.trim();
+    if (k) keys.push(k);
+  }
+  return keys;
+}
+
+/** Merge ally row values into one object with `id` for ergonomic access. */
+export function toAllyProps(ally: AllyRow): AllyProps {
+  return { id: ally.id, ...ally.values };
+}
+
+/** First ally in the store as a flat object, or `null` if there are none. */
+export function getPrimaryAllyProps(store: AllyStore): AllyProps | null {
+  const first = store.allies[0];
+  if (!first) return null;
+  return toAllyProps(first);
+}
+
+/** Ally at index (default 0), or `null`. */
+export function getAllyPropsAt(store: AllyStore, index: number): AllyProps | null {
+  const a = store.allies[index];
+  if (!a) return null;
+  return toAllyProps(a);
+}
+
+/** Find by id. */
+export function getAllyPropsById(store: AllyStore, id: string): AllyProps | null {
+  const a = store.allies.find((x) => x.id === id);
+  if (!a) return null;
+  return toAllyProps(a);
+}
+
+/** All allies as flat props (same order as `store.allies`). */
+export function getAllAllyProps(store: AllyStore): AllyProps[] {
+  return store.allies.map(toAllyProps);
+}
+
+/**
+ * Typed getters from schema: returns an object whose keys match schema field keys and values
+ * come from `ally`. Missing keys use schema defaults (0 / "" / null).
+ */
+export function alignAllyToSchema(ally: AllyRow, schema: AllySchema): AllyProps {
+  const out: AllyProps = { id: ally.id };
+  for (const f of schema.fields) {
+    const k = f.key.trim();
+    if (!k) continue;
+    if (k in ally.values) {
+      out[k] = ally.values[k] as string | number | boolean | null;
+    } else {
+      out[k] = defaultForFieldType(f.type);
+    }
+  }
+  return out;
+}
+
+function defaultForFieldType(t: "int" | "string" | "image" | "bool"): number | string | boolean | null {
+  if (t === "bool") return false;
+  if (t === "int") return 0;
+  if (t === "string") return "";
+  return null;
+}
+
+/** Keys currently defined in the schema (trimmed, non-empty). */
+export { schemaKeys };

package/lib/sdk/index.ts

@@ -0,0 +1,17 @@
+export {
+  alignAllyToSchema,
+  getAllyPropsAt,
+  getAllyPropsById,
+  getAllAllyProps,
+  getPrimaryAllyProps,
+  schemaKeys,
+  toAllyProps,
+  type AllyProps,
+} from "./allyProps";
+export {
+  buildAllyByPrimaryKey,
+  getPrimaryKeyFieldKey,
+  isPrimaryKeyConfigured,
+  type AllyTree,
+} from "./allyMap";
+export { normalizeStore, parseStore } from "./parseStore";

package/lib/sdk/node.ts

@@ -0,0 +1,11 @@
+import { readFileSync } from "fs";
+import path from "path";
+import type { AllyStore } from "../types";
+import { parseStore } from "./parseStore";
+
+/** Load store JSON from disk (Node.js). Path is resolved relative to `cwd` if not absolute. */
+export function loadStoreFromFileSync(filePath: string): AllyStore {
+  const abs = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+  const raw = readFileSync(abs, "utf-8");
+  return parseStore(raw);
+}

package/lib/sdk/parseStore.ts

@@ -0,0 +1,31 @@
+import type { AllyStore } from "../types";
+import { emptyStore } from "../types";
+
+/** Strip legacy fields (e.g. old `primaryKeyField`); schema is ordered fields only — first field is the PK for lookups. */
+export function normalizeStore(store: AllyStore): AllyStore {
+  return {
+    schema: { fields: store.schema.fields },
+    playerSchema: { fields: store.playerSchema?.fields ?? [] },
+    allies: Array.isArray(store.allies) ? store.allies : [],
+  };
+}
+
+/** Parse JSON text or an already-parsed object into a normalized store. */
+export function parseStore(input: string | unknown): AllyStore {
+  let parsed: unknown;
+  if (typeof input === "string") {
+    try {
+      parsed = JSON.parse(input) as unknown;
+    } catch {
+      return emptyStore();
+    }
+  } else {
+    parsed = input;
+  }
+
+  if (!parsed || typeof parsed !== "object") return emptyStore();
+  const o = parsed as Partial<AllyStore>;
+  if (!o.schema || !Array.isArray(o.schema.fields)) return emptyStore();
+  if (!Array.isArray(o.allies)) return normalizeStore({ ...o, allies: [] } as AllyStore);
+  return normalizeStore(o as AllyStore);
+}

package/lib/storage.ts

@@ -0,0 +1,57 @@
+import {
+  type BlobLane,
+  isBlobStoreConfigured,
+  migrateLegacyToLanes,
+  readAllyStoreFromBlob,
+  writeAllyStoreToBlob,
+} from "./db/studioBlobStore";
+import { normalizeStore } from "./sdk/parseStore";
+import type { AllyStore } from "./types";
+import { emptyStore } from "./types";
+
+function requireStudioId(studioId: string | undefined, op: string): asserts studioId is string {
+  if (!studioId?.trim()) {
+    throw new Error(`${op}: studioId is required (ally data is only stored in remote object storage).`);
+  }
+}
+
+function requireRemoteStorage(op: string): void {
+  if (!isBlobStoreConfigured()) {
+    throw new Error(
+      `${op}: Remote storage is not configured. Set R2_ENDPOINT, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY, and R2_BUCKET_NAME — or BLOB_READ_WRITE_TOKEN — then restart the dev server or redeploy.`
+    );
+  }
+}
+
+export async function readStore(studioId?: string, lane: BlobLane = "draft"): Promise<AllyStore> {
+  requireStudioId(studioId, "readStore");
+  requireRemoteStorage("readStore");
+
+  try {
+    let fromBlob = await readAllyStoreFromBlob(studioId, lane);
+
+    if (!fromBlob && lane === "draft") {
+      const migrated = await migrateLegacyToLanes(studioId);
+      if (migrated) fromBlob = await readAllyStoreFromBlob(studioId, lane);
+    }
+
+    if (fromBlob && fromBlob.schema && Array.isArray(fromBlob.schema.fields)) {
+      if (!Array.isArray(fromBlob.allies)) {
+        return normalizeStore({ ...fromBlob, allies: [] });
+      }
+      return normalizeStore(fromBlob);
+    }
+  } catch (err) {
+    console.error("[storage] Remote read failed", err);
+    throw err;
+  }
+
+  return emptyStore();
+}
+
+export async function writeStore(store: AllyStore, studioId?: string, lane: BlobLane = "draft"): Promise<void> {
+  requireStudioId(studioId, "writeStore");
+  requireRemoteStorage("writeStore");
+  const normalized = normalizeStore(store);
+  await writeAllyStoreToBlob(studioId, normalized, lane);
+}

package/lib/supabase/admin.ts

@@ -0,0 +1,28 @@
+import { createClient, type SupabaseClient } from "@supabase/supabase-js";
+
+let cached: SupabaseClient | null | undefined;
+
+/**
+ * Server-only client (bypasses RLS). Returns null if not configured.
+ *
+ * Prefer Supabase secret keys (`sb_secret_...`) in `SUPABASE_SECRET_KEY` (see Supabase docs:
+ * "Understanding API keys"). Legacy JWT `service_role` in `SUPABASE_SERVICE_ROLE_KEY` still works
+ * during Supabase's migration window.
+ */
+export function getSupabaseAdmin(): SupabaseClient | null {
+  if (cached !== undefined) return cached;
+
+  const url = process.env.NEXT_PUBLIC_SUPABASE_URL?.trim();
+  const key =
+    process.env.SUPABASE_SECRET_KEY?.trim() ||
+    process.env.SUPABASE_SERVICE_ROLE_KEY?.trim();
+  if (!url || !key) {
+    cached = null;
+    return null;
+  }
+
+  cached = createClient(url, key, {
+    auth: { persistSession: false, autoRefreshToken: false },
+  });
+  return cached;
+}

package/lib/supabase/client.ts

@@ -0,0 +1,8 @@
+import { createBrowserClient } from "@supabase/ssr";
+
+export function createClient() {
+  return createBrowserClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!
+  );
+}

package/lib/supabase/middleware.ts

@@ -0,0 +1,50 @@
+import { createServerClient } from "@supabase/ssr";
+import { NextResponse, type NextRequest } from "next/server";
+
+export async function updateSession(request: NextRequest) {
+  let supabaseResponse = NextResponse.next({ request });
+
+  const supabase = createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return request.cookies.getAll();
+        },
+        setAll(cookiesToSet) {
+          for (const { name, value } of cookiesToSet) {
+            request.cookies.set(name, value);
+          }
+          supabaseResponse = NextResponse.next({ request });
+          for (const { name, value, options } of cookiesToSet) {
+            supabaseResponse.cookies.set(name, value, options);
+          }
+        },
+      },
+    }
+  );
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  // Redirect unauthenticated users away from protected routes
+  const path = request.nextUrl.pathname;
+  const isPublic =
+    path === "/" || path === "/login" || path.startsWith("/api/") || path.startsWith("/auth/");
+  if (!user && !isPublic) {
+    const url = request.nextUrl.clone();
+    url.pathname = "/login";
+    return NextResponse.redirect(url);
+  }
+
+  // Redirect authenticated users away from login
+  if (user && request.nextUrl.pathname === "/login") {
+    const url = request.nextUrl.clone();
+    url.pathname = "/";
+    return NextResponse.redirect(url);
+  }
+
+  return supabaseResponse;
+}

package/lib/supabase/server.ts

@@ -0,0 +1,28 @@
+import { createServerClient } from "@supabase/ssr";
+import { cookies } from "next/headers";
+
+export async function createClient() {
+  const cookieStore = await cookies();
+
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return cookieStore.getAll();
+        },
+        setAll(cookiesToSet) {
+          try {
+            for (const { name, value, options } of cookiesToSet) {
+              cookieStore.set(name, value, options);
+            }
+          } catch {
+            // setAll is called from a Server Component where cookies can't be
+            // set — safe to ignore; the middleware will refresh the session.
+          }
+        },
+      },
+    }
+  );
+}