@nebutra/atelier-canvas 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nebutra/atelier-canvas",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Server-authoritative creative-canvas engine: scene model, non-overlap placement, write-then-broadcast consistency, tenant-scoped locking",
   "private": false,
   "license": "MIT",
@@ -11,13 +11,14 @@
     "surface": "creative-surface",
     "summary": "Server-authoritative creative-canvas engine"
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./store/memory": "./src/store/memory.ts",
-    "./store/prisma": "./src/store/prisma.ts",
-    "./agent": "./src/agent/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "dependencies": {
     "@nebutra/logger": "0.1.2",
@@ -50,6 +51,12 @@
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "scripts": {
     "build": "tsup",
     "test": "vitest run",

package/.turbo/turbo-build.log

@@ -1,33 +0,0 @@
-
-> @nebutra/atelier-canvas@1.0.2 build /Users/tseka_luk/Documents/Nebutra-SaaS-Lab/Nebutra-Sailor/packages/ai/atelier-canvas
-> tsup
-
-CLI Building entry: src/index.ts, src/agent/index.ts, src/store/memory.ts, src/store/prisma.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /Users/tseka_luk/Documents/Nebutra-SaaS-Lab/Nebutra-Sailor/packages/ai/atelier-canvas/tsup.config.ts
-CLI Target: es2022
-CLI Cleaning output folder
-ESM Build start
-ESM dist/chunk-JYV7NRGL.js     3.00 KB
-ESM dist/index.js              410.00 B
-ESM dist/chunk-AVQEQBLX.js     1.10 KB
-ESM dist/store/memory.js       130.00 B
-ESM dist/store/prisma.js       126.00 B
-ESM dist/chunk-5UUHUVE4.js     2.00 KB
-ESM dist/agent/index.js        5.83 KB
-ESM dist/chunk-JYV7NRGL.js.map 9.68 KB
-ESM dist/store/memory.js.map   71.00 B
-ESM dist/chunk-AVQEQBLX.js.map 2.70 KB
-ESM dist/chunk-5UUHUVE4.js.map 5.57 KB
-ESM dist/store/prisma.js.map   71.00 B
-ESM dist/index.js.map          71.00 B
-ESM dist/agent/index.js.map    12.44 KB
-ESM ⚡️ Build success in 18ms
-DTS Build start
-DTS ⚡️ Build success in 1260ms
-DTS dist/index.d.ts          3.84 KB
-DTS dist/agent/index.d.ts    6.63 KB
-DTS dist/store/memory.d.ts   976.00 B
-DTS dist/store/prisma.d.ts   2.55 KB
-DTS dist/types-Dw9o09h2.d.ts 2.95 KB

package/.turbo/turbo-test.log

@@ -1,15 +0,0 @@
-
-> @nebutra/atelier-canvas@1.0.1 test /Users/tseka_luk/Documents/Nebutra-SaaS-Lab/Nebutra-Sailor/packages/ai/atelier-canvas
-> vitest run
-
-
- RUN  v4.1.4 /Users/tseka_luk/Documents/Nebutra-SaaS-Lab/Nebutra-Sailor/packages/ai/atelier-canvas
-
- ✓ src/__tests__/atelier-canvas.test.ts (7 tests) 73ms
- ✓ src/agent/__tests__/agent.test.ts (5 tests) 29ms
-
- Test Files  2 passed (2)
-      Tests  12 passed (12)
-   Start at  09:40:52
-   Duration  3.29s (transform 1.73s, setup 0ms, import 2.96s, tests 102ms, environment 0ms)
-

package/.turbo/turbo-typecheck.log

@@ -1,4 +0,0 @@
-
-> @nebutra/atelier-canvas@1.0.2 typecheck /Users/tseka_luk/Documents/Nebutra-SaaS-Lab/Nebutra-Sailor/packages/ai/atelier-canvas
-> tsc --noEmit
-

package/src/__tests__/atelier-canvas.test.ts

@@ -1,96 +0,0 @@
-/**
- * Canvas engine: deterministic placement, tenant isolation, write-then-
- * broadcast consistency, and per-canvas serialization.
- */
-
-import { beforeEach, describe, expect, it } from "vitest";
-import { _resetCanvasLocks } from "../lock";
-import { findNextPosition } from "../placement";
-import { type GeneratedAsset, placeGeneratedAsset } from "../service";
-import { InMemoryCanvasStore } from "../store/memory";
-import type { CanvasElement } from "../types";
-
-const img = (over: Partial<GeneratedAsset> = {}): GeneratedAsset => ({
-  modality: "image",
-  mimeType: "image/svg+xml",
-  url: "data:image/svg+xml;base64,AAAA",
-  width: 512,
-  height: 512,
-  ...over,
-});
-
-beforeEach(() => {
-  _resetCanvasLocks();
-});
-
-describe("findNextPosition", () => {
-  it("places the first element at the origin", () => {
-    expect(findNextPosition([], { width: 100, height: 100 })).toEqual({ x: 0, y: 0 });
-  });
-
-  it("never overlaps an existing element (respects gap)", () => {
-    const existing: CanvasElement[] = [
-      { id: "a", type: "image", x: 0, y: 0, width: 200, height: 200, ref: "f" },
-    ];
-    const p = findNextPosition(existing, { width: 200, height: 200 });
-    const clash = p.x < 200 + 40 && p.x + 200 + 40 > 0 && p.y < 200 + 40 && p.y + 200 + 40 > 0;
-    expect(clash).toBe(false);
-  });
-
-  it("is deterministic for identical input", () => {
-    const existing: CanvasElement[] = [
-      { id: "a", type: "image", x: 0, y: 0, width: 300, height: 100, ref: "f" },
-    ];
-    const a = findNextPosition(existing, { width: 100, height: 100 });
-    const b = findNextPosition(existing, { width: 100, height: 100 });
-    expect(a).toEqual(b);
-  });
-});
-
-describe("placeGeneratedAsset", () => {
-  it("persists before returning the patch (scene is durable)", async () => {
-    const store = new InMemoryCanvasStore();
-    const { patch } = await placeGeneratedAsset(store, "org_1", "c1", img());
-
-    const reloaded = await store.get("org_1", "c1");
-    expect(reloaded?.scene.elements).toHaveLength(1);
-    expect(reloaded?.scene.elements[0]?.id).toBe(patch.element.id);
-    expect(reloaded?.scene.files).toHaveLength(1);
-    expect(reloaded?.thumbnail).toBe(patch.thumbnail);
-  });
-
-  it("isolates canvases by tenant", async () => {
-    const store = new InMemoryCanvasStore();
-    await placeGeneratedAsset(store, "org_a", "shared-id", img());
-    await placeGeneratedAsset(store, "org_b", "shared-id", img());
-
-    expect((await store.get("org_a", "shared-id"))?.scene.elements).toHaveLength(1);
-    expect(await store.list("org_a")).toHaveLength(1);
-    expect(await store.list("org_b")).toHaveLength(1);
-  });
-
-  it("embeds video by URL (no file entry)", async () => {
-    const store = new InMemoryCanvasStore();
-    const { patch } = await placeGeneratedAsset(
-      store,
-      "org_1",
-      "c1",
-      img({ modality: "video", url: "https://x.test/v.mp4", mimeType: "video/mp4" }),
-    );
-    expect(patch.element.type).toBe("embeddable");
-    expect(patch.element.ref).toBe("https://x.test/v.mp4");
-    expect(patch.file).toBeUndefined();
-  });
-
-  it("serializes concurrent placements on the same canvas (no stacking)", async () => {
-    const store = new InMemoryCanvasStore();
-    await Promise.all(
-      Array.from({ length: 6 }, () => placeGeneratedAsset(store, "org_1", "c1", img())),
-    );
-    const scene = (await store.get("org_1", "c1"))?.scene;
-    expect(scene?.elements).toHaveLength(6);
-    // Every element occupies a distinct position.
-    const positions = new Set(scene?.elements.map((e) => `${e.x},${e.y}`));
-    expect(positions.size).toBe(6);
-  });
-});

package/src/agent/__tests__/agent.test.ts

@@ -1,74 +0,0 @@
-/**
- * The /agent subpath closes the loop end-to-end (mock provider): prompt →
- * asset → server placement → durable scene → broadcast hook. Importing this
- * module pulls @nebutra/agents (optional peer); the core export does not.
- */
-
-import { createAgentContext } from "@nebutra/agents";
-import { describe, expect, it } from "vitest";
-import { InMemoryCanvasStore } from "../../store/memory";
-import type { ScenePatch } from "../../types";
-import { createAtelierAgent } from "../agent";
-import { ATELIER_SYSTEM_PROMPT } from "../prompts";
-import { createAtelierGenerationTool } from "../tools";
-
-const ctx = createAgentContext("org_1", "user_1", "conv_1");
-
-describe("atelier system prompt", () => {
-  it("encodes the absorbed creative invariants", () => {
-    expect(ATELIER_SYSTEM_PROMPT).toContain("Design Strategy");
-    expect(ATELIER_SYSTEM_PROMPT).toContain("QUANTITY IS A CONTRACT");
-    expect(ATELIER_SYSTEM_PROMPT).toContain("batches of at most 10");
-    expect(ATELIER_SYSTEM_PROMPT).toContain("input_images");
-  });
-});
-
-describe("createAtelierGenerationTool", () => {
-  it("generates, places, persists, then fires the broadcast hook", async () => {
-    const store = new InMemoryCanvasStore();
-    const broadcasts: ScenePatch[] = [];
-    const tool = createAtelierGenerationTool({
-      store,
-      onPlaced: (p) => {
-        broadcasts.push(p);
-      },
-    });
-
-    const out = (await tool.execute(
-      { canvasId: "c1", prompt: "a serene alpine lake at dawn" },
-      ctx,
-    )) as { ok: boolean; placed: { elementId: string; modality: string } };
-
-    expect(out.ok).toBe(true);
-    expect(out.placed.modality).toBe("image");
-
-    const canvas = await store.get("org_1", "c1");
-    expect(canvas?.scene.elements).toHaveLength(1);
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0]?.element.id).toBe(out.placed.elementId);
-  });
-
-  it("rejects missing required input", async () => {
-    const tool = createAtelierGenerationTool({ store: new InMemoryCanvasStore() });
-    await expect(tool.execute({ canvasId: "c1" }, ctx)).rejects.toThrow("prompt");
-    await expect(tool.execute({ prompt: "x" }, ctx)).rejects.toThrow("canvasId");
-  });
-
-  it("places video as an embeddable (no file)", async () => {
-    const store = new InMemoryCanvasStore();
-    const tool = createAtelierGenerationTool({ store });
-    await tool.execute({ canvasId: "c1", prompt: "loop of falling snow", modality: "video" }, ctx);
-    const el = (await store.get("org_1", "c1"))?.scene.elements[0];
-    expect(el?.type).toBe("embeddable");
-  });
-});
-
-describe("createAtelierAgent", () => {
-  it("produces a single-tool AgentConfig carrying the strategy prompt", () => {
-    const agent = createAtelierAgent({ store: new InMemoryCanvasStore() });
-    expect(agent.id).toBe("atelier");
-    expect(agent.tools).toHaveLength(1);
-    expect(agent.tools?.[0]?.name).toBe("atelier_generate");
-    expect(agent.instructions).toBe(ATELIER_SYSTEM_PROMPT);
-  });
-});

package/src/agent/agent.ts

@@ -1,34 +0,0 @@
-/**
- * The creative-canvas agent, as a single Sailor `AgentConfig`.
- *
- * The source product ran a two-node LangGraph swarm (planner ⇄ creator). Both
- * roles are expressed here as one prompt with two phases plus one tool — the
- * planner/creator split was orchestration overhead, not product value, and
- * Sailor's `BaseAgent` tool-loop already provides the step iteration the swarm
- * was emulating. `maxSteps` is the `@nebutra/agents` AgentConfig field (the
- * provider maps it to `stopWhen: stepCountIs(...)` internally) — not an AI SDK
- * option.
- */
-
-import type { AgentConfig } from "@nebutra/agents";
-import { ATELIER_SYSTEM_PROMPT } from "./prompts";
-import { type AtelierToolDeps, createAtelierGenerationTool } from "./tools";
-
-export interface CreateAtelierAgentOptions extends AtelierToolDeps {
-  /** Model id / preset. Defaults to the "flagship" preset. */
-  readonly model?: string;
-  /** Max tool-loop iterations (batch generation needs headroom). */
-  readonly maxSteps?: number;
-}
-
-export function createAtelierAgent(opts: CreateAtelierAgentOptions): AgentConfig {
-  return {
-    id: "atelier",
-    name: "Atelier",
-    description: "Plans and generates images/videos onto a creative canvas from a brief.",
-    model: opts.model ?? "flagship",
-    instructions: ATELIER_SYSTEM_PROMPT,
-    tools: [createAtelierGenerationTool(opts)],
-    maxSteps: opts.maxSteps ?? 30,
-  };
-}

package/src/agent/index.ts

@@ -1,16 +0,0 @@
-/**
- * @nebutra/atelier-canvas/agent — the canvas capability's agent face.
- *
- * Opt-in subpath: importing it pulls `@nebutra/agents` (an optional peer);
- * the package's core export (placement / store / consistency) stays free of
- * any agents dependency. This is a *consumer* of the agents runtime — it
- * yields an `AgentConfig` — never a runtime parallel to it.
- */
-
-export { type CreateAtelierAgentOptions, createAtelierAgent } from "./agent";
-export {
-  ATELIER_CREATOR_RULES,
-  ATELIER_PLANNER_RULES,
-  ATELIER_SYSTEM_PROMPT,
-} from "./prompts";
-export { type AtelierToolDeps, createAtelierGenerationTool } from "./tools";

package/src/agent/prompts.ts

@@ -1,64 +0,0 @@
-/**
- * The creative-direction prompt strategy.
- *
- * This is the differentiated IP absorbed from the source product, re-expressed
- * in Sailor's voice: a two-phase loop (plan → create), a structured "Design
- * Strategy" the model must author before generating, and the operational
- * invariants that make multi-asset generation reliable — exact-quantity
- * preservation, bounded batches, reference-image parsing, and act-without-
- * asking. These rules, not the model choice, are what make output consistent.
- *
- * Lives under the `/agent` subpath, not a package parallel to
- * `@nebutra/agents`: it produces an `AgentConfig` *consumed by* the agents
- * runtime, it is not a second runtime.
- */
-
-/** Phase 1 — decompose intent into an ordered plan. */
-export const ATELIER_PLANNER_RULES = `\
-You are a creative-canvas director. Reply in the SAME LANGUAGE as the user.
-
-PLAN FIRST:
-- For any multi-step request, write a short ordered plan (high-level steps)
-  before generating anything. For a single image with no extra steps, a plan
-  is optional.
-- Then proceed to generate immediately. Do NOT ask the user to approve the
-  plan — acting is expected.
-
-QUANTITY IS A CONTRACT:
-- If the user states a count ("20 images", "make 15 frames"), carry that
-  EXACT number through the plan and the generation calls. Never silently
-  change or drop it. If no count is given, assume 1.`;
-
-/** Phase 2 — author a design strategy, then generate. */
-export const ATELIER_CREATOR_RULES = `\
-BEFORE GENERATING AN IMAGE, author a brief Design Strategy in the user's
-language covering, as bullets:
-  • Recommended resolution (and why it fits the use case)
-  • Style & mood
-  • Key visual element(s)
-  • Composition & layout
-  • Colour palette (concrete values)
-  • Typography (only if the piece carries text)
-
-Then call the generation tool with ONE detailed, professional prompt derived
-from that strategy. The strategy is scaffolding for the prompt — keep it tight,
-not an essay.
-
-REFERENCE IMAGES:
-- The user message may carry references as XML:
-  <input_images><image file_id="..."/></input_images>
-- When present, extract every file_id and pass them to the tool's
-  \`inputImages\` argument so edits/variations are grounded in the source.
-
-BATCHING:
-- Need more than 10 assets? Generate in batches of at most 10, finishing and
-  acknowledging each batch ("Batch 1 of 3 done") before starting the next.
-
-VIDEO:
-- For video, you may first generate the key still(s) and animate from them, or
-  generate directly from a text prompt — choose what the brief implies.`;
-
-/** Composed system prompt for a single-agent creative-canvas operator. */
-export const ATELIER_SYSTEM_PROMPT = `${ATELIER_PLANNER_RULES}
-
-${ATELIER_CREATOR_RULES}`;

package/src/agent/tools.ts

@@ -1,148 +0,0 @@
-/**
- * The single agent tool that closes the loop: text prompt → generated asset
- * → server-placed on the tenant's canvas → patch handed back for broadcast.
- *
- * Generation reuses the env-key-gated modality in `@nebutra/agents` (mock when
- * no provider key is present). Placement + persistence reuse this package's
- * own engine (relative imports — same capability, no cross-package hop).
- *
- * `onPlaced` lets the app broadcast the patch (e.g. via pusher) WITHOUT this
- * package taking a realtime dependency — broadcast is a WRAP at the app layer.
- */
-
-import {
-  type AgentTool,
-  type GenerationContext,
-  generateImage,
-  generateVideo,
-} from "@nebutra/agents";
-import { placeGeneratedAsset } from "../service";
-import type { CanvasStore, ScenePatch } from "../types";
-
-export interface AtelierToolDeps {
-  /** Tenant-scoped persistence (InMemory for demo, Prisma in prod). */
-  readonly store: CanvasStore;
-  /** Broadcast hook — invoked after the patch is durably persisted. */
-  readonly onPlaced?: (patch: ScenePatch) => void | Promise<void>;
-}
-
-interface GenerateInput {
-  canvasId: string;
-  prompt: string;
-  modality?: "image" | "video";
-  width?: number;
-  height?: number;
-  inputImages?: string[];
-  durationSeconds?: number;
-}
-
-function parseInput(raw: unknown): GenerateInput {
-  const o = (raw ?? {}) as Record<string, unknown>;
-  if (typeof o.canvasId !== "string" || o.canvasId.length === 0) {
-    throw new Error("atelier_generate: 'canvasId' is required");
-  }
-  if (typeof o.prompt !== "string" || o.prompt.trim().length === 0) {
-    throw new Error("atelier_generate: 'prompt' is required");
-  }
-  const modality = o.modality === "video" ? "video" : "image";
-  return {
-    canvasId: o.canvasId,
-    prompt: o.prompt,
-    modality,
-    ...(typeof o.width === "number" ? { width: o.width } : {}),
-    ...(typeof o.height === "number" ? { height: o.height } : {}),
-    ...(Array.isArray(o.inputImages)
-      ? { inputImages: o.inputImages.filter((x): x is string => typeof x === "string") }
-      : {}),
-    ...(typeof o.durationSeconds === "number" ? { durationSeconds: o.durationSeconds } : {}),
-  };
-}
-
-/**
- * Build the `atelier_generate` tool. One call = one asset (the agent loops
- * itself for batches, per the batching rule in the system prompt).
- */
-export function createAtelierGenerationTool(deps: AtelierToolDeps): AgentTool {
-  return {
-    name: "atelier_generate",
-    description:
-      "Generate one image or video from a prompt and place it on the canvas. " +
-      "Returns the placed element's position so you can reason about layout. " +
-      "Call once per asset; for batches, call repeatedly.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        canvasId: { type: "string", description: "Target canvas id" },
-        prompt: { type: "string", description: "Detailed generation prompt" },
-        modality: { type: "string", enum: ["image", "video"] },
-        width: { type: "number" },
-        height: { type: "number" },
-        durationSeconds: { type: "number", description: "Video length (s)" },
-        inputImages: {
-          type: "array",
-          items: { type: "string" },
-          description: "Reference file ids / URLs for edits & variations",
-        },
-      },
-      required: ["canvasId", "prompt"],
-    },
-    execute: async (rawInput, context) => {
-      const input = parseInput(rawInput);
-      const genCtx: GenerationContext = {
-        tenantId: context.tenantId,
-        userId: context.userId,
-        conversationId: context.conversationId,
-      };
-
-      const result =
-        input.modality === "video"
-          ? await generateVideo(
-              {
-                prompt: input.prompt,
-                ...(input.width ? { width: input.width } : {}),
-                ...(input.height ? { height: input.height } : {}),
-                ...(input.durationSeconds ? { durationSeconds: input.durationSeconds } : {}),
-                ...(input.inputImages?.[0] ? { inputImage: input.inputImages[0] } : {}),
-              },
-              genCtx,
-            )
-          : await generateImage(
-              {
-                prompt: input.prompt,
-                ...(input.width ? { width: input.width } : {}),
-                ...(input.height ? { height: input.height } : {}),
-                ...(input.inputImages ? { inputImages: input.inputImages } : {}),
-              },
-              genCtx,
-            );
-
-      const { patch } = await placeGeneratedAsset(deps.store, context.tenantId, input.canvasId, {
-        modality: result.modality,
-        mimeType: result.mimeType,
-        url: result.url,
-        width: result.width,
-        height: result.height,
-        meta: {
-          prompt: input.prompt,
-          model: result.model,
-          provider: result.providerName,
-        },
-      });
-
-      // Persisted — now safe to broadcast.
-      await deps.onPlaced?.(patch);
-
-      return {
-        ok: true,
-        placed: {
-          elementId: patch.element.id,
-          x: patch.element.x,
-          y: patch.element.y,
-          modality: result.modality,
-        },
-        provider: result.providerName,
-        model: result.model,
-      };
-    },
-  };
-}

package/src/index.ts

@@ -1,33 +0,0 @@
-/**
- * @nebutra/atelier-canvas — server-authoritative creative-canvas engine.
- *
- * The browser owns the rich editing surface; this package owns the two
- * properties that make an agent-driven canvas correct under concurrency and
- * multi-tenancy: deterministic server-side placement, and persist-then-
- * broadcast consistency. Tenant isolation is structural — every store method
- * is scoped by `tenantId`.
- */
-
-export { _resetCanvasLocks, withCanvasLock } from "./lock";
-export { findNextPosition } from "./placement";
-export {
-  type GeneratedAsset,
-  placeGeneratedAsset,
-} from "./service";
-export { InMemoryCanvasStore } from "./store/memory";
-export {
-  type AtelierCanvasDelegate,
-  PrismaCanvasStore,
-  type TenantDbLike,
-} from "./store/prisma";
-export type {
-  AtelierCanvas,
-  CanvasElement,
-  CanvasElementType,
-  CanvasFile,
-  CanvasScene,
-  CanvasStore,
-  ElementSize,
-  Placement,
-  ScenePatch,
-} from "./types";

package/src/lock.ts

@@ -1,39 +0,0 @@
-/**
- * Per-canvas serialization.
- *
- * The generic per-(tenant, resource) serializer now lives in the neutral
- * lower layer `@nebutra/tenant-store` (so `@nebutra/reel` and future
- * tenant-scoped features share it without depending on this package). This
- * module keeps the original `withCanvasLock` / `_resetCanvasLocks` names as
- * thin, back-compatible aliases so existing callers (e.g. apps/web) keep
- * working unchanged.
- *
- * @deprecated Import `withTenantLock` / `_resetTenantLocks` from
- * `@nebutra/tenant-store` directly in new code. These aliases are retained
- * only for the existing public surface.
- */
-
-import { _resetTenantLocks, withTenantLock } from "@nebutra/tenant-store";
-
-/**
- * Run `fn` with exclusive access to a single (tenant, canvas). Calls for the
- * same canvas run strictly in submission order; different canvases run freely.
- *
- * @deprecated Use `withTenantLock` from `@nebutra/tenant-store`.
- */
-export function withCanvasLock<T>(
-  tenantId: string,
-  canvasId: string,
-  fn: () => Promise<T>,
-): Promise<T> {
-  return withTenantLock(tenantId, canvasId, fn);
-}
-
-/**
- * Test helper — clears all lock chains.
- *
- * @deprecated Use `_resetTenantLocks` from `@nebutra/tenant-store`.
- */
-export function _resetCanvasLocks(): void {
-  _resetTenantLocks();
-}

package/src/placement.ts

@@ -1,67 +0,0 @@
-/**
- * Server-authoritative non-overlap placement.
- *
- * Ported in spirit from the source product's `find_next_best_element_position`:
- * the server — not the client — decides where a freshly generated asset lands,
- * so concurrent generations never stack and every client converges on the same
- * coordinates. Deterministic given (existing elements, size, gap): identical
- * inputs always yield the identical position, which keeps placement tests and
- * websocket-sync reproducible.
- */
-
-import type { CanvasElement, ElementSize, Placement } from "./types";
-
-const DEFAULT_GAP = 40;
-/** Columns scanned before wrapping to the next row. Bounds worst-case work. */
-const MAX_COLS = 12;
-
-interface Box {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-
-function overlaps(a: Box, b: Box, gap: number): boolean {
-  return !(
-    a.x + a.width + gap <= b.x ||
-    b.x + b.width + gap <= a.x ||
-    a.y + a.height + gap <= b.y ||
-    b.y + b.height + gap <= a.y
-  );
-}
-
-/**
- * Find the first free top-left position for an element of `size`, scanning
- * left→right then top→down on a grid sized to the largest existing element.
- * Returns `{0,0}` for an empty canvas.
- */
-export function findNextPosition(
-  existing: readonly CanvasElement[],
-  size: ElementSize,
-  gap: number = DEFAULT_GAP,
-): Placement {
-  if (existing.length === 0) return { x: 0, y: 0 };
-
-  // Step = widest/tallest placed element (+gap) so the grid never collides
-  // with large neighbours; bounded below by the incoming element's own size.
-  const stepX = Math.max(size.width, ...existing.map((e) => e.width)) + gap;
-  const stepY = Math.max(size.height, ...existing.map((e) => e.height)) + gap;
-
-  const candidate: Box = { x: 0, y: 0, width: size.width, height: size.height };
-
-  for (let row = 0; row < existing.length + 1; row++) {
-    for (let col = 0; col < MAX_COLS; col++) {
-      candidate.x = col * stepX;
-      candidate.y = row * stepY;
-      const clash = existing.some((e) =>
-        overlaps(candidate, { x: e.x, y: e.y, width: e.width, height: e.height }, gap),
-      );
-      if (!clash) return { x: candidate.x, y: candidate.y };
-    }
-  }
-
-  // Pathological fallback: drop below everything.
-  const maxBottom = Math.max(...existing.map((e) => e.y + e.height));
-  return { x: 0, y: maxBottom + gap };
-}

package/src/service.ts

@@ -1,115 +0,0 @@
-/**
- * The write-then-broadcast placement service — the core consistency
- * invariant absorbed from the source product.
- *
- * For one (tenant, canvas), under the canvas lock:
- *   1. load the authoritative scene,
- *   2. compute a non-overlapping position server-side,
- *   3. append the element/file and **persist** the new scene,
- *   4. return a {@link ScenePatch}.
- *
- * The caller broadcasts the returned patch over the realtime channel *after*
- * this resolves. Persisting before broadcasting is what makes the websocket
- * a pure optimization: a client that never receives the event recovers the
- * identical state on reload. Reversing the order reintroduces the
- * lost-update bug.
- */
-
-import { logger } from "@nebutra/logger";
-import { withCanvasLock } from "./lock";
-import { findNextPosition } from "./placement";
-import type {
-  AtelierCanvas,
-  CanvasElement,
-  CanvasFile,
-  CanvasScene,
-  CanvasStore,
-  ScenePatch,
-} from "./types";
-
-const log = logger.child({ module: "atelier-canvas/service" });
-
-/** A generated asset, shaped to match `@nebutra/agents` GenerationResult. */
-export interface GeneratedAsset {
-  readonly modality: "image" | "video";
-  readonly mimeType: string;
-  readonly url: string;
-  readonly width: number;
-  readonly height: number;
-  /** Carried into element.meta for provenance (prompt, model, provider). */
-  readonly meta?: Readonly<Record<string, unknown>>;
-}
-
-function newId(prefix: string): string {
-  return `${prefix}_${crypto.randomUUID()}`;
-}
-
-/**
- * Place a generated asset on a canvas. Creates the canvas on first write.
- * Concurrency-safe per (tenant, canvas) via {@link withCanvasLock}.
- */
-export async function placeGeneratedAsset(
-  store: CanvasStore,
-  tenantId: string,
-  canvasId: string,
-  asset: GeneratedAsset,
-): Promise<{ patch: ScenePatch; canvas: AtelierCanvas }> {
-  return withCanvasLock(tenantId, canvasId, async () => {
-    const current =
-      (await store.get(tenantId, canvasId)) ?? (await store.create(tenantId, canvasId, canvasId));
-
-    const position = findNextPosition(current.scene.elements, {
-      width: asset.width,
-      height: asset.height,
-    });
-
-    // Images carry a file the client resolves by id; videos embed by URL.
-    let file: CanvasFile | undefined;
-    let ref: string;
-    if (asset.modality === "image") {
-      file = { id: newId("file"), mimeType: asset.mimeType, dataURL: asset.url };
-      ref = file.id;
-    } else {
-      ref = asset.url;
-    }
-
-    const element: CanvasElement = {
-      id: newId("el"),
-      type: asset.modality === "image" ? "image" : "embeddable",
-      x: position.x,
-      y: position.y,
-      width: asset.width,
-      height: asset.height,
-      ref,
-      ...(asset.meta ? { meta: asset.meta } : {}),
-    };
-
-    const nextScene: CanvasScene = {
-      elements: [...current.scene.elements, element],
-      files: file ? [...current.scene.files, file] : current.scene.files,
-    };
-
-    // Thumbnail = latest asset (matches source product's grid-preview rule).
-    const thumbnail = asset.url;
-
-    // (3) Persist BEFORE returning — broadcast happens in the caller, after.
-    const canvas = await store.save(tenantId, canvasId, nextScene, thumbnail);
-
-    log.debug("placed generated asset", {
-      tenantId,
-      canvasId,
-      modality: asset.modality,
-      x: position.x,
-      y: position.y,
-    });
-
-    const patch: ScenePatch = {
-      canvasId,
-      tenantId,
-      element,
-      ...(file ? { file } : {}),
-      thumbnail,
-    };
-    return { patch, canvas };
-  });
-}

package/src/store/memory.ts

@@ -1,59 +0,0 @@
-/**
- * In-memory CanvasStore — the default for tests and the flag-gated demo.
- *
- * Storage mechanics (tenant-keyed map, never returning rows across tenants,
- * tenant-filtered listing) are delegated to `InMemoryTenantStore` from
- * `@nebutra/tenant-store`; this class only adds atelier's typed `create` /
- * `save` domain shape, mirroring what RLS does in the Prisma store.
- */
-
-import { InMemoryTenantStore } from "@nebutra/tenant-store";
-import type { AtelierCanvas, CanvasScene, CanvasStore } from "../types";
-
-const EMPTY_SCENE: CanvasScene = { elements: [], files: [] };
-
-export class InMemoryCanvasStore implements CanvasStore {
-  private readonly base = new InMemoryTenantStore<AtelierCanvas>();
-
-  async get(tenantId: string, canvasId: string): Promise<AtelierCanvas | null> {
-    return this.base.read(tenantId, canvasId);
-  }
-
-  async create(tenantId: string, canvasId: string, name: string): Promise<AtelierCanvas> {
-    const row: AtelierCanvas = {
-      id: canvasId,
-      tenantId,
-      name,
-      scene: EMPTY_SCENE,
-      updatedAt: new Date(),
-    };
-    return this.base.write(tenantId, canvasId, row);
-  }
-
-  async save(
-    tenantId: string,
-    canvasId: string,
-    scene: CanvasScene,
-    thumbnail?: string,
-  ): Promise<AtelierCanvas> {
-    const existing = await this.base.read(tenantId, canvasId);
-    const row: AtelierCanvas = {
-      id: canvasId,
-      tenantId,
-      name: existing?.name ?? canvasId,
-      scene,
-      ...(thumbnail !== undefined ? { thumbnail } : {}),
-      updatedAt: new Date(),
-    };
-    return this.base.write(tenantId, canvasId, row);
-  }
-
-  async list(tenantId: string): Promise<readonly AtelierCanvas[]> {
-    return this.base.listByTenant(tenantId);
-  }
-
-  /** Test helper. */
-  _clear(): void {
-    this.base.clear();
-  }
-}

package/src/store/prisma.ts

@@ -1,119 +0,0 @@
-/**
- * Prisma-backed CanvasStore — the production persistence adapter.
- *
- * Decoupled from `@nebutra/db`'s generated client by a narrow structural
- * interface, so this package typechecks and tests without running
- * `prisma generate`. Wire it in the app by passing a `getDb` that returns
- * `getTenantDb(tenantId)` (RLS-scoped) — that is what enforces tenant
- * isolation at the database layer; this adapter never calls `getSystemDb()`.
- *
- * The `AtelierCanvas` Prisma model (see packages/platform/db/prisma/
- * schema.prisma) stores the scene as a single JSON column — the same
- * one-blob-per-canvas shape the source product used, but with an
- * `organization_id` column + RLS instead of an implicit single user.
- */
-
-import type { AtelierCanvas, CanvasScene, CanvasStore } from "../types";
-
-/** Row shape as persisted (scene/files as JSON). */
-interface AtelierCanvasRow {
-  id: string;
-  organizationId: string;
-  name: string;
-  scene: unknown;
-  thumbnail: string | null;
-  updatedAt: Date;
-}
-
-/** The subset of the generated delegate this adapter needs. */
-export interface AtelierCanvasDelegate {
-  findUnique(args: {
-    where: { organizationId_id: { organizationId: string; id: string } };
-  }): Promise<AtelierCanvasRow | null>;
-  upsert(args: {
-    where: { organizationId_id: { organizationId: string; id: string } };
-    create: Omit<AtelierCanvasRow, "updatedAt">;
-    update: Partial<Omit<AtelierCanvasRow, "id" | "organizationId">>;
-  }): Promise<AtelierCanvasRow>;
-  findMany(args: { where: { organizationId: string } }): Promise<AtelierCanvasRow[]>;
-}
-
-export interface TenantDbLike {
-  atelierCanvas: AtelierCanvasDelegate;
-}
-
-const EMPTY_SCENE: CanvasScene = { elements: [], files: [] };
-
-function toDomain(row: AtelierCanvasRow): AtelierCanvas {
-  const scene =
-    row.scene && typeof row.scene === "object" ? (row.scene as CanvasScene) : EMPTY_SCENE;
-  return {
-    id: row.id,
-    tenantId: row.organizationId,
-    name: row.name,
-    scene,
-    ...(row.thumbnail ? { thumbnail: row.thumbnail } : {}),
-    updatedAt: row.updatedAt,
-  };
-}
-
-export class PrismaCanvasStore implements CanvasStore {
-  /**
-   * @param getDb returns an RLS-scoped tenant client. In the app:
-   *   `new PrismaCanvasStore((t) => getTenantDb(t) as unknown as TenantDbLike)`
-   */
-  constructor(private readonly getDb: (tenantId: string) => Promise<TenantDbLike> | TenantDbLike) {}
-
-  async get(tenantId: string, canvasId: string): Promise<AtelierCanvas | null> {
-    const db = await this.getDb(tenantId);
-    const row = await db.atelierCanvas.findUnique({
-      where: { organizationId_id: { organizationId: tenantId, id: canvasId } },
-    });
-    return row ? toDomain(row) : null;
-  }
-
-  async create(tenantId: string, canvasId: string, name: string): Promise<AtelierCanvas> {
-    const db = await this.getDb(tenantId);
-    const row = await db.atelierCanvas.upsert({
-      where: { organizationId_id: { organizationId: tenantId, id: canvasId } },
-      create: {
-        id: canvasId,
-        organizationId: tenantId,
-        name,
-        scene: EMPTY_SCENE,
-        thumbnail: null,
-      },
-      update: {},
-    });
-    return toDomain(row);
-  }
-
-  async save(
-    tenantId: string,
-    canvasId: string,
-    scene: CanvasScene,
-    thumbnail?: string,
-  ): Promise<AtelierCanvas> {
-    const db = await this.getDb(tenantId);
-    const row = await db.atelierCanvas.upsert({
-      where: { organizationId_id: { organizationId: tenantId, id: canvasId } },
-      create: {
-        id: canvasId,
-        organizationId: tenantId,
-        name: canvasId,
-        scene,
-        thumbnail: thumbnail ?? null,
-      },
-      update: { scene, thumbnail: thumbnail ?? null },
-    });
-    return toDomain(row);
-  }
-
-  async list(tenantId: string): Promise<readonly AtelierCanvas[]> {
-    const db = await this.getDb(tenantId);
-    const rows = await db.atelierCanvas.findMany({
-      where: { organizationId: tenantId },
-    });
-    return rows.map(toDomain);
-  }
-}

package/src/types.ts

@@ -1,92 +0,0 @@
-/**
- * Scene model for the creative canvas.
- *
- * A narrow, transport-stable subset of the Excalidraw element shape — enough
- * to place agent-generated media deterministically on the server without
- * pulling Excalidraw as a server dependency. The browser holds the full
- * Excalidraw scene; the server is authoritative only for *placement* and
- * *persistence*, exactly the property that makes refresh == realtime.
- */
-
-export type CanvasElementType = "image" | "embeddable" | "text";
-
-export interface CanvasElement {
-  readonly id: string;
-  readonly type: CanvasElementType;
-  /** Top-left x in scene coordinates. */
-  readonly x: number;
-  /** Top-left y in scene coordinates. */
-  readonly y: number;
-  readonly width: number;
-  readonly height: number;
-  /**
-   * For `image` — a file id resolvable in `scene.files`.
-   * For `embeddable` — the media URL (video).
-   * For `text` — the literal string.
-   */
-  readonly ref: string;
-  /** Free-form, provider/agent attribution (prompt, model, etc.). */
-  readonly meta?: Readonly<Record<string, unknown>>;
-}
-
-export interface CanvasFile {
-  readonly id: string;
-  readonly mimeType: string;
-  /** `data:` URI or remote URL. */
-  readonly dataURL: string;
-}
-
-export interface CanvasScene {
-  readonly elements: readonly CanvasElement[];
-  readonly files: readonly CanvasFile[];
-}
-
-export interface AtelierCanvas {
-  readonly id: string;
-  /** Owning organization — every read/write is scoped by this. */
-  readonly tenantId: string;
-  readonly name: string;
-  readonly scene: CanvasScene;
-  /** Latest generated asset, for list/grid previews. */
-  readonly thumbnail?: string;
-  readonly updatedAt: Date;
-}
-
-/** Size of an element to be placed. */
-export interface ElementSize {
-  readonly width: number;
-  readonly height: number;
-}
-
-/** Resolved top-left position in scene coordinates. */
-export interface Placement {
-  readonly x: number;
-  readonly y: number;
-}
-
-/**
- * The minimal patch produced by a server-side placement. Persisted *before*
- * it is broadcast, so the websocket message is a pure UI optimization: a
- * client that missed it recovers the identical state on reload.
- */
-export interface ScenePatch {
-  readonly canvasId: string;
-  readonly tenantId: string;
-  readonly element: CanvasElement;
-  readonly file?: CanvasFile;
-  readonly thumbnail?: string;
-}
-
-/** Tenant-scoped persistence boundary (repository pattern). */
-export interface CanvasStore {
-  get(tenantId: string, canvasId: string): Promise<AtelierCanvas | null>;
-  create(tenantId: string, canvasId: string, name: string): Promise<AtelierCanvas>;
-  /** Replace the persisted scene + thumbnail for a canvas. */
-  save(
-    tenantId: string,
-    canvasId: string,
-    scene: CanvasScene,
-    thumbnail?: string,
-  ): Promise<AtelierCanvas>;
-  list(tenantId: string): Promise<readonly AtelierCanvas[]>;
-}

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "target": "esnext",
-    "types": ["node"],
-    "incremental": false
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsup.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts", "src/store/memory.ts", "src/store/prisma.ts", "src/agent/index.ts"],
-  format: ["esm"],
-  dts: true,
-  sourcemap: true,
-  clean: true,
-  target: "es2022",
-  external: ["@nebutra/logger", "@nebutra/agents"],
-});