@smartcat/sanity-plugin 1.0.0 → 1.0.1

package/src/export/index.ts

@@ -0,0 +1,393 @@
+import type {CreateProjectInput, RequestLogger, SmartcatDocument, SmartcatProject} from '../smartcat/types'
+import {SmartcatError} from '../smartcat/client'
+import {buildProgress, sourceIdPrefix, type DocProgress, type ProjectItem} from '../progress/core'
+import {toSmartcatLanguage, type SmartcatLanguageMapping} from '../lib/languageMap'
+import {resolveWorkflowCreateParams} from '../lib/workflow'
+import type {LogLine} from '../lib/log'
+
+/** Source files per multi-file upload request (first-sync create path). */
+const UPLOAD_CHUNK_SIZE = 50
+/** Delay before the single batch retry, ms. */
+const BATCH_RETRY_DELAY_MS = 1000
+/** Create-path chunks uploaded concurrently. A saturation study found upload
+ * throughput scales ~linearly with concurrency only up to ~C=40, where the
+ * Smartcat API's per-workspace rate limit trips (HTTP 429) and effective
+ * throughput collapses. Raising this above ~30 is pointless — the gains are
+ * erased by rate-limiting, and it eats into the shared rate budget of any other
+ * exports running concurrently. 10 is a safe, near-linear default with headroom. */
+export const UPLOAD_CHUNK_CONCURRENCY = 10
+
+function chunk<T>(items: T[], size: number): T[][] {
+  const out: T[][] = []
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size))
+  return out
+}
+
+/** Runs `worker` over `items` with at most `limit` in flight concurrently. */
+async function runWithConcurrency<T>(items: T[], limit: number, worker: (item: T) => Promise<void>): Promise<void> {
+  let next = 0
+  async function runNext(): Promise<void> {
+    const i = next++
+    if (i >= items.length) return
+    await worker(items[i])
+    return runNext()
+  }
+  await Promise.all(Array.from({length: Math.min(limit, items.length)}, () => runNext()))
+}
+
+/** Minimal structural subset of @sanity/client used by the export. */
+export interface SanityLikeClient {
+  fetch<T = unknown>(query: string, params?: Record<string, unknown>): Promise<T>
+  patch(id: string): {
+    set(attrs: Record<string, unknown>): {
+      unset(keys: string[]): {commit(): Promise<unknown>}
+      commit(): Promise<unknown>
+    }
+  }
+}
+
+/** Structural subset of SmartcatClient the export needs. */
+export interface SmartcatExportClient {
+  createProject(input: CreateProjectInput): Promise<{id: string}>
+  uploadDocument(projectId: string, filename: string, content: string): Promise<SmartcatDocument[]>
+  uploadDocuments(projectId: string, files: {filename: string; content: string}[]): Promise<SmartcatDocument[]>
+  updateDocument(documentId: string, filename: string, content: string): Promise<SmartcatDocument[]>
+  deleteDocument(documentId: string): Promise<void>
+  getProject(projectId: string): Promise<SmartcatProject>
+  projectUrl(projectId: string): string
+  /** Optional: receive a trace of every HTTP call for the client-facing log. */
+  setRequestLogger?(logger: RequestLogger): void
+}
+
+interface PendingDeletion {
+  itemKey?: string
+  sourceDocId?: string
+  smartcatDocumentId?: string
+}
+
+export interface RunExportUploadOptions {
+  sanity: SanityLikeClient
+  smartcat: SmartcatExportClient
+  /** `_id` of the `smartcat.translationProject` to export. */
+  projectId: string
+  now?: () => string
+  sleep?: (ms: number) => Promise<void>
+}
+
+export interface RunExportUploadResult {
+  smartcatProjectId: string
+  /** Source files newly created in Smartcat this run. */
+  created: number
+  /** Source files updated in place this run. */
+  updated: number
+  /** Documents deleted from Smartcat this run. */
+  deleted: number
+  /** Documents whose upload/update failed (e.g. Smartcat lock); the rest still synced. */
+  failed: number
+}
+
+const PROJECT_QUERY = `*[_id == $id][0]{
+  _id,
+  name,
+  sourceLanguage,
+  targetLanguages,
+  workflow,
+  smartcatProjectId,
+  smartcatProjectUrl,
+  smartcatLanguages[]{sanityId, smartcatLanguage},
+  outbox[]{sourceDocId, title, filename, locjson},
+  pendingDeletions[]{itemKey, sourceDocId, smartcatDocumentId},
+  progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}
+}`
+
+interface OutboxItem {
+  sourceDocId?: string
+  title?: string
+  filename: string
+  locjson: string
+}
+
+interface ProjectData {
+  _id: string
+  name?: string
+  sourceLanguage?: string
+  targetLanguages?: string[]
+  workflow?: string
+  smartcatProjectId?: string
+  smartcatProjectUrl?: string
+  smartcatLanguages?: SmartcatLanguageMapping[]
+  outbox?: OutboxItem[]
+  pendingDeletions?: PendingDeletion[]
+  progress?: DocProgress[]
+}
+
+/** A source file maps to one Smartcat document id we can update in place. */
+function existingDocIdsBySource(scProject: SmartcatProject, outbox: OutboxItem[]): Map<string, string> {
+  // Index Smartcat documents by the source-id prefix in their filename, keeping
+  // one representative id per source file (all target-language docs share a source).
+  const idByPrefix = new Map<string, string>()
+  for (const doc of scProject.documents ?? []) {
+    const prefix = sourceIdPrefix(doc)
+    if (prefix && doc.id && !idByPrefix.has(prefix)) idByPrefix.set(prefix, doc.id)
+  }
+  const result = new Map<string, string>()
+  for (const item of outbox) {
+    if (!item.sourceDocId) continue
+    const id = idByPrefix.get(stripDraft(item.sourceDocId).slice(0, 8))
+    if (id) result.set(item.sourceDocId, id)
+  }
+  return result
+}
+
+function stripDraft(id: string): string {
+  return id.replace(/^drafts\./, '')
+}
+
+/**
+ * Merges the documents Smartcat returned from this run's writes into the
+ * authoritative `getProject` list. The fetched docs win (they carry workflow
+ * stages); written docs are added only when the fetch hasn't indexed them yet,
+ * so a freshly-created document — and its title — isn't dropped this run.
+ */
+function mergeWrittenDocs(authoritative: SmartcatDocument[], written: SmartcatDocument[]): SmartcatDocument[] {
+  const byId = new Map(authoritative.filter((d) => d.id).map((d) => [d.id, d]))
+  for (const d of written) if (d.id && !byId.has(d.id)) byId.set(d.id, d)
+  return [...byId.values()]
+}
+
+/**
+ * Thin export step run by a Sanity Function: takes the LocJSON files the browser
+ * prepared (in `outbox`) and syncs them to Smartcat.
+ *
+ * - **First sync** (no `smartcatProjectId`): creates the Smartcat project and
+ *   uploads each file, then mirrors Smartcat's (possibly de-duplicated) project
+ *   name back onto the Sanity project.
+ * - **Re-sync** (project already exists): reuses it — updating documents that are
+ *   already there (Smartcat merges changes, preserving existing translations) and
+ *   creating any newly-added items. Never creates a second Smartcat project.
+ *
+ * Does no content processing, so it depends only on the Smartcat client.
+ */
+export async function runExportUpload(options: RunExportUploadOptions): Promise<RunExportUploadResult> {
+  const {
+    sanity,
+    smartcat,
+    projectId,
+    now = () => new Date().toISOString(),
+    sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+  } = options
+  const log: LogLine[] = []
+
+  // Trace every Smartcat HTTP call into the client-facing log. Successful calls
+  // are a single info line; failures show "Error <status> while performing …"
+  // (red) with the raw response body on the line below.
+  smartcat.setRequestLogger?.(({method, path, status, body}) => {
+    if (status >= 200 && status < 300) {
+      log.push({level: 'info', message: `${method} ${path} → ${status}`})
+    } else {
+      log.push({level: 'error', message: `Error ${status} while performing ${method} ${path}`})
+      if (body) log.push({level: 'error', indent: true, message: body})
+    }
+  })
+
+  const project = await sanity.fetch<ProjectData | null>(PROJECT_QUERY, {id: projectId})
+  if (!project) throw new Error(`Translation project ${projectId} not found`)
+
+  try {
+    const outbox = project.outbox ?? []
+    const deletions = project.pendingDeletions ?? []
+    if (outbox.length === 0 && deletions.length === 0) {
+      // Not an error: every queued document resolved to zero translatable units
+      // (e.g. empty source content), so there's nothing to send. Settle back to a
+      // resting status and explain why, rather than failing the project.
+      const status = project.smartcatProjectId ? 'sent' : 'draft'
+      log.push({level: 'skip', message: 'Nothing to sync — no documents with translatable content'})
+      await sanity
+        .patch(projectId)
+        .set({status, lastExportAt: now(), lastError: null, functionLog: JSON.stringify(log)})
+        .unset(['outbox', 'pendingDeletions'])
+        .commit()
+      return {smartcatProjectId: project.smartcatProjectId ?? '', created: 0, updated: 0, deleted: 0, failed: 0}
+    }
+    log.push({level: 'info', message: `Syncing ${outbox.length} file(s)${deletions.length ? ` · ${deletions.length} deletion(s)` : ''} to Smartcat`})
+
+    const isNew = !project.smartcatProjectId
+    let scProjectId = project.smartcatProjectId
+    let scProjectUrl = project.smartcatProjectUrl
+
+    if (isNew) {
+      const sourceLanguage = project.sourceLanguage
+      if (!sourceLanguage) throw new Error('No source language set on the project')
+      const targetLanguages = project.targetLanguages ?? []
+      if (targetLanguages.length === 0) throw new Error('No target languages set on the project')
+      // Send Smartcat its own language codes (the project carries the mapping).
+      const map = project.smartcatLanguages
+      log.push({level: 'info', message: `Creating Smartcat project "${project.name || 'Sanity translation project'}"`})
+      const createdProject = await smartcat.createProject({
+        name: project.name || 'Sanity translation project',
+        sourceLanguage: toSmartcatLanguage(map, sourceLanguage),
+        targetLanguages: targetLanguages.map((id) => toSmartcatLanguage(map, id)),
+        ...resolveWorkflowCreateParams(project.workflow),
+      })
+      scProjectId = createdProject.id
+      scProjectUrl = smartcat.projectUrl(createdProject.id)
+      log.push({level: 'success', message: `Created Smartcat project ${scProjectId}`})
+      // Persist the new project id immediately, before uploads. If a later step
+      // fails (or the event is re-run), the next run reuses this project instead
+      // of creating a duplicate in Smartcat.
+      await sanity.patch(projectId).set({smartcatProjectId: scProjectId, smartcatProjectUrl: scProjectUrl}).commit()
+    }
+
+    // Delete marked documents first (one id removes the whole document). Best-effort:
+    // an item is removed from the project only if its Smartcat delete succeeded (or
+    // it had no linked document).
+    const deletedItemKeys: string[] = []
+    for (const del of deletions) {
+      try {
+        if (del.smartcatDocumentId) {
+          await smartcat.deleteDocument(del.smartcatDocumentId)
+          log.push({level: 'success', message: `Deleted document ${del.smartcatDocumentId}`})
+        }
+        if (del.itemKey) deletedItemKeys.push(del.itemKey)
+      } catch (e) {
+        // Leave the item in place; the mark is cleared so the editor can retry.
+        log.push({level: 'error', message: `Failed to delete document ${del.smartcatDocumentId}: ${e instanceof Error ? e.message : String(e)}`})
+      }
+    }
+
+    // For an existing project, find which source files are already in Smartcat so
+    // we update them in place rather than creating duplicates.
+    const existing =
+      isNew || outbox.length === 0
+        ? new Map<string, string>()
+        : existingDocIdsBySource(await smartcat.getProject(scProjectId as string), outbox)
+
+    let created = 0
+    let updated = 0
+    let failed = 0
+    // Capture the documents Smartcat returns from each write. The post-upload
+    // getProject can lag on freshly-created docs (indexing delay); merging these
+    // in guarantees buildProgress sees them this run, so the title — which lives
+    // only on the in-memory outbox — is captured now instead of being lost until
+    // a re-export (see the field-level "Untitled" progress bug).
+    const writtenDocs: SmartcatDocument[] = []
+
+    const toUpdate = outbox.filter((item) => item.sourceDocId && existing.get(item.sourceDocId))
+    const toCreate = outbox.filter((item) => !(item.sourceDocId && existing.get(item.sourceDocId)))
+
+    // Updates stay per-item (no multi-file equivalent) — today's behavior.
+    for (const item of toUpdate) {
+      const docId = existing.get(item.sourceDocId as string) as string
+      try {
+        const returned = await smartcat.updateDocument(docId, item.filename, item.locjson)
+        // Tag with the filename we uploaded so correlation works even when the
+        // write response omits the document name.
+        for (const d of returned) writtenDocs.push({...d, name: d.name || item.filename})
+        updated++
+        log.push({level: 'success', message: `Updated ${item.filename}`})
+      } catch {
+        // The HTTP error + body were already logged in red by the request logger.
+        // One document failing (e.g. a Smartcat "document locked" / update-in-
+        // progress 400) must not abort the batch or fail the whole project — record
+        // it and move on so the rest still sync.
+        failed++
+        log.push({level: 'error', message: `Skipped ${item.filename} — update failed (see error above)`})
+      }
+    }
+
+    // Per-chunk upload: batch → retry once as batch → per-file fallback. Mutates the
+    // enclosing `created`/`failed`/`writtenDocs`/`log` state; never throws for a
+    // normal upload failure (the per-file fallback swallows those), so it's safe to
+    // run many of these concurrently below.
+    async function processChunk(group: OutboxItem[]): Promise<void> {
+      const payload = group.map((i) => ({filename: i.filename, content: i.locjson}))
+      try {
+        const returned = await smartcat.uploadDocuments(scProjectId as string, payload)
+        // Batch correlation relies on the response carrying a per-doc name/fullPath (spike-confirmed).
+        writtenDocs.push(...returned)
+        created += group.length
+        log.push({level: 'success', message: `Uploaded ${group.length} file(s)`})
+      } catch {
+        await sleep(BATCH_RETRY_DELAY_MS)
+        try {
+          const returned = await smartcat.uploadDocuments(scProjectId as string, payload)
+          writtenDocs.push(...returned)
+          created += group.length
+          log.push({level: 'success', message: `Uploaded ${group.length} file(s) (retry)`})
+        } catch {
+          log.push({level: 'info', message: `Batch upload failed, retrying ${group.length} file(s) individually`})
+          for (const item of group) {
+            try {
+              const returned = await smartcat.uploadDocument(scProjectId as string, item.filename, item.locjson)
+              // Tag with the filename we uploaded so correlation works even when the
+              // write response omits the document name.
+              for (const d of returned) writtenDocs.push({...d, name: d.name || item.filename})
+              created++
+              log.push({level: 'success', message: `Uploaded ${item.filename}`})
+            } catch (e) {
+              // A 409 here means the batch attempt(s) above actually committed this
+              // file before throwing (HTTP error masking a successful create); the
+              // re-POST fails because Smartcat rejects a duplicate filename. The
+              // document exists in the project, so it's synced, not failed —
+              // getProject/buildProgress remain authoritative for its content.
+              if (e instanceof SmartcatError && e.status === 409) {
+                created++
+                log.push({level: 'success', message: `Already synced ${item.filename}`})
+              } else {
+                failed++
+                log.push({level: 'error', message: `Skipped ${item.filename} — upload failed (see error above)`})
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Creates are uploaded in chunks, with bounded concurrency across chunks —
+    // log-line order becomes non-deterministic, but the mutations above are safe
+    // under JS's single-threaded async interleaving.
+    await runWithConcurrency(chunk(toCreate, UPLOAD_CHUNK_SIZE), UPLOAD_CHUNK_CONCURRENCY, processChunk)
+
+    // Re-fetch for authoritative ids/stages, and mirror the name back on first
+    // creation (Smartcat may have de-duplicated it, e.g. "My test (1)"). Then add
+    // any just-written docs it hasn't indexed yet so none are dropped this run.
+    const scProject = await smartcat.getProject(scProjectId as string)
+    const documents = mergeWrittenDocs(scProject.documents ?? [], writtenDocs)
+    const items: ProjectItem[] = outbox.map((o) => ({_id: o.sourceDocId || o.filename, title: o.title}))
+    const progress = buildProgress(items, {...scProject, documents}, project.progress, now(), project.smartcatLanguages)
+
+    log.push({
+      level: failed ? 'error' : 'info',
+      message: `Synced ${created} created, ${updated} updated${failed ? `, ${failed} failed` : ''}${deletedItemKeys.length ? `, ${deletedItemKeys.length} deleted` : ''}`,
+    })
+
+    const patch: Record<string, unknown> = {
+      smartcatProjectId: scProjectId,
+      smartcatProjectUrl: scProjectUrl,
+      status: 'sent',
+      progress,
+      lastExportAt: now(),
+      lastError: null,
+      functionLog: JSON.stringify(log),
+    }
+    // Mirror Smartcat's project name back on every sync, so the two stay in step
+    // (Smartcat may de-duplicate it, e.g. "My test (1)"). Note: this means a local
+    // rename in the Studio is overwritten on the next sync unless it's also pushed
+    // to Smartcat — Smartcat is the source of truth for the linked project's name.
+    if (scProject.name) patch.name = scProject.name
+
+    const unset = ['outbox', 'pendingDeletions', ...deletedItemKeys.map((k) => `items[_key=="${k}"]`)]
+    await sanity.patch(projectId).set(patch).unset(unset).commit()
+
+    return {smartcatProjectId: scProjectId as string, created, updated, deleted: deletedItemKeys.length, failed}
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    log.push({level: 'error', message})
+    await sanity
+      .patch(projectId)
+      .set({status: 'error', lastError: message, lastExportAt: now(), functionLog: JSON.stringify(log)})
+      .commit()
+      .catch(() => {})
+    throw err
+  }
+}

package/src/form/TranslationStatusInput.tsx

@@ -0,0 +1,212 @@
+import {Fragment, useCallback, useEffect, useState, type MouseEvent} from 'react'
+import {useClient, useFormValue, useWorkspace, type InputProps} from 'sanity'
+import {Card, Stack, Text, type CardTone} from '@sanity/ui'
+import {useRouter} from 'sanity/router'
+import {API_VERSION, TRANSLATION_PROJECT_TYPE} from '../lib/constants'
+import {ITEM_ID} from '../lib/projectItems'
+import {localizationMode} from '../lib/locjson/fields'
+import {TRANSLATION_TOOL_NAME} from '../tool'
+import type {LocalizationMode} from '../lib/locjson/types'
+import type {ResolvedSmartcatConfig} from '../lib/resolveConfig'
+
+interface ProjectRef {
+  _id: string
+  name?: string
+  /** True when this document is itself in the project's items (the source it was
+   * added as); false when it matched via a sibling variant (a translation target). */
+  isSource: boolean
+  /** True when the project actually targets this document's language — i.e. this
+   * variant is a real translation target of it, not just a sibling of its source. */
+  targetsThisLanguage: boolean
+}
+
+// Match projects whose items reference this document OR one of its sibling
+// language variants — so the banner shows on both the source and its translated
+// (document-level i18n) variants. The sibling ids come from the
+// translation.metadata group that references this document. Per project we also
+// record which role this document plays: `isSource` (the doc is itself an item)
+// and `targetsThisLanguage` (the project targets this doc's language, so this
+// variant is a genuine target — a project that references the source but doesn't
+// target this language is not). The same document can be a source in one project
+// and a target in another (e.g. pivot-language translation).
+const QUERY = `*[_type == "${TRANSLATION_PROJECT_TYPE}" && count(items[
+  ${ITEM_ID} in [$id] + *[_type == "translation.metadata" && references($id)].translations[].value._ref
+]) > 0] | order(_updatedAt desc){
+  _id,
+  name,
+  "isSource": count(items[${ITEM_ID} == $id]) > 0,
+  "targetsThisLanguage": $language in targetLanguages
+}`
+
+/** A link to a project's page in the Translations tool, with SPA navigation. */
+function ProjectLink({basePath, project}: {basePath: string; project: ProjectRef}) {
+  const router = useRouter()
+  // basePath is "/" by default or a configured prefix; join without doubling slashes.
+  const href = `${basePath.replace(/\/$/, '')}/${TRANSLATION_TOOL_NAME}/project/${project._id}`
+  const onClick = useCallback(
+    (e: MouseEvent) => {
+      // Let modifier-clicks (new tab/window) use the href; otherwise navigate in-app.
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return
+      e.preventDefault()
+      router.navigateUrl({path: href})
+    },
+    [router, href],
+  )
+  return (
+    <a href={href} onClick={onClick}>
+      {project.name || 'Untitled project'}
+    </a>
+  )
+}
+
+/** A self-contained card listing same-role projects. `lead` is the full text before the links. */
+function RoleCard({
+  lead,
+  tone = 'primary',
+  warning,
+  basePath,
+  projects,
+}: {
+  lead: string
+  tone?: CardTone
+  warning?: string
+  basePath: string
+  projects: ProjectRef[]
+}) {
+  return (
+    <Card tone={tone} padding={3} radius={2} border>
+      <Stack space={3}>
+        <Text size={1}>
+          {lead}
+          {projects.map((p, i) => (
+            <Fragment key={p._id}>
+              {i > 0 && ', '}
+              <ProjectLink basePath={basePath} project={p} />
+            </Fragment>
+          ))}
+        </Text>
+        {warning && (
+          <Text size={1} weight="semibold">
+            {warning}
+          </Text>
+        )}
+      </Stack>
+    </Card>
+  )
+}
+
+/**
+ * Status banner naming the project(s) this document belongs to, each linking to
+ * its page in the tool.
+ *
+ * For document-level localization a document can play both roles across projects
+ * (source in one, target in another), so source and variant memberships get
+ * their own lines. For field-level localization the single document holds every
+ * language, so there is no source/variant distinction — it's just "this document".
+ */
+function TranslationStatusLine({mode}: {mode: LocalizationMode}) {
+  const client = useClient({apiVersion: API_VERSION})
+  const {basePath} = useWorkspace()
+  const docId = (useFormValue(['_id']) as string | undefined)?.replace(/^drafts\./, '')
+  const language = (useFormValue(['language']) as string | undefined) ?? null
+  const [projects, setProjects] = useState<ProjectRef[]>([])
+
+  useEffect(() => {
+    if (!docId) return undefined
+    let cancelled = false
+    const params = {id: docId, language}
+    const load = () =>
+      client
+        .fetch<ProjectRef[]>(QUERY, params)
+        .then((res) => !cancelled && setProjects(res))
+        .catch(() => !cancelled && setProjects([]))
+    load()
+    const sub = client.listen(QUERY, params, {visibility: 'query'}).subscribe({next: load, error: () => {}})
+    return () => {
+      cancelled = true
+      sub.unsubscribe()
+    }
+  }, [client, docId, language])
+
+  if (projects.length === 0) return null
+
+  // Field-level docs hold all languages in one document — neutral, single card.
+  if (mode === 'field') {
+    return (
+      <Stack space={3}>
+        <RoleCard
+          lead={
+            projects.length === 1
+              ? 'This document is part of a translation project: '
+              : 'This document is part of multiple translation projects: '
+          }
+          basePath={basePath}
+          projects={projects}
+        />
+      </Stack>
+    )
+  }
+
+  const asSource = projects.filter((p) => p.isSource)
+  // A genuine target only if the project actually targets this variant's
+  // language — a project that merely includes the source (but targets other
+  // languages) doesn't translate into this variant, so it's not a collision.
+  const asTarget = projects.filter((p) => !p.isSource && p.targetsThisLanguage)
+
+  return (
+    <Stack space={3}>
+      {asSource.length > 0 && (
+        <RoleCard
+          lead={
+            asSource.length === 1
+              ? 'This source document is part of a translation project: '
+              : 'This source document is part of multiple translation projects: '
+          }
+          basePath={basePath}
+          projects={asSource}
+        />
+      )}
+      {asTarget.length > 0 && (
+        <RoleCard
+          // A document being a translation target in more than one project means
+          // multiple projects can write back to the same variant — flag it red.
+          tone={asTarget.length > 1 ? 'critical' : 'primary'}
+          lead={
+            asTarget.length === 1
+              ? 'This document variant is part of a translation project: '
+              : 'This document variant is part of multiple translation projects: '
+          }
+          warning={
+            asTarget.length > 1
+              ? 'Importing translations from more than one project can overwrite each other on this document.'
+              : undefined
+          }
+          basePath={basePath}
+          projects={asTarget}
+        />
+      )}
+    </Stack>
+  )
+}
+
+/**
+ * Wraps the document form for translatable types, rendering a status line above
+ * the fields when the document belongs to one or more Smartcat translation
+ * projects. Resolves live, so it updates as projects change.
+ */
+export function createTranslationStatusInput(config: ResolvedSmartcatConfig) {
+  return function TranslationStatusInput(props: InputProps) {
+    // Only the document root of a translatable type — not nested fields. This
+    // input is registered globally, so the type check also keeps it off the
+    // plugin's own `smartcat.*` documents.
+    const isDocumentRoot = props.path.length === 0 && config.isTranslatableType(props.schemaType.name)
+    if (!isDocumentRoot) return props.renderDefault(props)
+
+    return (
+      <Stack space={5}>
+        <TranslationStatusLine mode={localizationMode(props.schemaType)} />
+        {props.renderDefault(props)}
+      </Stack>
+    )
+  }
+}