fix: upload local canvas references before generate

Same-origin demo assets now follow the just-in-time upload path, and a failed run can reuse files already uploaded for the project.

Author: erickkkyt

messages/en.json

@@ -291,6 +291,7 @@
         "promptTooLong": "Prompt must be shorter than {maxChars} characters.",
         "promptRequired": "Please enter a prompt.",
         "imageReferencesPending": "Generate the connected upstream image before running this node.",
+        "localReferenceExpired": "A connected file is only on this page. Re-add it and generate again.",
         "imageModelOnlySupportsImageReference": "The current image model only supports image references. This run will continue as text-only generation.",
         "videoContinuationUnsupported": "The current video model does not support video continuation. Switch to a model with video input support.",
         "statusRequestFailed": "Failed to query task status.",

messages/zh.json

@@ -292,6 +292,7 @@
         "promptTooLong": "提示词需少于 {maxChars} 个字符。",
         "promptRequired": "请输入提示词。",
         "imageReferencesPending": "请先生成已连接的上游图片，再运行当前节点。",
+        "localReferenceExpired": "有参考文件只存在于当前页面，请重新添加后再生成。",
         "imageModelOnlySupportsImageReference": "当前图片模型只支持图片参考，本次将按文本生成。",
         "videoContinuationUnsupported": "当前视频模型不支持视频续写，请切换到支持视频输入的模型。",
         "statusRequestFailed": "查询任务状态失败。",

src/core/beatcanvas/generation-controller.ts

@@ -32,6 +32,7 @@ import {
   resolveReferencePayload,
 } from '@/core/beatcanvas/canvas-workflows';
 import { isDraftBusyStatus } from '@/core/beatcanvas/composer';
+import { isLocalWorkspaceMediaUrl } from '@/core/beatcanvas/local-references';
 
 export type StudioJobStatus = CanvasCardStatus;
 
@@ -225,7 +226,10 @@ export const buildGenerationEffectInput = async ({
 
   const referenceCards = draftCard.referenceCardIds
     .map((cardId) => canvasCards[cardId])
-    .filter((card): card is CanvasCard => Boolean(card?.url))
+    .filter(
+      (card): card is CanvasCard =>
+        Boolean(card?.url) && !isLocalWorkspaceMediaUrl(card.url)
+    )
     .map((card) => toWorkflowReferenceCard(card));
 
   const referencePayload = resolveReferencePayload({
@@ -572,6 +576,18 @@ export const runDraftGeneration = async ({
           translate('messages.requestValidationFailed')
         );
       }
+      const unresolvedLocalReference = preparedCard.referenceCardIds.some(
+        (cardId) => {
+          const card = getCurrentCard(cardId);
+          return Boolean(card?.url) && isLocalWorkspaceMediaUrl(card.url);
+        }
+      );
+      if (unresolvedLocalReference) {
+        throw new GenerationFailure(
+          'storage',
+          translate('messages.localReferenceExpired')
+        );
+      }
       input = preparedRequest.input;
     }
 

src/core/beatcanvas/local-references.test.ts

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import type { CanvasCard, CanvasDraftCard } from './canvas-types';
+import {
+  getPendingDraftReferenceUploadCount,
+  isLocalWorkspaceMediaUrl,
+  promotePendingDraftReferenceUploads,
+} from './local-references';
+
+const draft = {
+  id: 'draft-1',
+  kind: 'generation',
+  type: 'image',
+  referenceCardIds: ['character-card', 'outfit-05', 'bg-05'],
+} as CanvasDraftCard;
+
+const localCard = (id: string, url: string): CanvasCard =>
+  ({
+    id,
+    kind: 'asset',
+    type: 'image',
+    name: id,
+    url,
+    referenceCardIds: [],
+  }) as CanvasCard;
+
+test('counts same-origin demo assets as just-in-time uploads', () => {
+  assert.equal(
+    getPendingDraftReferenceUploadCount({
+      draftCard: draft,
+      cardsById: {
+        'character-card': localCard(
+          'character-card',
+          '/demo-assets/character.png'
+        ),
+        'outfit-05': localCard('outfit-05', '/demo-assets/outfit.png'),
+        'bg-05': localCard('bg-05', '/demo-assets/bg.png'),
+      },
+      pendingUploadsByCardId: {},
+    }),
+    3
+  );
+  assert.equal(isLocalWorkspaceMediaUrl('/demo-assets/character.png'), true);
+  assert.equal(
+    isLocalWorkspaceMediaUrl('https://media.beatapi.io/inputs/file.png'),
+    false
+  );
+});
+
+test('uploads local demo assets through the generation intent', async () => {
+  const uploaded: string[] = [];
+  const promotions = await promotePendingDraftReferenceUploads({
+    draftCard: draft,
+    cardsById: {
+      'character-card': localCard(
+        'character-card',
+        '/demo-assets/character.png'
+      ),
+      'outfit-05': localCard('outfit-05', '/demo-assets/outfit.png'),
+      'bg-05': localCard('bg-05', 'https://media.beatapi.io/keep.png'),
+    },
+    pendingUploadsByCardId: {},
+    projectId: 'project-1',
+    generationIntentToken: 'intent-1',
+    fetchImpl: async (input) =>
+      new Response(new Uint8Array([1, 2, 3]), {
+        status: 200,
+        headers: { 'content-type': 'image/png' },
+      }),
+    uploadFileFromBrowserImpl: async (file) => {
+      uploaded.push(file.name);
+      return { url: `https://media.beatapi.io/${file.name}`, key: file.name };
+    },
+  });
+
+  assert.deepEqual(uploaded, ['character.png', 'outfit.png']);
+  assert.equal(promotions.length, 2);
+  assert.equal(
+    promotions[0]?.uploadResult.url,
+    'https://media.beatapi.io/character.png'
+  );
+});

src/core/beatcanvas/local-references.ts

@@ -9,6 +9,42 @@ export type PendingLocalReferenceUpload = {
 };
 
 type UploadFileFromBrowserImpl = typeof uploadFileFromBrowser;
+type FetchImpl = typeof fetch;
+
+export const isTransientCanvasUrl = (url: string | null | undefined) =>
+  typeof url === 'string' &&
+  (url.startsWith('blob:') || url.startsWith('data:'));
+
+export const isLocalWorkspaceMediaUrl = (url: string | null | undefined) => {
+  if (!url) return false;
+  if (isTransientCanvasUrl(url)) return true;
+  if (url.startsWith('/') && !url.startsWith('//')) return true;
+  try {
+    const parsed = new URL(url);
+    const origin =
+      typeof window !== 'undefined' && window.location?.origin
+        ? window.location.origin
+        : '';
+    if (origin) return parsed.origin === origin;
+    return ['localhost', '127.0.0.1', '::1'].includes(parsed.hostname);
+  } catch {
+    return false;
+  }
+};
+
+const needsJustInTimeUpload = ({
+  card,
+  pendingUpload,
+}: {
+  card: CanvasCard | undefined;
+  pendingUpload?: PendingLocalReferenceUpload;
+}) => {
+  if (!card || card.kind === 'generation') return false;
+  if (pendingUpload && (!card.url || isTransientCanvasUrl(card.url))) {
+    return true;
+  }
+  return Boolean(card.url && isLocalWorkspaceMediaUrl(card.url));
+};
 
 export const getPendingDraftReferenceUploadCount = ({
   draftCard,
@@ -24,22 +60,34 @@ export const getPendingDraftReferenceUploadCount = ({
   for (const cardId of draftCard.referenceCardIds) {
     if (seenCardIds.has(cardId)) continue;
     seenCardIds.add(cardId);
-    const card = cardsById[cardId];
     if (
-      pendingUploadsByCardId[cardId] &&
-      card &&
-      card.kind !== 'generation' &&
-      (!card.url || isTransientCanvasUrl(card.url))
+      needsJustInTimeUpload({
+        card: cardsById[cardId],
+        pendingUpload: pendingUploadsByCardId[cardId],
+      })
     ) {
       count += 1;
     }
   }
   return count;
 };
 
-export const isTransientCanvasUrl = (url: string | null | undefined) =>
-  typeof url === 'string' &&
-  (url.startsWith('blob:') || url.startsWith('data:'));
+const fileFromWorkspaceUrl = async (
+  url: string,
+  fetchImpl: FetchImpl
+): Promise<File> => {
+  const response = await fetchImpl(url);
+  if (!response.ok) {
+    throw new Error('Failed to read a local canvas reference');
+  }
+  const blob = await response.blob();
+  const filename = decodeURIComponent(
+    url.split('/').pop()?.split('?')[0] || 'reference'
+  );
+  return new File([blob], filename, {
+    type: blob.type || 'application/octet-stream',
+  });
+};
 
 export const promotePendingDraftReferenceUploads = async ({
   draftCard,
@@ -48,13 +96,15 @@ export const promotePendingDraftReferenceUploads = async ({
   projectId,
   generationIntentToken,
   uploadFileFromBrowserImpl = uploadFileFromBrowser,
+  fetchImpl = fetch,
 }: {
   draftCard: CanvasDraftCard;
   cardsById: Record<string, CanvasCard>;
   pendingUploadsByCardId: Record<string, PendingLocalReferenceUpload>;
   projectId: string;
   generationIntentToken: string;
   uploadFileFromBrowserImpl?: UploadFileFromBrowserImpl;
+  fetchImpl?: FetchImpl;
 }): Promise<
   Array<{
     cardId: string;
@@ -77,16 +127,22 @@ export const promotePendingDraftReferenceUploads = async ({
 
     const pendingUpload = pendingUploadsByCardId[cardId];
     const card = cardsById[cardId];
-    if (!pendingUpload || !card || card.kind === 'generation') {
+    if (
+      !needsJustInTimeUpload({
+        card,
+        pendingUpload,
+      })
+    ) {
       continue;
     }
 
-    if (card.url && !isTransientCanvasUrl(card.url)) {
-      continue;
-    }
+    const file =
+      pendingUpload && (!card.url || isTransientCanvasUrl(card.url))
+        ? pendingUpload.file
+        : await fileFromWorkspaceUrl(card.url as string, fetchImpl);
 
     const uploadResult = await uploadFileFromBrowserImpl(
-      pendingUpload.file,
+      file,
       'beatcanvas/uploads',
       {
         projectId,
@@ -96,7 +152,7 @@ export const promotePendingDraftReferenceUploads = async ({
 
     promotions.push({
       cardId,
-      objectUrl: pendingUpload.objectUrl,
+      objectUrl: pendingUpload?.objectUrl || card.url || '',
       uploadResult,
     });
   }

src/core/effects/generation-upload-intent.test.ts

@@ -228,6 +228,65 @@ test('zero-upload intents remain valid once and expired intents are rejected', a
   }
 });
 
+test('zero-upload retries can reuse previously uploaded project files', async () => {
+  const { client, db } = await createTestDb();
+  try {
+    const now = new Date(1_000);
+    const firstIntentId = await issueGenerationUploadIntent({
+      projectId: 'project-1',
+      effectId: 301,
+      expectedUploadCount: 1,
+      now,
+      dbClient: db,
+    });
+    const slotId = await claimGenerationUploadSlot({
+      intentId: firstIntentId,
+      projectId: 'project-1',
+      now: new Date(2_000),
+      dbClient: db,
+    });
+    assert.ok(slotId);
+    assert.equal(
+      await completeGenerationUploadSlot({
+        intentId: firstIntentId,
+        upload: {
+          slotId,
+          provider: 'beatapi',
+          bucket: 'beatapi',
+          key: 'inputs/retry.png',
+          url: 'https://media.beatapi.io/inputs/retry.png',
+          filename: 'retry.png',
+          mimeType: 'image/png',
+          sizeBytes: 123,
+        },
+        now: new Date(3_000),
+        dbClient: db,
+      }),
+      true
+    );
+
+    const retryIntentId = await issueGenerationUploadIntent({
+      projectId: 'project-1',
+      effectId: 302,
+      expectedUploadCount: 0,
+      now: new Date(4_000),
+      dbClient: db,
+    });
+    assert.ok(
+      await consumeGenerationUploadIntent({
+        intentId: retryIntentId,
+        projectId: 'project-1',
+        effectId: 302,
+        referencedUrls: ['https://media.beatapi.io/inputs/retry.png'],
+        now: new Date(5_000),
+        dbClient: db,
+      })
+    );
+  } finally {
+    client.close();
+  }
+});
+
 test('limits active upload authorizations per project', async () => {
   const { client, db } = await createTestDb();
   try {