@smartcat/sanity-plugin 1.0.0 → 1.0.1

package/src/export/export.test.ts

@@ -0,0 +1,537 @@
+import {describe, expect, it, vi} from 'vitest'
+import {runExportUpload, UPLOAD_CHUNK_CONCURRENCY, type SanityLikeClient, type SmartcatExportClient} from './index'
+import {SmartcatError} from '../smartcat/client'
+import type {SmartcatDocument, SmartcatProject} from '../smartcat/types'
+
+function fakeSanity(project: unknown) {
+  const sets: Record<string, unknown>[] = []
+  const unsets: string[][] = []
+  const client: SanityLikeClient = {
+    fetch: vi.fn(async () => project) as never,
+    patch: () => {
+      const attrs: Record<string, unknown> = {}
+      const p = {
+        set: (a: Record<string, unknown>) => {
+          Object.assign(attrs, a)
+          return p
+        },
+        unset: (keys: string[]) => {
+          unsets.push(keys)
+          return p
+        },
+        commit: async () => {
+          sets.push(attrs)
+          return {}
+        },
+      }
+      return p
+    },
+  }
+  return {client, sets, unsets}
+}
+
+// Stateful Smartcat fake. `getProject` reflects documents created so far; names
+// encode the source-id prefix exactly as buildLocjsonFilename does.
+function fakeSmartcat(initialDocs: SmartcatDocument[] = []) {
+  const uploads: {filename: string; body: string}[] = []
+  const updates: {documentId: string; filename: string; body: string}[] = []
+  const deletes: string[] = []
+  const docs = [...initialDocs]
+  let guid = 0
+  const project: SmartcatProject = {
+    id: 'guid-1',
+    name: 'Spring (1)',
+    workflowStages: [{id: 'st-tr', stageType: 'translation'}],
+    documents: docs,
+  }
+  const client: SmartcatExportClient = {
+    createProject: vi.fn(async () => ({id: 'guid-1'})),
+    uploadDocument: vi.fn(async (_p: string, filename: string, body: string) => {
+      uploads.push({filename, body})
+      const leaf = filename.split('/').pop()!.replace(/\.[^.]+$/, '')
+      const id = `gNew${++guid}_12`
+      docs.push({id, name: leaf, targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 0}]})
+      return [{id, targetLanguage: 'fr'}]
+    }),
+    uploadDocuments: vi.fn(async (_p: string, files: {filename: string; content: string}[]) => {
+      const out: SmartcatDocument[] = []
+      for (const f of files) {
+        uploads.push({filename: f.filename, body: f.content})
+        const leaf = f.filename.split('/').pop()!.replace(/\.[^.]+$/, '')
+        const id = `gNew${++guid}_12`
+        const doc = {id, name: leaf, targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 0}]}
+        docs.push(doc)
+        out.push({id, name: leaf, targetLanguage: 'fr'})
+      }
+      return out
+    }),
+    updateDocument: vi.fn(async (documentId: string, filename: string, body: string) => {
+      updates.push({documentId, filename, body})
+      return [{id: documentId}]
+    }),
+    deleteDocument: vi.fn(async (documentId: string) => {
+      deletes.push(documentId)
+      // One id removes the whole document (all language entries sharing the guid).
+      const guidPart = documentId.slice(0, documentId.lastIndexOf('_'))
+      for (let i = docs.length - 1; i >= 0; i--) {
+        if (docs[i].id.startsWith(`${guidPart}_`)) docs.splice(i, 1)
+      }
+    }),
+    getProject: vi.fn(async () => project),
+    projectUrl: (id) => `https://us.smartcat.com/projects/${id}/general`,
+  }
+  return {client, uploads, updates, deletes, docs}
+}
+
+const ABOUT = {sourceDocId: 'about123-aaaa', title: 'About', filename: 'page/About-about123.locjson', locjson: '{"units":[]}'}
+const CONTACT = {sourceDocId: 'contact1-bbbb', title: 'Contact', filename: 'page/Contact-contact1.locjson', locjson: '{"units":[]}'}
+
+describe('runExportUpload — first sync', () => {
+  it('creates the project, uploads the outbox, syncs the name back, marks sent', async () => {
+    const project = {_id: 'p1', name: 'Spring', sourceLanguage: 'en', targetLanguages: ['fr'], outbox: [ABOUT, CONTACT]}
+    const {client: sanity, sets, unsets} = fakeSanity(project)
+    const {client: smartcat, uploads, updates} = fakeSmartcat()
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(smartcat.createProject).toHaveBeenCalledWith({
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      workflowStages: ['translation', 'postediting'],
+    })
+    expect(uploads.map((u) => u.filename)).toEqual([ABOUT.filename, CONTACT.filename])
+    expect(updates).toHaveLength(0)
+    expect(result).toEqual({smartcatProjectId: 'guid-1', created: 2, updated: 0, deleted: 0, failed: 0})
+
+    const set = sets.at(-1)!
+    expect(set.status).toBe('sent')
+    expect(set.smartcatProjectId).toBe('guid-1')
+    expect(set.smartcatProjectUrl).toBe('https://us.smartcat.com/projects/guid-1/general')
+    expect(set.name).toBe('Spring (1)') // de-duplicated name mirrored back
+    expect(unsets.at(-1)).toEqual(['outbox', 'pendingDeletions'])
+
+    const progress = set.progress as {sourceDocId: string; targets: {language: string; smartcatDocumentId?: string}[]}[]
+    expect(progress.map((p) => p.sourceDocId)).toEqual(['about123-aaaa', 'contact1-bbbb'])
+    expect(progress[0].targets[0]).toMatchObject({language: 'fr', smartcatDocumentId: 'gNew1_12'})
+  })
+
+  it('maps Sanity ids to Smartcat codes for createProject', async () => {
+    const project = {
+      _id: 'p1',
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr', 'PL-PL'],
+      smartcatLanguages: [
+        {sanityId: 'en', smartcatLanguage: 'en'},
+        {sanityId: 'fr', smartcatLanguage: 'fr'},
+        {sanityId: 'PL-PL', smartcatLanguage: 'pl'},
+      ],
+      outbox: [ABOUT],
+    }
+    const {client: sanity} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+
+    await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(smartcat.createProject).toHaveBeenCalledWith({
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr', 'pl'], // PL-PL → pl
+      workflowStages: ['translation', 'postediting'],
+    })
+  })
+
+  it('passes a chosen template id to createProject (omitting workflow stages)', async () => {
+    const project = {
+      _id: 'p1',
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      workflow: 'template:tmpl-123',
+      outbox: [ABOUT],
+    }
+    const {client: sanity} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+
+    await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(smartcat.createProject).toHaveBeenCalledWith({
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      templateId: 'tmpl-123',
+    })
+  })
+
+  it('uses a single translation stage for the AI-only standard workflow', async () => {
+    const project = {
+      _id: 'p1',
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      workflow: 'standard:ai',
+      outbox: [ABOUT],
+    }
+    const {client: sanity} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+
+    await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(smartcat.createProject).toHaveBeenCalledWith({
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      workflowStages: ['translation'],
+    })
+  })
+
+  it('persists the new project id before uploading, so a failed run does not duplicate it', async () => {
+    const project = {_id: 'p1', name: 'Spring', sourceLanguage: 'en', targetLanguages: ['fr'], outbox: [ABOUT]}
+    const {client: sanity, sets} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+    // Make the only upload fail after the project has been created — both batch
+    // attempts and the per-file fallback all reject.
+    ;(smartcat.uploadDocuments as ReturnType<typeof vi.fn>)
+      .mockRejectedValueOnce(new Error('network blip'))
+      .mockRejectedValueOnce(new Error('network blip'))
+    ;(smartcat.uploadDocument as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('network blip'))
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T', sleep: async () => {}})
+
+    // The project id was committed before the upload that failed, so a re-send reuses it.
+    expect(smartcat.createProject).toHaveBeenCalledTimes(1)
+    expect(sets.some((s) => s.smartcatProjectId === 'guid-1')).toBe(true)
+    // A per-document write failure is recorded but does NOT fail the whole project.
+    expect(result).toMatchObject({created: 0, failed: 1})
+    expect(sets.at(-1)?.status).toBe('sent')
+    expect(sets.at(-1)?.lastError).toBeNull()
+  })
+
+  it('reuses an existing Smartcat project instead of creating a second one on re-run', async () => {
+    // Same project, but now it already carries a smartcatProjectId (persisted by a prior run).
+    const project = {
+      _id: 'p1',
+      name: 'Spring',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      smartcatProjectId: 'guid-1',
+      outbox: [ABOUT],
+    }
+    const {client: sanity} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+
+    await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(smartcat.createProject).not.toHaveBeenCalled()
+  })
+
+  it('settles to draft (not error) when there is nothing to sync', async () => {
+    const {client: sanity, sets} = fakeSanity({_id: 'p1', targetLanguages: ['fr'], outbox: []})
+    const {client: smartcat} = fakeSmartcat()
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1'})
+    expect(result).toMatchObject({created: 0, updated: 0, deleted: 0})
+    expect(smartcat.createProject).not.toHaveBeenCalled()
+    expect(sets.at(-1)?.status).toBe('draft')
+    expect(sets.at(-1)?.lastError).toBeNull()
+  })
+
+  it('keeps an already-linked project at "sent" when there is nothing to sync', async () => {
+    const {client: sanity, sets} = fakeSanity({
+      _id: 'p1',
+      targetLanguages: ['fr'],
+      outbox: [],
+      smartcatProjectId: 'guid-1',
+    })
+    const {client: smartcat} = fakeSmartcat()
+    await runExportUpload({sanity, smartcat, projectId: 'p1'})
+    expect(sets.at(-1)?.status).toBe('sent')
+  })
+
+  it('captures a freshly-uploaded doc (and its title) even when getProject lags on indexing', async () => {
+    // The upload response carries the new doc, but getProject hasn't indexed it
+    // yet — the title (outbox-only) must still land in progress this run.
+    const project = {_id: 'p1', name: 'Spring', sourceLanguage: 'en', targetLanguages: ['fr'], outbox: [ABOUT]}
+    const {client: sanity, sets} = fakeSanity(project)
+    const smartcat: SmartcatExportClient = {
+      createProject: vi.fn(async () => ({id: 'guid-1'})),
+      uploadDocument: vi.fn(async () => [{id: 'gNew1_12', targetLanguage: 'fr'}]),
+      // Batch response carries the created doc's own name — set-wise correlation
+      // captures the title from it while getProject reports no documents yet.
+      uploadDocuments: vi.fn(async () => [{id: 'gNew1_12', name: 'About-about123', targetLanguage: 'fr'}]),
+      updateDocument: vi.fn(async () => []),
+      deleteDocument: vi.fn(async () => {}),
+      // …getProject still reports no documents (indexing lag).
+      getProject: vi.fn(async () => ({id: 'guid-1', name: 'Spring', workflowStages: [], documents: []})),
+      projectUrl: (id) => `https://us.smartcat.com/projects/${id}/general`,
+    }
+
+    await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    const set = sets.at(-1)!
+    const progress = set.progress as {sourceDocId: string; title?: string; targets: {language: string; smartcatDocumentId?: string}[]}[]
+    expect(progress).toHaveLength(1)
+    expect(progress[0]).toMatchObject({sourceDocId: 'about123-aaaa', title: 'About'})
+    expect(progress[0].targets[0]).toMatchObject({language: 'fr', smartcatDocumentId: 'gNew1_12'})
+  })
+})
+
+describe('runExportUpload — re-sync (existing project)', () => {
+  it('reuses the project and updates existing docs in place, without re-creating', async () => {
+    const project = {
+      _id: 'p1',
+      name: 'Spring (1)',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      smartcatProjectId: 'guid-1',
+      smartcatProjectUrl: 'https://us.smartcat.com/projects/guid-1/general',
+      outbox: [ABOUT, CONTACT],
+      progress: [],
+    }
+    const {client: sanity, sets} = fakeSanity(project)
+    // Both source files already exist in Smartcat.
+    const {client: smartcat, uploads, updates} = fakeSmartcat([
+      {id: 'gA_12', name: 'About-about123', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 50}]},
+      {id: 'gC_12', name: 'Contact-contact1', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 100}]},
+    ])
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(smartcat.createProject).not.toHaveBeenCalled()
+    expect(uploads).toHaveLength(0)
+    expect(updates.map((u) => u.documentId).sort()).toEqual(['gA_12', 'gC_12'])
+    expect(result).toEqual({smartcatProjectId: 'guid-1', created: 0, updated: 2, deleted: 0, failed: 0})
+
+    const set = sets.at(-1)!
+    expect(set.status).toBe('sent')
+    expect(set.name).toBe('Spring (1)') // Smartcat name mirrored back on every sync
+  })
+
+  it('creates only the newly-added item when re-syncing', async () => {
+    const project = {
+      _id: 'p1',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      smartcatProjectId: 'guid-1',
+      outbox: [ABOUT, CONTACT],
+      progress: [],
+    }
+    const {client: sanity, sets} = fakeSanity(project)
+    // Only "About" exists yet; "Contact" is new.
+    const {client: smartcat, uploads, updates} = fakeSmartcat([
+      {id: 'gA_12', name: 'About-about123', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 10}]},
+    ])
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(updates.map((u) => u.documentId)).toEqual(['gA_12'])
+    expect(uploads.map((u) => u.filename)).toEqual([CONTACT.filename])
+    expect(result).toEqual({smartcatProjectId: 'guid-1', created: 1, updated: 1, deleted: 0, failed: 0})
+    expect(sets.at(-1)!.status).toBe('sent')
+  })
+
+  it('keeps syncing other docs and stays "sent" when one update fails (e.g. document lock)', async () => {
+    const project = {
+      _id: 'p1',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      smartcatProjectId: 'guid-1',
+      outbox: [ABOUT, CONTACT],
+      progress: [],
+    }
+    const {client: sanity, sets} = fakeSanity(project)
+    // Both already exist → both go through updateDocument; "About" fails with a 400.
+    const {client: smartcat, updates} = fakeSmartcat([
+      {id: 'gA_12', name: 'About-about123', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 10}]},
+      {id: 'gC_12', name: 'Contact-contact1', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 10}]},
+    ])
+    smartcat.updateDocument = vi.fn(async (documentId: string, filename: string, body: string) => {
+      if (documentId === 'gA_12') {
+        throw new SmartcatError(400, 'Error processing request. Correlation id: abc-123, Trace id: def Invalid input')
+      }
+      updates.push({documentId, filename, body})
+      return [{id: documentId}]
+    })
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    // The good one still synced; the project is NOT marked errored.
+    expect(updates.map((u) => u.documentId)).toEqual(['gC_12'])
+    expect(result).toMatchObject({updated: 1, failed: 1})
+    const set = sets.at(-1)!
+    expect(set.status).toBe('sent')
+    expect(set.lastError).toBeNull()
+    // The failure is visible in the persisted log.
+    const log = JSON.parse(set.functionLog as string) as {level: string; message: string}[]
+    expect(log.some((l) => l.level === 'error' && /Skipped .*About/.test(l.message))).toBe(true)
+  })
+
+  it('logs every Smartcat HTTP call via the request logger, with bodies on failures', async () => {
+    const project = {_id: 'p1', name: 'Spring', sourceLanguage: 'en', targetLanguages: ['fr'], outbox: [ABOUT]}
+    const {client: sanity, sets} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+    // Drive the real request-logger path: the fake forwards calls to the logger.
+    let logger: ((info: {method: string; path: string; status: number; body: string}) => void) | undefined
+    smartcat.setRequestLogger = (fn) => {
+      logger = fn
+    }
+    // ABOUT is a create (no existing Smartcat doc), so it goes through the batch
+    // upload path — override that method to drive the logger.
+    smartcat.uploadDocuments = vi.fn(async () => {
+      logger?.({method: 'POST', path: '/api/integration/v1/project/document', status: 200, body: '[]'})
+      return [{id: 'gNew_12', targetLanguage: 'fr'}]
+    })
+
+    await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    const log = JSON.parse(sets.at(-1)!.functionLog as string) as {level: string; message: string}[]
+    expect(log.some((l) => l.level === 'info' && l.message === 'POST /api/integration/v1/project/document → 200')).toBe(true)
+  })
+
+  it('deletes marked documents from Smartcat and unsets the items', async () => {
+    const project = {
+      _id: 'p1',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      smartcatProjectId: 'guid-1',
+      // Only About remains in the outbox; Contact is marked for deletion.
+      outbox: [ABOUT],
+      pendingDeletions: [{itemKey: 'item-contact', sourceDocId: 'contact1-bbbb', smartcatDocumentId: 'gC_12'}],
+      progress: [],
+    }
+    const {client: sanity, sets, unsets} = fakeSanity(project)
+    const {client: smartcat, deletes} = fakeSmartcat([
+      {id: 'gA_12', name: 'About-about123', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 10}]},
+      {id: 'gC_12', name: 'Contact-contact1', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 0}]},
+    ])
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+
+    expect(deletes).toEqual(['gC_12'])
+    expect(result.deleted).toBe(1)
+    // The deleted item and the transient fields are unset.
+    expect(unsets.at(-1)).toEqual(['outbox', 'pendingDeletions', 'items[_key=="item-contact"]'])
+  })
+
+  it('allows a delete-only re-sync (empty outbox)', async () => {
+    const project = {
+      _id: 'p1',
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      smartcatProjectId: 'guid-1',
+      outbox: [],
+      pendingDeletions: [{itemKey: 'item-a', sourceDocId: 'about123-aaaa', smartcatDocumentId: 'gA_12'}],
+      progress: [],
+    }
+    const {client: sanity, sets} = fakeSanity(project)
+    const {client: smartcat, deletes} = fakeSmartcat([
+      {id: 'gA_12', name: 'About-about123', targetLanguage: 'fr', workflowStages: [{id: 'st-tr', progress: 0}]},
+    ])
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T'})
+    expect(deletes).toEqual(['gA_12'])
+    expect(result).toEqual({smartcatProjectId: 'guid-1', created: 0, updated: 0, deleted: 1, failed: 0})
+    expect(sets.at(-1)!.status).toBe('sent')
+  })
+})
+
+describe('runExportUpload — chunked create path', () => {
+  it('uploads >UPLOAD_CHUNK_SIZE creates in multiple batches', async () => {
+    const outbox = Array.from({length: 120}, (_, i) => ({
+      sourceDocId: `doc${i}-${String(i).padStart(4, '0')}`,
+      title: `Doc ${i}`,
+      filename: `page/Doc${i}-doc${i}.locjson`,
+      locjson: '{"units":[]}',
+    }))
+    const project = {_id: 'p1', name: 'Big', sourceLanguage: 'en', targetLanguages: ['fr'], outbox}
+    const {client: sanity} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T', sleep: async () => {}})
+
+    expect((smartcat.uploadDocuments as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(3) // 50+50+20
+    expect(result).toMatchObject({created: 120, failed: 0})
+  })
+
+  it('retries once as a batch before falling back', async () => {
+    const project = {_id: 'p1', name: 'Big', sourceLanguage: 'en', targetLanguages: ['fr'], outbox: [ABOUT, CONTACT]}
+    const {client: sanity, sets} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+    ;(smartcat.uploadDocuments as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('blip'))
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T', sleep: async () => {}})
+
+    expect((smartcat.uploadDocuments as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(2) // attempt + retry
+    expect(smartcat.uploadDocument).not.toHaveBeenCalled()
+    expect(result).toMatchObject({created: 2, failed: 0})
+    expect(sets.at(-1)?.status).toBe('sent')
+  })
+
+  it('falls back to per-file after both batch attempts fail; one poison file → failed++', async () => {
+    const project = {_id: 'p1', name: 'Big', sourceLanguage: 'en', targetLanguages: ['fr'], outbox: [ABOUT, CONTACT]}
+    const {client: sanity, sets} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+    ;(smartcat.uploadDocuments as ReturnType<typeof vi.fn>)
+      .mockRejectedValueOnce(new Error('blip'))
+      .mockRejectedValueOnce(new Error('blip'))
+    ;(smartcat.uploadDocument as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('poison')) // ABOUT fails
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T', sleep: async () => {}})
+
+    expect((smartcat.uploadDocument as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(2) // per-file over the chunk
+    expect(result).toMatchObject({created: 1, failed: 1})
+    expect(sets.at(-1)?.status).toBe('sent')
+    const log = JSON.parse(sets.at(-1)!.functionLog as string) as {level: string; message: string}[]
+    expect(log.some((l) => l.level === 'error' && /Skipped .*About/.test(l.message))).toBe(true)
+  })
+
+  it('treats a 409 "already exists" in the per-file fallback as already synced, not failed', async () => {
+    const project = {_id: 'p1', name: 'Big', sourceLanguage: 'en', targetLanguages: ['fr'], outbox: [ABOUT, CONTACT]}
+    const {client: sanity, sets} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+    ;(smartcat.uploadDocuments as ReturnType<typeof vi.fn>)
+      .mockRejectedValueOnce(new Error('blip'))
+      .mockRejectedValueOnce(new Error('blip'))
+    ;(smartcat.uploadDocument as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+      new SmartcatError(409, "A document with the full name 'page/About-about123' already exists."),
+    ) // ABOUT already committed; CONTACT succeeds normally
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T', sleep: async () => {}})
+
+    expect(result).toMatchObject({created: 2, failed: 0})
+    expect(sets.at(-1)?.status).toBe('sent')
+    const log = JSON.parse(sets.at(-1)!.functionLog as string) as {level: string; message: string}[]
+    expect(log.some((l) => l.level === 'success' && /Already synced .*About/.test(l.message))).toBe(true)
+  })
+
+  it('runs create-path chunk uploads with bounded concurrency', async () => {
+    // 700 docs → 14 chunks (chunk size 50), comfortably above UPLOAD_CHUNK_CONCURRENCY
+    // so the cap genuinely limits in-flight requests below the chunk count.
+    const outbox = Array.from({length: 700}, (_, i) => ({
+      sourceDocId: `doc${i}-${String(i).padStart(4, '0')}`,
+      title: `Doc ${i}`,
+      filename: `page/Doc${i}-doc${i}.locjson`,
+      locjson: '{"units":[]}',
+    }))
+    const project = {_id: 'p1', name: 'Big', sourceLanguage: 'en', targetLanguages: ['fr'], outbox}
+    const {client: sanity} = fakeSanity(project)
+    const {client: smartcat} = fakeSmartcat()
+
+    let inFlight = 0
+    let maxInFlight = 0
+    const realUploadDocuments = smartcat.uploadDocuments
+    smartcat.uploadDocuments = vi.fn(async (p: string, files: {filename: string; content: string}[]) => {
+      inFlight++
+      maxInFlight = Math.max(maxInFlight, inFlight)
+      await new Promise((resolve) => setTimeout(resolve, 0))
+      const result = await realUploadDocuments(p, files)
+      inFlight--
+      return result
+    })
+
+    const result = await runExportUpload({sanity, smartcat, projectId: 'p1', now: () => 'T', sleep: async () => {}})
+
+    expect(maxInFlight).toBe(UPLOAD_CHUNK_CONCURRENCY)
+    expect(result.created).toBe(700)
+  })
+})