vanaheimr 0.4.0

package/lib/clientImageToDataUrl.ts

@@ -0,0 +1,141 @@
+/**
+ * Vercel caps serverless request bodies around ~4.5MB; base64 adds ~37%.
+ * Compress in the browser so PUT /api/data stays under the limit.
+ *
+ * Tuned for common mobile splash / character art at **1024×1536** (portrait):
+ * we try lowering quality at **full pixel dimensions** before downscaling.
+ */
+
+const TARGET_BINARY_BYTES = 2_200_000;
+/** Skip canvas for small files — base64 payload stays safe with rest of JSON. */
+const DIRECT_READ_MAX_BYTES = 450 * 1024;
+
+/** Never upsample; cap longest edge only if asset is enormous. */
+const ABSOLUTE_MAX_LONG_EDGE = 2048;
+
+const QUALITIES = [
+  0.92, 0.88, 0.85, 0.8, 0.74, 0.68, 0.62, 0.55, 0.48, 0.42,
+] as const;
+
+function fileToRawDataUrl(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const s = reader.result;
+      if (typeof s === "string") resolve(s);
+      else reject(new Error("Read failed"));
+    };
+    reader.onerror = () => reject(reader.error);
+    reader.readAsDataURL(file);
+  });
+}
+
+function blobToDataUrl(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const s = reader.result;
+      if (typeof s === "string") resolve(s);
+      else reject(new Error("Read failed"));
+    };
+    reader.onerror = () => reject(reader.error);
+    reader.readAsDataURL(blob);
+  });
+}
+
+function canvasToBlob(
+  canvas: HTMLCanvasElement,
+  type: string,
+  quality?: number
+): Promise<Blob | null> {
+  return new Promise((resolve) => {
+    canvas.toBlob((b) => resolve(b), type, quality);
+  });
+}
+
+function layoutToCanvas(
+  bmp: ImageBitmap,
+  canvas: HTMLCanvasElement,
+  ctx: CanvasRenderingContext2D,
+  maxLongEdge: number
+) {
+  let w = bmp.width;
+  let h = bmp.height;
+  const longEdge = Math.max(w, h, 1);
+  const scale = Math.min(1, maxLongEdge / longEdge);
+  w = Math.max(1, Math.round(w * scale));
+  h = Math.max(1, Math.round(h * scale));
+  canvas.width = w;
+  canvas.height = h;
+  ctx.clearRect(0, 0, w, h);
+  ctx.drawImage(bmp, 0, 0, w, h);
+  return { w, h };
+}
+
+async function encodeUnderBudget(
+  canvas: HTMLCanvasElement
+): Promise<Blob | null> {
+  for (const q of QUALITIES) {
+    for (const mime of ["image/webp", "image/jpeg"] as const) {
+      const blob = await canvasToBlob(canvas, mime, q);
+      if (blob && blob.size > 0 && blob.size <= TARGET_BINARY_BYTES) {
+        return blob;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Turns an image file into a data URL for embedded studio JSON (mobile-friendly).
+ */
+export async function compressImageFileToDataUrl(file: File): Promise<{
+  dataUrl: string;
+  compressed: boolean;
+}> {
+  if (!file.type.startsWith("image/")) {
+    throw new Error("Not an image file");
+  }
+
+  if (file.size <= DIRECT_READ_MAX_BYTES) {
+    return { dataUrl: await fileToRawDataUrl(file), compressed: false };
+  }
+
+  const bmp = await createImageBitmap(file);
+
+  let maxLongEdge = Math.min(
+    ABSOLUTE_MAX_LONG_EDGE,
+    Math.max(bmp.width, bmp.height)
+  );
+
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    bmp.close();
+    return { dataUrl: await fileToRawDataUrl(file), compressed: false };
+  }
+
+  try {
+    // 1024×1536 → longest edge 1536: first pass keeps full pixels, sweeps quality only.
+    for (let shrink = 0; shrink < 18; shrink++) {
+      layoutToCanvas(bmp, canvas, ctx, maxLongEdge);
+      const blob = await encodeUnderBudget(canvas);
+      if (blob) {
+        return { dataUrl: await blobToDataUrl(blob), compressed: true };
+      }
+      maxLongEdge = Math.max(360, Math.floor(maxLongEdge * 0.9));
+    }
+
+    canvas.width = Math.max(1, Math.min(512, bmp.width));
+    canvas.height = Math.max(1, Math.round((bmp.height / bmp.width) * canvas.width));
+    ctx.drawImage(bmp, 0, 0, canvas.width, canvas.height);
+    const fallback = await canvasToBlob(canvas, "image/jpeg", 0.38);
+    if (fallback && fallback.size > 0) {
+      return { dataUrl: await blobToDataUrl(fallback), compressed: true };
+    }
+
+    return { dataUrl: await fileToRawDataUrl(file), compressed: false };
+  } finally {
+    bmp.close();
+  }
+}

package/lib/content/gameContent.ts

@@ -0,0 +1,106 @@
+import { Ally as bundleAlly } from "../generated/ally";
+import { Enemies as bundleEnemies } from "../generated/enemy";
+import type { EntityClass } from "../entityTypes";
+import type { AllyTree } from "../sdk/allyMap";
+import type { SchemaField } from "../types";
+
+/**
+ * Inject studio entity data (from Tools / your API). Until set, built-in bundles are empty trees.
+ */
+export type GameContentProvider = {
+  getEntityClasses(): EntityClass[];
+  /** Map **primary-key string -> row** for a class slug. */
+  getEntities(classSlug: string): AllyTree;
+  getEntityPlayerSchema(classSlug: string): SchemaField[];
+  getVersion?(): string | null;
+  /** @deprecated Use `getEntities("allies")`. */
+  getAllies(): AllyTree;
+  /** @deprecated Use `getEntities("enemies")`. */
+  getEnemies(): AllyTree;
+  /** @deprecated Use `getEntityPlayerSchema("allies")`. */
+  getAllyPlayerSchema?(): SchemaField[];
+  /** @deprecated Use `getEntityPlayerSchema("enemies")`. */
+  getEnemyPlayerSchema?(): SchemaField[];
+};
+
+export type GameContentState = {
+  classes: EntityClass[];
+  entities: Record<string, AllyTree>;
+  playerSchemas: Record<string, SchemaField[]>;
+  version: string | null;
+};
+
+const emptyTree: AllyTree = {};
+
+const staticProvider: GameContentProvider = {
+  getEntityClasses: () => [],
+  getEntities: (slug) => {
+    if (slug === "allies") return bundleAlly;
+    if (slug === "enemies") return bundleEnemies;
+    return emptyTree;
+  },
+  getEntityPlayerSchema: () => [],
+  getAllies: () => bundleAlly,
+  getEnemies: () => bundleEnemies,
+};
+
+let activeProvider: GameContentProvider = staticProvider;
+
+export function setGameContentProvider(provider: GameContentProvider): void {
+  activeProvider = provider;
+}
+
+export function setGameContentState(state: GameContentState): void {
+  setGameContentProvider({
+    getEntityClasses: () => state.classes,
+    getEntities: (slug) => state.entities[slug] ?? emptyTree,
+    getEntityPlayerSchema: (slug) => state.playerSchemas[slug] ?? [],
+    getVersion: () => state.version,
+    getAllies: () => state.entities.allies ?? emptyTree,
+    getEnemies: () => state.entities.enemies ?? emptyTree,
+    getAllyPlayerSchema: () => state.playerSchemas.allies ?? [],
+    getEnemyPlayerSchema: () => state.playerSchemas.enemies ?? [],
+  });
+}
+
+export function getGameContentProvider(): GameContentProvider {
+  return activeProvider;
+}
+
+export function getEntityClasses(): EntityClass[] {
+  return activeProvider.getEntityClasses();
+}
+
+export function getEntities(classSlug: string): AllyTree {
+  return activeProvider.getEntities(classSlug);
+}
+
+export function getEntityPlayerSchema(classSlug: string): SchemaField[] {
+  return activeProvider.getEntityPlayerSchema(classSlug);
+}
+
+/** Returns the slug if a class with that slug exists, else null. */
+export function resolveEntityClassSlug(slug: string): string | null {
+  const normalized = slug.trim().toLowerCase();
+  return getEntityClasses().some((c) => c.slug === normalized) ? normalized : null;
+}
+
+export function getAllies(): AllyTree {
+  return activeProvider.getAllies();
+}
+
+export function getEnemies(): AllyTree {
+  return activeProvider.getEnemies();
+}
+
+export function getVersion(): string | null {
+  return activeProvider.getVersion?.() ?? null;
+}
+
+export function getAllyPlayerSchema(): SchemaField[] {
+  return activeProvider.getAllyPlayerSchema?.() ?? activeProvider.getEntityPlayerSchema("allies");
+}
+
+export function getEnemyPlayerSchema(): SchemaField[] {
+  return activeProvider.getEnemyPlayerSchema?.() ?? activeProvider.getEntityPlayerSchema("enemies");
+}

package/lib/corsPublicRead.ts

@@ -0,0 +1,19 @@
+import { NextResponse } from "next/server";
+
+/** Lets another deployed site (your Game) fetch GET /api/data and GET /api/enemy from the browser. */
+export function withPublicReadCors(response: NextResponse): NextResponse {
+  response.headers.set("Access-Control-Allow-Origin", "*");
+  return response;
+}
+
+export function publicReadPreflight(): NextResponse {
+  return new NextResponse(null, {
+    status: 204,
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type",
+      "Access-Control-Max-Age": "86400",
+    },
+  });
+}

package/lib/db/studioBlobStore.ts

@@ -0,0 +1,286 @@
+import {
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { list, put } from "@vercel/blob";
+import type { EntityClassRegistry } from "../entityTypes";
+import type { AllyStore } from "../types";
+import type { EquipmentStore } from "../equipmentTypes";
+
+const ENTITY_REGISTRY_BLOB = "entity-classes";
+
+/**
+ * Studio JSON assets (allies / enemies, draft & live lanes).
+ *
+ * **Cloudflare R2** (preferred when set): S3-compatible API via `@aws-sdk/client-s3`.
+ * - `R2_ENDPOINT` — S3 API URL only: `https://<accountid>.r2.cloudflarestorage.com` (not the public `*.r2.dev` URL)
+ * - `R2_ACCESS_KEY_ID` / `R2_SECRET_ACCESS_KEY` — R2 API token credentials
+ * - `R2_BUCKET_NAME` — bucket name
+ *
+ * **Vercel Blob** (fallback): used only when R2 vars are not all set.
+ * - `BLOB_READ_WRITE_TOKEN`
+ */
+
+export type BlobLane = "draft" | "live";
+
+function pathnameFor(studioId: string, id: string, lane: BlobLane): string {
+  return `studios/${studioId}/${lane}/${id}.json`;
+}
+
+/** Cloudflare R2 (S3-compatible) when all vars are set. Takes precedence over Vercel Blob. */
+export function isR2Configured(): boolean {
+  return Boolean(
+    process.env.R2_ENDPOINT?.trim() &&
+      process.env.R2_ACCESS_KEY_ID?.trim() &&
+      process.env.R2_SECRET_ACCESS_KEY?.trim() &&
+      process.env.R2_BUCKET_NAME?.trim()
+  );
+}
+
+function isVercelBlobConfigured(): boolean {
+  return Boolean(process.env.BLOB_READ_WRITE_TOKEN?.trim());
+}
+
+/** Remote object storage for studio JSON (R2 preferred, else legacy Vercel Blob). */
+export function isBlobStoreConfigured(): boolean {
+  return isR2Configured() || isVercelBlobConfigured();
+}
+
+let r2Client: S3Client | null = null;
+
+function normalizeR2Endpoint(raw: string): string {
+  let t = raw.trim();
+  while (t.endsWith("/")) t = t.slice(0, -1);
+  if (t.startsWith("http://") || t.startsWith("https://")) return t;
+  return `https://${t}`;
+}
+
+function getR2Client(): S3Client {
+  if (r2Client) return r2Client;
+  const endpoint = normalizeR2Endpoint(process.env.R2_ENDPOINT!);
+  r2Client = new S3Client({
+    region: "auto",
+    endpoint,
+    /** R2 S3 API expects path-style URLs; avoids signing/host issues on some deployments. */
+    forcePathStyle: true,
+    credentials: {
+      accessKeyId: process.env.R2_ACCESS_KEY_ID!.trim(),
+      secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!.trim(),
+    },
+  });
+  return r2Client;
+}
+
+function r2Bucket(): string {
+  return process.env.R2_BUCKET_NAME!.trim();
+}
+
+function isR2NotFound(err: unknown): boolean {
+  if (!err || typeof err !== "object") return false;
+  const e = err as { name?: string; $metadata?: { httpStatusCode?: number } };
+  return e.name === "NoSuchKey" || e.$metadata?.httpStatusCode === 404;
+}
+
+async function r2GetJson(key: string): Promise<unknown | null> {
+  try {
+    const out = await getR2Client().send(
+      new GetObjectCommand({ Bucket: r2Bucket(), Key: key })
+    );
+    const text = await out.Body?.transformToString();
+    if (text == null) return null;
+    try {
+      return JSON.parse(text) as unknown;
+    } catch {
+      return null;
+    }
+  } catch (err) {
+    if (isR2NotFound(err)) return null;
+    throw err;
+  }
+}
+
+async function r2PutJson(key: string, payload: unknown): Promise<void> {
+  await getR2Client().send(
+    new PutObjectCommand({
+      Bucket: r2Bucket(),
+      Key: key,
+      Body: JSON.stringify(payload),
+      ContentType: "application/json",
+    })
+  );
+}
+
+async function readBlobJson(studioId: string, id: string, lane: BlobLane): Promise<unknown | null> {
+  const pathname = pathnameFor(studioId, id, lane);
+
+  if (isR2Configured()) {
+    return r2GetJson(pathname);
+  }
+
+  const token = process.env.BLOB_READ_WRITE_TOKEN?.trim();
+  if (!token) return null;
+
+  const prefix = `studios/${studioId}/${lane}/`;
+  const { blobs } = await list({ prefix, token, limit: 100 });
+
+  const blob = blobs.find((b) => b.pathname === pathname);
+  if (!blob?.url) return null;
+
+  const res = await fetch(blob.url);
+  if (!res.ok) return null;
+  try {
+    return JSON.parse(await res.text()) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeStudioBlob(
+  studioId: string,
+  id: string,
+  lane: BlobLane,
+  payload: unknown
+): Promise<void> {
+  const pathname = pathnameFor(studioId, id, lane);
+
+  if (isR2Configured()) {
+    await r2PutJson(pathname, payload);
+    return;
+  }
+
+  const token = process.env.BLOB_READ_WRITE_TOKEN?.trim();
+  if (!token) return;
+
+  await put(pathname, JSON.stringify(payload), {
+    access: "public",
+    token,
+    addRandomSuffix: false,
+    contentType: "application/json",
+  });
+}
+
+export async function readEntityRegistryFromBlob(
+  studioId: string,
+  lane: BlobLane = "draft"
+): Promise<EntityClassRegistry | null> {
+  const raw = await readBlobJson(studioId, ENTITY_REGISTRY_BLOB, lane);
+  if (raw == null || typeof raw !== "object") return null;
+  return raw as EntityClassRegistry;
+}
+
+export async function writeEntityRegistryToBlob(
+  studioId: string,
+  registry: EntityClassRegistry,
+  lane: BlobLane = "draft"
+): Promise<void> {
+  await writeStudioBlob(studioId, ENTITY_REGISTRY_BLOB, lane, registry);
+}
+
+export async function readEntityClassFromBlob(
+  studioId: string,
+  slug: string,
+  lane: BlobLane = "draft"
+): Promise<unknown | null> {
+  return readBlobJson(studioId, slug, lane);
+}
+
+export async function writeEntityClassToBlob(
+  studioId: string,
+  slug: string,
+  lane: BlobLane,
+  payload: unknown
+): Promise<void> {
+  await writeStudioBlob(studioId, slug, lane, payload);
+}
+
+export async function readAllyStoreFromBlob(studioId: string, lane: BlobLane = "draft"): Promise<AllyStore | null> {
+  const raw = await readEntityClassFromBlob(studioId, "allies", lane);
+  if (raw == null || typeof raw !== "object") return null;
+  return raw as AllyStore;
+}
+
+export async function writeAllyStoreToBlob(studioId: string, store: AllyStore, lane: BlobLane = "draft"): Promise<void> {
+  await writeEntityClassToBlob(studioId, "allies", lane, store);
+}
+
+export async function readEquipmentStoreFromBlob(
+  studioId: string,
+  lane: BlobLane = "draft"
+): Promise<EquipmentStore | null> {
+  const raw = await readEntityClassFromBlob(studioId, "enemies", lane);
+  if (raw == null || typeof raw !== "object") return null;
+  return raw as EquipmentStore;
+}
+
+export async function writeEquipmentStoreToBlob(
+  studioId: string,
+  store: EquipmentStore,
+  lane: BlobLane = "draft"
+): Promise<void> {
+  await writeEntityClassToBlob(studioId, "enemies", lane, store);
+}
+
+/** Copy entity registry and every class blob from draft to live. */
+export async function copyDraftToLive(studioId: string): Promise<void> {
+  const { defaultEntityRegistry } = await import("../entityTypes");
+  const registry =
+    (await readEntityRegistryFromBlob(studioId, "draft")) ?? defaultEntityRegistry();
+  await writeEntityRegistryToBlob(studioId, registry, "live");
+
+  for (const c of registry.classes) {
+    const raw = await readEntityClassFromBlob(studioId, c.slug, "draft");
+    if (raw) await writeEntityClassToBlob(studioId, c.slug, "live", raw);
+  }
+}
+
+/**
+ * Read from the old flat path (studios/{studioId}/{id}.json) used before
+ * the draft/live lane system. Returns null if nothing exists there.
+ */
+async function readLegacyBlobJson(studioId: string, id: string): Promise<unknown | null> {
+  const pathname = `studios/${studioId}/${id}.json`;
+
+  if (isR2Configured()) {
+    return r2GetJson(pathname);
+  }
+
+  const token = process.env.BLOB_READ_WRITE_TOKEN?.trim();
+  if (!token) return null;
+
+  const prefix = `studios/${studioId}/`;
+  const { blobs } = await list({ prefix, token, limit: 100 });
+
+  const blob = blobs.find((b) => b.pathname === pathname);
+  if (!blob?.url) return null;
+
+  const res = await fetch(blob.url);
+  if (!res.ok) return null;
+  try {
+    return JSON.parse(await res.text()) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Migrate data from the old flat path to both draft and live lanes.
+ * Called once when draft lane is empty on first access after the upgrade.
+ */
+export async function migrateLegacyToLanes(studioId: string): Promise<boolean> {
+  const legacyAllies = await readLegacyBlobJson(studioId, "allies");
+  const legacyEnemies = await readLegacyBlobJson(studioId, "enemies");
+
+  if (!legacyAllies && !legacyEnemies) return false;
+
+  if (legacyAllies) {
+    await writeStudioBlob(studioId, "allies", "draft", legacyAllies);
+    await writeStudioBlob(studioId, "allies", "live", legacyAllies);
+  }
+  if (legacyEnemies) {
+    await writeStudioBlob(studioId, "enemies", "draft", legacyEnemies);
+    await writeStudioBlob(studioId, "enemies", "live", legacyEnemies);
+  }
+
+  return true;
+}

package/lib/db/studioLookup.ts

@@ -0,0 +1,39 @@
+import { createClient } from "@/lib/supabase/server";
+
+export type StudioRow = {
+  id: string;
+  owner_id: string;
+  name: string;
+  read_key: string;
+  current_version: string;
+};
+
+/** Look up a studio by its public read key. Returns null if not found. */
+export async function getStudioByReadKey(readKey: string): Promise<StudioRow | null> {
+  const supabase = await createClient();
+  const { data, error } = await supabase
+    .from("studios")
+    .select("id, owner_id, name, read_key, current_version")
+    .eq("read_key", readKey)
+    .maybeSingle();
+
+  if (error || !data) return null;
+  return data as StudioRow;
+}
+
+/** Look up the first studio owned by the currently authenticated user. */
+export async function getStudioForCurrentUser(): Promise<StudioRow | null> {
+  const supabase = await createClient();
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) return null;
+
+  const { data, error } = await supabase
+    .from("studios")
+    .select("id, owner_id, name, read_key, current_version")
+    .eq("owner_id", user.id)
+    .limit(1)
+    .maybeSingle();
+
+  if (error || !data) return null;
+  return data as StudioRow;
+}

package/lib/enemyTypes.ts

@@ -0,0 +1,13 @@
+import type { AllyRow, AllySchema } from "./types";
+
+export type EnemyRow = AllyRow;
+
+export type EnemyStore = {
+  schema: AllySchema;
+  playerSchema: AllySchema;
+  enemies: EnemyRow[];
+};
+
+export function emptyEnemyStore(): EnemyStore {
+  return { schema: { fields: [] }, playerSchema: { fields: [] }, enemies: [] };
+}

package/lib/entityClassStorage.ts

@@ -0,0 +1,89 @@
+import {
+  type BlobLane,
+  isBlobStoreConfigured,
+  migrateLegacyToLanes,
+  readEntityClassFromBlob,
+  writeEntityClassToBlob,
+} from "./db/studioBlobStore";
+import { normalizeStore } from "./sdk/parseStore";
+import type { AllyRow, 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.`);
+  }
+}
+
+function requireRemoteStorage(op: string): void {
+  if (!isBlobStoreConfigured()) {
+    throw new Error(`${op}: Remote storage is not configured.`);
+  }
+}
+
+function rowsFromBlobPayload(raw: Record<string, unknown>, slug: string): AllyRow[] {
+  if (slug === "allies" && Array.isArray(raw.allies)) return raw.allies as AllyRow[];
+  if (slug === "enemies" && Array.isArray(raw.equipment)) return raw.equipment as AllyRow[];
+  if (Array.isArray(raw.rows)) return raw.rows as AllyRow[];
+  if (Array.isArray(raw.entities)) return raw.entities as AllyRow[];
+  return [];
+}
+
+function blobPayloadFromStore(store: AllyStore, slug: string): Record<string, unknown> {
+  const base = {
+    schema: store.schema,
+    playerSchema: store.playerSchema,
+  };
+  if (slug === "allies") return { ...base, allies: store.allies };
+  if (slug === "enemies") return { ...base, equipment: store.allies };
+  return { ...base, rows: store.allies };
+}
+
+export async function readEntityClassStore(
+  studioId: string,
+  slug: string,
+  lane: BlobLane = "draft"
+): Promise<AllyStore> {
+  requireStudioId(studioId, "readEntityClassStore");
+  requireRemoteStorage("readEntityClassStore");
+
+  try {
+    let raw = await readEntityClassFromBlob(studioId, slug, lane);
+
+    if (!raw && lane === "draft" && (slug === "allies" || slug === "enemies")) {
+      const migrated = await migrateLegacyToLanes(studioId);
+      if (migrated) raw = await readEntityClassFromBlob(studioId, slug, lane);
+    }
+
+    if (raw && typeof raw === "object") {
+      const o = raw as Record<string, unknown>;
+      const schema = o.schema;
+      if (!schema || typeof schema !== "object" || !Array.isArray((schema as { fields?: unknown }).fields)) {
+        return emptyStore();
+      }
+      const allies = rowsFromBlobPayload(o, slug);
+      return normalizeStore({
+        schema: o.schema as AllyStore["schema"],
+        playerSchema: (o.playerSchema as AllyStore["playerSchema"]) ?? { fields: [] },
+        allies,
+      });
+    }
+  } catch (err) {
+    console.error("[entityClassStorage] read failed", slug, err);
+    throw err;
+  }
+
+  return emptyStore();
+}
+
+export async function writeEntityClassStore(
+  studioId: string,
+  slug: string,
+  store: AllyStore,
+  lane: BlobLane = "draft"
+): Promise<void> {
+  requireStudioId(studioId, "writeEntityClassStore");
+  requireRemoteStorage("writeEntityClassStore");
+  const normalized = normalizeStore(store);
+  await writeEntityClassToBlob(studioId, slug, lane, blobPayloadFromStore(normalized, slug));
+}