refactor: flatten monorepo to single web package (#12)

Flatten the pnpm monorepo (apps/web + packages/*) into a single web package at the repo root.

- Move app/lib/components/scripts/public to root; drop apps/web and packages/* wrappers
- Rewrite tsconfig paths (@infiplot/*) to ./lib/*; turbopack.root = __dirname
- Update Vercel (no root-directory) and Cloudflare (pnpm build:cf at root) deploy paths
- Regenerate pnpm-lock.yaml to drop stale workspace importers
- Bump engines.node to >=22 to match wrangler

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

lib/ai-client/chat.ts

@@ -0,0 +1,54 @@
+import type { ProviderConfig } from "@infiplot/types";
+import { fetchWithRetry } from "./fetchWithRetry";
+
+export type ChatMessage = {
+  role: "system" | "user" | "assistant";
+  content: string;
+};
+
+export async function chat(
+  config: ProviderConfig,
+  messages: ChatMessage[],
+  opts?: { temperature?: number; responseFormat?: "json_object" | "text" },
+): Promise<string> {
+  const url = `${config.baseUrl.replace(/\/$/, "")}/chat/completions`;
+  const body: Record<string, unknown> = {
+    model: config.model,
+    messages,
+    temperature: opts?.temperature ?? 0.9,
+  };
+  if (opts?.responseFormat === "json_object") {
+    body.response_format = { type: "json_object" };
+  }
+
+  const res = await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Chat API error ${res.status}: ${text}`);
+  }
+
+  let json: { choices: { message: { content: string } }[] };
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`Chat API returned invalid JSON: ${text.slice(0, 500)}`);
+  }
+
+  // Guard against empty choices array or missing message/content fields
+  const content = json.choices?.[0]?.message?.content;
+  if (typeof content !== "string") {
+    throw new Error(
+      `Chat API returned no content. Response: ${text.slice(0, 500)}`
+    );
+  }
+
+  return content;
+}

lib/ai-client/fetchWithRetry.ts

@@ -0,0 +1,39 @@
+type RetryInit = RequestInit & { retries?: number; retryDelayMs?: number };
+
+export async function fetchWithRetry(
+  url: string,
+  init: RetryInit,
+): Promise<Response> {
+  const { retries = 2, retryDelayMs = 1500, ...fetchInit } = init;
+
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const res = await fetch(url, fetchInit);
+      if (res.ok) return res;
+      // Don't retry 4xx (client errors won't fix themselves)
+      if (res.status >= 400 && res.status < 500) return res;
+      // 5xx: retry if we have budget left
+      if (attempt < retries) {
+        await sleep(retryDelayMs * (attempt + 1));
+        continue;
+      }
+      return res;
+    } catch (err) {
+      lastError = err;
+      const isAbort =
+        err instanceof DOMException && err.name === "AbortError";
+      if (isAbort) throw err;
+      if (attempt < retries) {
+        await sleep(retryDelayMs * (attempt + 1));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

lib/ai-client/image.ts

@@ -0,0 +1,130 @@
+import type { ProviderConfig } from "@infiplot/types";
+import { fetchWithRetry } from "./fetchWithRetry";
+
+// Runware uses its own task-array protocol (not OpenAI-compatible).
+// POST <baseUrl> with [{ taskType: "imageInference", ... }]; errors come
+// back as a 200 with `errors[]`, so we have to inspect the body either way.
+//
+// referenceImages accepts UUIDs, public URLs, or base64. UUID is cheapest
+// in transport cost; URL is next; base64 last resort. The FLUX.2 [klein] 9B
+// KV variant (runware:400@6) accelerates multi-reference inference ~2.5× via
+// its KV cache for reference latents (cached only within one inference run,
+// not persisted across calls — hence the need to keep stable UUIDs/URLs for
+// later reuse).
+//
+// We request outputType=URL so Runware persists the image and returns a CDN
+// link the client can render directly. The same response also carries the
+// image UUID, so we never need a separate uploadImage round-trip to anchor
+// future referenceImages.
+const DEFAULT_IMG2IMG_STRENGTH = 0.85;
+const MAX_REFERENCE_IMAGES = 4;
+
+type RunwareImageResult = {
+  imageURL?: string;
+  imageUUID?: string;
+};
+type RunwareError = {
+  code?: string;
+  message?: string;
+  parameter?: string;
+};
+type RunwareResponse = {
+  data?: RunwareImageResult[];
+  errors?: RunwareError[];
+};
+
+export type GenerateImageOptions = {
+  /**
+   * Reference image (UUID, public URL, or base64) for img2img. When set,
+   * FLUX preserves the seed image's composition and applies `strength` to
+   * deviate. NOTE: FLUX.2 [klein] 9B KV does NOT support seedImage — use
+   * `referenceImages` for visual continuity instead.
+   */
+  seedImage?: string;
+  /**
+   * Reference images (UUIDs, URLs, or base64) to condition generation on —
+   * typically character portraits + the prior scene image. Runware caps at 4;
+   * we silently truncate beyond that.
+   */
+  referenceImages?: string[];
+  /** 0–1, FLUX needs ≥ 0.8 to actually have an effect. */
+  strength?: number;
+};
+
+export type GenerateImageResult = {
+  /** Public CDN URL of the generated image (Runware-hosted). */
+  imageUrl: string;
+  /** Stable UUID for cheap re-reference in later `referenceImages`. */
+  imageUuid: string;
+};
+
+// ──────────────────────────────────────────────────────────────────────
+//  generateImage — text-to-image (default) or referenceImages-conditioned.
+//  Returns both the public URL (for client display + future references)
+//  and the UUID (cheapest reference form for subsequent calls).
+// ──────────────────────────────────────────────────────────────────────
+
+export async function generateImage(
+  config: ProviderConfig,
+  prompt: string,
+  options?: GenerateImageOptions,
+): Promise<GenerateImageResult> {
+  const url = config.baseUrl.replace(/\/$/, "");
+
+  const task: Record<string, unknown> = {
+    taskType: "imageInference",
+    taskUUID: crypto.randomUUID(),
+    model: config.model,
+    positivePrompt: prompt,
+    width: 1792,
+    height: 1024,
+    steps: 4,
+    CFGScale: 3.5,
+    numberResults: 1,
+    outputType: "URL",
+    outputFormat: "PNG",
+    includeCost: false,
+  };
+
+  if (options?.seedImage) {
+    task.seedImage = options.seedImage;
+    task.strength = options.strength ?? DEFAULT_IMG2IMG_STRENGTH;
+  }
+
+  if (options?.referenceImages?.length) {
+    task.referenceImages = options.referenceImages.slice(0, MAX_REFERENCE_IMAGES);
+  }
+
+  const res = await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`,
+    },
+    body: JSON.stringify([task]),
+  });
+
+  const text = await res.text();
+  let json: RunwareResponse;
+  try {
+    json = JSON.parse(text) as RunwareResponse;
+  } catch {
+    throw new Error(`Image API error ${res.status}: ${text.slice(0, 500)}`);
+  }
+
+  if (json.errors?.length) {
+    const e = json.errors[0]!;
+    throw new Error(
+      `Runware error [${e.code ?? "unknown"}]: ${e.message ?? "no message"}` +
+        (e.parameter ? ` (parameter: ${e.parameter})` : ""),
+    );
+  }
+
+  const result = json.data?.[0];
+  const imageUrl = result?.imageURL;
+  const imageUuid = result?.imageUUID;
+  if (!imageUrl || !imageUuid) {
+    throw new Error(`No image URL/UUID in Runware response: ${text.slice(0, 300)}`);
+  }
+  return { imageUrl, imageUuid };
+}

lib/ai-client/index.ts

@@ -0,0 +1,5 @@
+export { chat } from "./chat";
+export { generateImage } from "./image";
+export type { GenerateImageOptions, GenerateImageResult } from "./image";
+export { interpretClick } from "./vision";
+export type { ChatMessage } from "./chat";

lib/ai-client/vision.ts

@@ -0,0 +1,69 @@
+import type { ProviderConfig } from "@infiplot/types";
+import { fetchWithRetry } from "./fetchWithRetry";
+
+export async function interpretClick(
+  config: ProviderConfig,
+  imageBase64: string,
+  prompt: string,
+): Promise<string> {
+  const url = `${config.baseUrl.replace(/\/$/, "")}/chat/completions`;
+
+  const body = {
+    model: config.model,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: prompt },
+          {
+            type: "image_url",
+            image_url: { url: `data:image/png;base64,${imageBase64}` },
+          },
+        ],
+      },
+    ],
+    temperature: 0.2,
+    response_format: { type: "json_object" },
+  };
+
+  const timeoutCtrl = new AbortController();
+  const timeoutId = setTimeout(() => timeoutCtrl.abort(), 60_000);
+
+  let res: Response;
+  try {
+    res = await fetchWithRetry(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`,
+      },
+      body: JSON.stringify(body),
+      signal: timeoutCtrl.signal,
+      retries: 0,
+    });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Vision API error ${res.status}: ${text}`);
+  }
+
+  let json: { choices: { message: { content: string } }[] };
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`Vision API returned invalid JSON: ${text.slice(0, 500)}`);
+  }
+
+  // Guard against empty choices array or missing message/content fields
+  const content = json.choices?.[0]?.message?.content;
+  if (typeof content !== "string") {
+    throw new Error(
+      `Vision API returned no content. Response: ${text.slice(0, 500)}`
+    );
+  }
+
+  return content;
+}