@smartcat/sanity-plugin 1.0.0 → 1.1.0

package/dist/import.d.cts

@@ -0,0 +1,155 @@
+/**
+ * Live, in-memory log lines for the export/import flows, streamed to the
+ * ProjectView Log panel as each document and field is processed. Never persisted
+ * — purely a session-scoped trace for troubleshooting (e.g. on client calls).
+ */
+declare type LogLevel = "info" | "success" | "skip" | "error" | "update";
+
+declare interface LogLine {
+  level: LogLevel;
+  message: string;
+  /** Field-level lines are indented under their document header. */
+  indent?: boolean;
+  /** Optional value (source or translated text); revealed on click in the panel. */
+  value?: string;
+  /** Prior value; when set, the panel shows `before` and `value` side by side. */
+  before?: string;
+  /** Extra detail (e.g. a JSON parse error); shown in its own box on expand. */
+  error?: string;
+}
+
+/**
+ * Thin import step run by a Sanity Function: refreshes per-stage progress from
+ * Smartcat, then downloads the ready targets into the project's `inbox` and
+ * sets status to `downloaded`. The browser turns the inbox into locale
+ * variants and decides final completion.
+ *
+ * Downloads happen in **batches** (one Smartcat export task per ~50 documents,
+ * returned as a ZIP), so run time no longer scales with per-document polling —
+ * large projects fit comfortably inside the Function timeout. The inbox is
+ * size-capped per run; overflow targets are reported as `remaining` and the
+ * next import run picks them up (already-imported targets are skipped).
+ *
+ * Targets with nothing confirmed are skipped, so no untranslated variants are
+ * created. Does no content processing, so it depends only on the Smartcat client.
+ */
+export declare function runImportDownload(
+  options: RunImportDownloadOptions,
+): Promise<RunImportDownloadResult>;
+
+export declare interface RunImportDownloadOptions {
+  sanity: SanityLikeClient;
+  smartcat: SmartcatImportClient;
+  /** `_id` of the `smartcat.translationProject` to import. */
+  projectId: string;
+  now?: () => string;
+  /** Documents per Smartcat batch-export task. */
+  batchSize?: number;
+  /**
+   * Soft cap on the total LocJSON bytes stored in the project's `inbox` per
+   * run. The inbox lives on the Sanity project document, which has a practical
+   * size limit — targets beyond the cap are reported as `remaining` and picked
+   * up by the next import run.
+   */
+  maxInboxBytes?: number;
+  /** How many batch-export tasks run against Smartcat concurrently. */
+  concurrency?: number;
+  /**
+   * Soft time budget for the download phase, in ms. Once exceeded, batches not
+   * yet started are deferred as `remaining` and the run exits cleanly — so the
+   * Function always finishes well before its hard platform timeout instead of
+   * being killed mid-run (which would leave the project stuck in "importing").
+   */
+  timeBudgetMs?: number;
+  /** Clock override for tests (ms). */
+  nowMs?: () => number;
+  /**
+   * Receives every log line as it is emitted (in addition to the functionLog
+   * stored on the project document) — the Function forwards these to console
+   * so `sanity functions logs` shows the run without reading the document.
+   */
+  onLog?: (line: LogLine) => void;
+}
+
+export declare interface RunImportDownloadResult {
+  /** Number of complete targets downloaded into the inbox. */
+  downloaded: number;
+  /** Number of targets skipped because they are not yet fully translated. */
+  skipped: number;
+  /** Targets ready to download but deferred to the next run (inbox size cap). */
+  remaining: number;
+  /** Targets already imported in a previous run and therefore not re-downloaded. */
+  alreadyImported: number;
+}
+
+/** Minimal structural subset of @sanity/client used by the import download. */
+export declare interface SanityLikeClient {
+  fetch<T = unknown>(
+    query: string,
+    params?: Record<string, unknown>,
+  ): Promise<T>;
+  patch(id: string): {
+    set(attrs: Record<string, unknown>): {
+      commit(): Promise<unknown>;
+    };
+  };
+}
+
+/** A document within a Smartcat project (one per source file × target language). */
+declare interface SmartcatDocument {
+  /** Target document id, formatted `<fileGuid>_<languageNumber>`. */
+  id: string;
+  name?: string;
+  fullPath?: string;
+  filename?: string;
+  /** Shared id of the uploaded source file (the `<fileGuid>` part of `id`). */
+  externalId?: string;
+  sourceLanguage?: string;
+  targetLanguage?: string;
+  /** Per-stage progress. On documents these carry only `{id, progress}`; the
+   * stage names live on the project-level `workflowStages` (keyed by `id`). */
+  workflowStages?: SmartcatWorkflowStage[];
+}
+
+/** Structural subset of SmartcatClient the import download needs. */
+export declare interface SmartcatImportClient {
+  getProject(projectId: string): Promise<SmartcatProject>;
+  exportDocument(documentId: string): Promise<string>;
+  /**
+   * Batch export: one Smartcat task for many documents (ZIP result). Optional
+   * so custom/legacy clients keep working — without it every document falls
+   * back to a single {@link exportDocument} round-trip.
+   */
+  exportDocumentsBatch?(documentIds: string[]): Promise<
+    {
+      filename: string;
+      content: string;
+    }[]
+  >;
+}
+
+/** A Smartcat project as returned by the API. */
+declare interface SmartcatProject {
+  id: string;
+  name?: string;
+  sourceLanguage?: string;
+  targetLanguages?: string[];
+  /** Project-level stages, where each `id` maps to a `stageType` (e.g. "translation"). */
+  workflowStages?: SmartcatWorkflowStage[];
+  documents?: SmartcatDocument[];
+}
+
+declare interface SmartcatWorkflowStage {
+  id?: string;
+  /** Stage type/name, e.g. "translation" / "editing" (casing varies by API). */
+  stageType?: string;
+  /** Human-readable stage name, when the API provides one. */
+  stageName?: string;
+  /** Completion percentage for this stage, 0–100. */
+  progress?: number;
+  /** Word counts, when present — useful for a weighted progress view. */
+  wordsTranslated?: number;
+  totalWordsCount?: number;
+}
+
+export {};

package/dist/import.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Live, in-memory log lines for the export/import flows, streamed to the
+ * ProjectView Log panel as each document and field is processed. Never persisted
+ * — purely a session-scoped trace for troubleshooting (e.g. on client calls).
+ */
+declare type LogLevel = "info" | "success" | "skip" | "error" | "update";
+
+declare interface LogLine {
+  level: LogLevel;
+  message: string;
+  /** Field-level lines are indented under their document header. */
+  indent?: boolean;
+  /** Optional value (source or translated text); revealed on click in the panel. */
+  value?: string;
+  /** Prior value; when set, the panel shows `before` and `value` side by side. */
+  before?: string;
+  /** Extra detail (e.g. a JSON parse error); shown in its own box on expand. */
+  error?: string;
+}
+
+/**
+ * Thin import step run by a Sanity Function: refreshes per-stage progress from
+ * Smartcat, then downloads the ready targets into the project's `inbox` and
+ * sets status to `downloaded`. The browser turns the inbox into locale
+ * variants and decides final completion.
+ *
+ * Downloads happen in **batches** (one Smartcat export task per ~50 documents,
+ * returned as a ZIP), so run time no longer scales with per-document polling —
+ * large projects fit comfortably inside the Function timeout. The inbox is
+ * size-capped per run; overflow targets are reported as `remaining` and the
+ * next import run picks them up (already-imported targets are skipped).
+ *
+ * Targets with nothing confirmed are skipped, so no untranslated variants are
+ * created. Does no content processing, so it depends only on the Smartcat client.
+ */
+export declare function runImportDownload(
+  options: RunImportDownloadOptions,
+): Promise<RunImportDownloadResult>;
+
+export declare interface RunImportDownloadOptions {
+  sanity: SanityLikeClient;
+  smartcat: SmartcatImportClient;
+  /** `_id` of the `smartcat.translationProject` to import. */
+  projectId: string;
+  now?: () => string;
+  /** Documents per Smartcat batch-export task. */
+  batchSize?: number;
+  /**
+   * Soft cap on the total LocJSON bytes stored in the project's `inbox` per
+   * run. The inbox lives on the Sanity project document, which has a practical
+   * size limit — targets beyond the cap are reported as `remaining` and picked
+   * up by the next import run.
+   */
+  maxInboxBytes?: number;
+  /** How many batch-export tasks run against Smartcat concurrently. */
+  concurrency?: number;
+  /**
+   * Soft time budget for the download phase, in ms. Once exceeded, batches not
+   * yet started are deferred as `remaining` and the run exits cleanly — so the
+   * Function always finishes well before its hard platform timeout instead of
+   * being killed mid-run (which would leave the project stuck in "importing").
+   */
+  timeBudgetMs?: number;
+  /** Clock override for tests (ms). */
+  nowMs?: () => number;
+  /**
+   * Receives every log line as it is emitted (in addition to the functionLog
+   * stored on the project document) — the Function forwards these to console
+   * so `sanity functions logs` shows the run without reading the document.
+   */
+  onLog?: (line: LogLine) => void;
+}
+
+export declare interface RunImportDownloadResult {
+  /** Number of complete targets downloaded into the inbox. */
+  downloaded: number;
+  /** Number of targets skipped because they are not yet fully translated. */
+  skipped: number;
+  /** Targets ready to download but deferred to the next run (inbox size cap). */
+  remaining: number;
+  /** Targets already imported in a previous run and therefore not re-downloaded. */
+  alreadyImported: number;
+}
+
+/** Minimal structural subset of @sanity/client used by the import download. */
+export declare interface SanityLikeClient {
+  fetch<T = unknown>(
+    query: string,
+    params?: Record<string, unknown>,
+  ): Promise<T>;
+  patch(id: string): {
+    set(attrs: Record<string, unknown>): {
+      commit(): Promise<unknown>;
+    };
+  };
+}
+
+/** A document within a Smartcat project (one per source file × target language). */
+declare interface SmartcatDocument {
+  /** Target document id, formatted `<fileGuid>_<languageNumber>`. */
+  id: string;
+  name?: string;
+  fullPath?: string;
+  filename?: string;
+  /** Shared id of the uploaded source file (the `<fileGuid>` part of `id`). */
+  externalId?: string;
+  sourceLanguage?: string;
+  targetLanguage?: string;
+  /** Per-stage progress. On documents these carry only `{id, progress}`; the
+   * stage names live on the project-level `workflowStages` (keyed by `id`). */
+  workflowStages?: SmartcatWorkflowStage[];
+}
+
+/** Structural subset of SmartcatClient the import download needs. */
+export declare interface SmartcatImportClient {
+  getProject(projectId: string): Promise<SmartcatProject>;
+  exportDocument(documentId: string): Promise<string>;
+  /**
+   * Batch export: one Smartcat task for many documents (ZIP result). Optional
+   * so custom/legacy clients keep working — without it every document falls
+   * back to a single {@link exportDocument} round-trip.
+   */
+  exportDocumentsBatch?(documentIds: string[]): Promise<
+    {
+      filename: string;
+      content: string;
+    }[]
+  >;
+}
+
+/** A Smartcat project as returned by the API. */
+declare interface SmartcatProject {
+  id: string;
+  name?: string;
+  sourceLanguage?: string;
+  targetLanguages?: string[];
+  /** Project-level stages, where each `id` maps to a `stageType` (e.g. "translation"). */
+  workflowStages?: SmartcatWorkflowStage[];
+  documents?: SmartcatDocument[];
+}
+
+declare interface SmartcatWorkflowStage {
+  id?: string;
+  /** Stage type/name, e.g. "translation" / "editing" (casing varies by API). */
+  stageType?: string;
+  /** Human-readable stage name, when the API provides one. */
+  stageName?: string;
+  /** Completion percentage for this stage, 0–100. */
+  progress?: number;
+  /** Word counts, when present — useful for a weighted progress view. */
+  wordsTranslated?: number;
+  totalWordsCount?: number;
+}
+
+export {};

package/dist/import.js

@@ -0,0 +1,169 @@
+import { ITEM_ID, buildProgress, itemsFromProject, hasConfirmedContent, itemDocDerefRespectingDraft } from "./_chunks-es/index.js";
+function smartcatDocPath(scDoc) {
+  return (scDoc?.fullPath || scDoc?.name || scDoc?.filename || "").replace(/\.[^./]+$/, "");
+}
+const DEFAULT_BATCH_SIZE = 50, DEFAULT_MAX_INBOX_BYTES = 15e5, DEFAULT_CONCURRENCY = 4, DEFAULT_TIME_BUDGET_MS = 10 * 6e4, PROJECT_QUERY = `*[_id == $id][0]{
+  _id,
+  smartcatProjectId,
+  smartcatLanguages[]{sanityId, smartcatLanguage},
+  "items": items[]{ "_id": ${ITEM_ID}, "title": ${itemDocDerefRespectingDraft(".title")} },
+  progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}
+}`;
+function stripDraft(id) {
+  return id.replace(/^drafts\./, "");
+}
+function sanityDocIdOf(locjson) {
+  try {
+    return JSON.parse(locjson).properties?.["x-sanity"]?.documentId;
+  } catch {
+    return;
+  }
+}
+async function downloadBatch(smartcat, batch, emit) {
+  const contentByTarget = /* @__PURE__ */ new Map(), batchAttempted = !!(smartcat.exportDocumentsBatch && batch.length > 1);
+  let batchFailed = !1;
+  if (batchAttempted)
+    try {
+      const files2 = await smartcat.exportDocumentsBatch(batch.map((t) => t.smartcatDocumentId)), targetByDocId = new Map(batch.map((t) => [stripDraft(t.sourceDocId), t]));
+      for (const file of files2) {
+        const docId = sanityDocIdOf(file.content), target = docId ? targetByDocId.get(stripDraft(docId)) : void 0;
+        target && !contentByTarget.has(target) && contentByTarget.set(target, file.content);
+      }
+      contentByTarget.size < batch.length && emit({
+        level: "info",
+        message: `${batch.length - contentByTarget.size} of ${batch.length} file(s) missing from the batch archive \u2014 fetching them per-document`
+      });
+    } catch (err) {
+      batchFailed = !0, emit({
+        level: "error",
+        message: `Batch export of ${batch.length} document(s) failed \u2014 falling back to per-document export: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  const files = [];
+  let fallbackCount = 0;
+  for (const target of batch) {
+    let locjson = contentByTarget.get(target);
+    locjson === void 0 && (locjson = await smartcat.exportDocument(target.smartcatDocumentId), batchAttempted && fallbackCount++), files.push({ target, locjson });
+  }
+  return { files, fallbackCount, batchFailed };
+}
+async function runImportDownload(options) {
+  const {
+    sanity,
+    smartcat,
+    projectId,
+    now = () => (/* @__PURE__ */ new Date()).toISOString(),
+    batchSize = DEFAULT_BATCH_SIZE,
+    maxInboxBytes = DEFAULT_MAX_INBOX_BYTES,
+    concurrency = DEFAULT_CONCURRENCY,
+    timeBudgetMs = DEFAULT_TIME_BUDGET_MS,
+    nowMs = Date.now,
+    onLog
+  } = options, log = [], emit = (line) => {
+    log.push(line), onLog?.(line);
+  }, project = await sanity.fetch(PROJECT_QUERY, { id: projectId });
+  if (!project) throw new Error(`Translation project ${projectId} not found`);
+  try {
+    if (!project.smartcatProjectId)
+      throw new Error("Project has no smartcatProjectId \u2014 export it first");
+    const timestamp = now(), scProject = await smartcat.getProject(project.smartcatProjectId);
+    emit({ level: "info", message: "Checking Smartcat for completed translations" });
+    const scDocById = new Map((scProject.documents ?? []).filter((d) => d.id).map((d) => [d.id, d])), progress = buildProgress(
+      itemsFromProject(project),
+      scProject,
+      project.progress,
+      timestamp,
+      project.smartcatLanguages
+    ), ready = [];
+    let skipped = 0, alreadyImported = 0;
+    for (const docProgress of progress)
+      for (const target of docProgress.targets) {
+        const id = target.smartcatDocumentId, label = id && smartcatDocPath(scDocById.get(id)) || docProgress.title || docProgress.sourceDocId;
+        if (!id || !hasConfirmedContent(target.stages)) {
+          id && !target.imported && (skipped++, emit({ level: "skip", message: `${label} (Smartcat ID: ${id}) \u2192 ${target.language}: not ready, skipped` }));
+          continue;
+        }
+        if (target.imported) {
+          alreadyImported++;
+          continue;
+        }
+        ready.push({
+          key: target._key,
+          sourceDocId: docProgress.sourceDocId,
+          language: target.language,
+          smartcatDocumentId: id,
+          label
+        });
+      }
+    const inbox = [];
+    let inboxBytes = 0, remaining = 0;
+    const byLanguage = /* @__PURE__ */ new Map();
+    for (const target of ready) {
+      const group = byLanguage.get(target.language) ?? [];
+      group.push(target), byLanguage.set(target.language, group);
+    }
+    const batches = [];
+    for (const group of byLanguage.values())
+      for (let i = 0; i < group.length; i += batchSize)
+        batches.push(group.slice(i, i + batchSize));
+    const effectiveConcurrency = Math.max(1, Math.min(concurrency, batches.length));
+    batches.length > 0 && emit({
+      level: "info",
+      message: `Downloading ${ready.length} target(s) in ${batches.length} batch(es) of up to ${batchSize}, ${effectiveConcurrency} in parallel`
+    });
+    const startedAtMs = nowMs();
+    let deferredByBytes = 0, deferredByTime = 0, fallbackDownloads = 0, failedBatches = 0, nextBatch = 0;
+    const worker = async () => {
+      for (; nextBatch < batches.length; ) {
+        const index = nextBatch++, batch = batches[index];
+        if (inboxBytes >= maxInboxBytes) {
+          deferredByBytes += batch.length;
+          continue;
+        }
+        if (nowMs() - startedAtMs >= timeBudgetMs) {
+          deferredByTime += batch.length;
+          continue;
+        }
+        const batchStartMs = nowMs(), { files, fallbackCount, batchFailed } = await downloadBatch(smartcat, batch, emit);
+        fallbackDownloads += fallbackCount, batchFailed && failedBatches++;
+        for (const { target, locjson } of files)
+          inbox.push({
+            _key: target.key,
+            sourceDocId: target.sourceDocId,
+            targetLanguage: target.language,
+            smartcatDocumentId: target.smartcatDocumentId,
+            locjson
+          }), inboxBytes += locjson.length;
+        emit({
+          level: "success",
+          message: `Batch ${index + 1}/${batches.length} (${batch[0].language}): ${files.length} doc(s) in ${((nowMs() - batchStartMs) / 1e3).toFixed(1)}s${fallbackCount ? ` \u2014 ${fallbackCount} via per-document fallback` : ""}`
+        });
+      }
+    };
+    return await Promise.all(Array.from({ length: effectiveConcurrency }, worker)), remaining = deferredByBytes + deferredByTime, ready.length > 0 && emit({
+      level: failedBatches || fallbackDownloads ? "error" : "info",
+      message: `Download phase: ${((nowMs() - startedAtMs) / 1e3).toFixed(1)}s \u2014 ${batches.length} batch(es), ${failedBatches} failed, ${fallbackDownloads} per-document fallback download(s); deferred ${deferredByBytes} (inbox size cap) + ${deferredByTime} (time budget)`
+    }), emit({
+      level: "info",
+      message: `Downloaded ${inbox.length} target(s)${skipped ? `, skipped ${skipped} not ready` : ""}${alreadyImported ? `, ${alreadyImported} already imported` : ""}${remaining ? `, ${remaining} deferred \u2014 run Import again to continue` : ""}`
+    }), await sanity.patch(projectId).set({
+      inbox,
+      progress,
+      progressSyncedAt: timestamp,
+      status: "downloaded",
+      // Deferred-target count for the dashboard: after applying this batch it
+      // auto-continues the import instead of asking for another click.
+      importRemaining: remaining,
+      lastError: null,
+      functionLog: JSON.stringify(log)
+    }).commit(), { downloaded: inbox.length, skipped, remaining, alreadyImported };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw emit({ level: "error", message }), await sanity.patch(projectId).set({ status: "error", lastError: message, lastImportAt: now(), functionLog: JSON.stringify(log) }).commit().catch(() => {
+    }), err;
+  }
+}
+export {
+  runImportDownload
+};
+//# sourceMappingURL=import.js.map

package/dist/import.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.js","sources":["../src/import/index.ts"],"sourcesContent":["import type {SmartcatDocument, SmartcatProject} from '../smartcat/types'\nimport {buildProgress, hasConfirmedContent, itemsFromProject, type DocProgress} from '../progress/core'\nimport {ITEM_ID, itemDocDerefRespectingDraft} from '../lib/projectItems'\nimport type {SmartcatLanguageMapping} from '../lib/languageMap'\nimport type {LogLine} from '../lib/log'\n\n/** The Smartcat document's full path (folder + filename), extension stripped. */\nfunction smartcatDocPath(scDoc: SmartcatDocument | undefined): string {\n  const raw = scDoc?.fullPath || scDoc?.name || scDoc?.filename || ''\n  return raw.replace(/\\.[^./]+$/, '')\n}\n\n/** Minimal structural subset of @sanity/client used by the import download. */\nexport interface SanityLikeClient {\n  fetch<T = unknown>(query: string, params?: Record<string, unknown>): Promise<T>\n  patch(id: string): {\n    set(attrs: Record<string, unknown>): {commit(): Promise<unknown>}\n  }\n}\n\n/** Structural subset of SmartcatClient the import download needs. */\nexport interface SmartcatImportClient {\n  getProject(projectId: string): Promise<SmartcatProject>\n  exportDocument(documentId: string): Promise<string>\n  /**\n   * Batch export: one Smartcat task for many documents (ZIP result). Optional\n   * so custom/legacy clients keep working — without it every document falls\n   * back to a single {@link exportDocument} round-trip.\n   */\n  exportDocumentsBatch?(documentIds: string[]): Promise<{filename: string; content: string}[]>\n}\n\nexport interface RunImportDownloadOptions {\n  sanity: SanityLikeClient\n  smartcat: SmartcatImportClient\n  /** `_id` of the `smartcat.translationProject` to import. */\n  projectId: string\n  now?: () => string\n  /** Documents per Smartcat batch-export task. */\n  batchSize?: number\n  /**\n   * Soft cap on the total LocJSON bytes stored in the project's `inbox` per\n   * run. The inbox lives on the Sanity project document, which has a practical\n   * size limit — targets beyond the cap are reported as `remaining` and picked\n   * up by the next import run.\n   */\n  maxInboxBytes?: number\n  /** How many batch-export tasks run against Smartcat concurrently. */\n  concurrency?: number\n  /**\n   * Soft time budget for the download phase, in ms. Once exceeded, batches not\n   * yet started are deferred as `remaining` and the run exits cleanly — so the\n   * Function always finishes well before its hard platform timeout instead of\n   * being killed mid-run (which would leave the project stuck in \"importing\").\n   */\n  timeBudgetMs?: number\n  /** Clock override for tests (ms). */\n  nowMs?: () => number\n  /**\n   * Receives every log line as it is emitted (in addition to the functionLog\n   * stored on the project document) — the Function forwards these to console\n   * so `sanity functions logs` shows the run without reading the document.\n   */\n  onLog?: (line: LogLine) => void\n}\n\nexport interface RunImportDownloadResult {\n  /** Number of complete targets downloaded into the inbox. */\n  downloaded: number\n  /** Number of targets skipped because they are not yet fully translated. */\n  skipped: number\n  /** Targets ready to download but deferred to the next run (inbox size cap). */\n  remaining: number\n  /** Targets already imported in a previous run and therefore not re-downloaded. */\n  alreadyImported: number\n}\n\nconst DEFAULT_BATCH_SIZE = 50\n/** Keeps the project document comfortably below Sanity's document size limits. */\nconst DEFAULT_MAX_INBOX_BYTES = 1_500_000\n/**\n * Parallel Smartcat export tasks. High enough to divide the download time ~4×,\n * low enough not to crowd the account's export-task queue.\n */\nconst DEFAULT_CONCURRENCY = 4\n/** Exit-early margin against the 15-minute Sanity Function timeout. */\nconst DEFAULT_TIME_BUDGET_MS = 10 * 60_000\n\nconst PROJECT_QUERY = `*[_id == $id][0]{\n  _id,\n  smartcatProjectId,\n  smartcatLanguages[]{sanityId, smartcatLanguage},\n  \"items\": items[]{ \"_id\": ${ITEM_ID}, \"title\": ${itemDocDerefRespectingDraft('.title')} },\n  progress[]{_key, sourceDocId, title, targets[]{_key, language, smartcatDocumentId, stages, complete, imported, syncedAt}}\n}`\n\ninterface ProjectData {\n  _id: string\n  smartcatProjectId?: string\n  smartcatLanguages?: SmartcatLanguageMapping[]\n  items?: {_id?: string; title?: string}[]\n  progress?: DocProgress[]\n}\n\ninterface InboxItem {\n  _key: string\n  sourceDocId: string\n  targetLanguage: string\n  smartcatDocumentId: string\n  locjson: string\n}\n\n/** A (document × language) target selected for download this run. */\ninterface ReadyTarget {\n  key: string\n  sourceDocId: string\n  language: string\n  smartcatDocumentId: string\n  label: string\n}\n\nfunction stripDraft(id: string): string {\n  return id.replace(/^drafts\\./, '')\n}\n\n/** The Sanity source-document id a LocJSON carries in its `x-sanity` metadata. */\nfunction sanityDocIdOf(locjson: string): string | undefined {\n  try {\n    const parsed = JSON.parse(locjson) as {properties?: {'x-sanity'?: {documentId?: string}}}\n    return parsed.properties?.['x-sanity']?.documentId\n  } catch {\n    return undefined\n  }\n}\n\ninterface BatchDownloadResult {\n  files: {target: ReadyTarget; locjson: string}[]\n  /** Targets fetched one-by-one because the batched call failed or its archive missed them. */\n  fallbackCount: number\n  /** The batched export call itself failed (the error line is already emitted). */\n  batchFailed: boolean\n}\n\n/**\n * Downloads a batch of same-language targets. Uses one batched export task\n * (ZIP) when the client supports it, correlating each returned file back to\n * its target via the LocJSON's own `x-sanity.documentId`. Targets the archive\n * didn't cover — and the whole batch when the batched call fails — fall back\n * to per-document exports, so a batch problem degrades to the old (slow but\n * proven) path instead of failing the run. Every degradation is logged loudly:\n * a silent fallback looks exactly like \"batching deployed but nothing faster\".\n */\nasync function downloadBatch(\n  smartcat: SmartcatImportClient,\n  batch: ReadyTarget[],\n  emit: (line: LogLine) => void,\n): Promise<BatchDownloadResult> {\n  const contentByTarget = new Map<ReadyTarget, string>()\n  const batchAttempted = Boolean(smartcat.exportDocumentsBatch && batch.length > 1)\n  let batchFailed = false\n\n  if (batchAttempted) {\n    try {\n      const files = await smartcat.exportDocumentsBatch!(batch.map((t) => t.smartcatDocumentId))\n      const targetByDocId = new Map(batch.map((t) => [stripDraft(t.sourceDocId), t]))\n      for (const file of files) {\n        const docId = sanityDocIdOf(file.content)\n        const target = docId ? targetByDocId.get(stripDraft(docId)) : undefined\n        if (target && !contentByTarget.has(target)) contentByTarget.set(target, file.content)\n      }\n      if (contentByTarget.size < batch.length) {\n        emit({\n          level: 'info',\n          message: `${batch.length - contentByTarget.size} of ${batch.length} file(s) missing from the batch archive — fetching them per-document`,\n        })\n      }\n    } catch (err) {\n      batchFailed = true\n      emit({\n        level: 'error',\n        message: `Batch export of ${batch.length} document(s) failed — falling back to per-document export: ${err instanceof Error ? err.message : String(err)}`,\n      })\n    }\n  }\n\n  const files: {target: ReadyTarget; locjson: string}[] = []\n  let fallbackCount = 0\n  for (const target of batch) {\n    let locjson = contentByTarget.get(target)\n    if (locjson === undefined) {\n      locjson = await smartcat.exportDocument(target.smartcatDocumentId)\n      if (batchAttempted) fallbackCount++\n    }\n    files.push({target, locjson})\n  }\n  return {files, fallbackCount, batchFailed}\n}\n\n/**\n * Thin import step run by a Sanity Function: refreshes per-stage progress from\n * Smartcat, then downloads the ready targets into the project's `inbox` and\n * sets status to `downloaded`. The browser turns the inbox into locale\n * variants and decides final completion.\n *\n * Downloads happen in **batches** (one Smartcat export task per ~50 documents,\n * returned as a ZIP), so run time no longer scales with per-document polling —\n * large projects fit comfortably inside the Function timeout. The inbox is\n * size-capped per run; overflow targets are reported as `remaining` and the\n * next import run picks them up (already-imported targets are skipped).\n *\n * Targets with nothing confirmed are skipped, so no untranslated variants are\n * created. Does no content processing, so it depends only on the Smartcat client.\n */\nexport async function runImportDownload(\n  options: RunImportDownloadOptions,\n): Promise<RunImportDownloadResult> {\n  const {\n    sanity,\n    smartcat,\n    projectId,\n    now = () => new Date().toISOString(),\n    batchSize = DEFAULT_BATCH_SIZE,\n    maxInboxBytes = DEFAULT_MAX_INBOX_BYTES,\n    concurrency = DEFAULT_CONCURRENCY,\n    timeBudgetMs = DEFAULT_TIME_BUDGET_MS,\n    nowMs = Date.now,\n    onLog,\n  } = options\n  const log: LogLine[] = []\n  const emit = (line: LogLine) => {\n    log.push(line)\n    onLog?.(line)\n  }\n\n  const project = await sanity.fetch<ProjectData | null>(PROJECT_QUERY, {id: projectId})\n  if (!project) throw new Error(`Translation project ${projectId} not found`)\n\n  try {\n    if (!project.smartcatProjectId) {\n      throw new Error('Project has no smartcatProjectId — export it first')\n    }\n\n    const timestamp = now()\n    const scProject = await smartcat.getProject(project.smartcatProjectId)\n    emit({level: 'info', message: 'Checking Smartcat for completed translations'})\n    // Look up each target's Smartcat document by its id, for full-path logging.\n    const scDocById = new Map((scProject.documents ?? []).filter((d) => d.id).map((d) => [d.id, d]))\n\n    // Rebuild progress from Smartcat + the project's items, so the dashboard\n    // reflects the latest state even for targets we don't import this round.\n    const progress = buildProgress(\n      itemsFromProject(project),\n      scProject,\n      project.progress,\n      timestamp,\n      project.smartcatLanguages,\n    )\n\n    // Collect every target that has confirmed content (at any stage); targets\n    // with nothing confirmed are skipped. Targets already imported in an\n    // earlier run are not re-downloaded, so capped runs make forward progress.\n    const ready: ReadyTarget[] = []\n    let skipped = 0\n    let alreadyImported = 0\n    for (const docProgress of progress) {\n      for (const target of docProgress.targets) {\n        const id = target.smartcatDocumentId\n        // Prefer the Smartcat full path; fall back to the resolved title / source id.\n        const label =\n          (id && smartcatDocPath(scDocById.get(id))) || docProgress.title || docProgress.sourceDocId\n        if (!id || !hasConfirmedContent(target.stages)) {\n          if (id && !target.imported) {\n            skipped++\n            emit({level: 'skip', message: `${label} (Smartcat ID: ${id}) → ${target.language}: not ready, skipped`})\n          }\n          continue\n        }\n        if (target.imported) {\n          alreadyImported++\n          continue\n        }\n        ready.push({\n          key: target._key,\n          sourceDocId: docProgress.sourceDocId,\n          language: target.language,\n          smartcatDocumentId: id,\n          label,\n        })\n      }\n    }\n\n    // Download in batches: one Smartcat export task per batch (ZIP result)\n    // instead of a request+poll round-trip per document. Batches are grouped\n    // by language so each source document appears at most once per archive.\n    const inbox: InboxItem[] = []\n    let inboxBytes = 0\n    let remaining = 0\n    const byLanguage = new Map<string, ReadyTarget[]>()\n    for (const target of ready) {\n      const group = byLanguage.get(target.language) ?? []\n      group.push(target)\n      byLanguage.set(target.language, group)\n    }\n\n    const batches: ReadyTarget[][] = []\n    for (const group of byLanguage.values()) {\n      for (let i = 0; i < group.length; i += batchSize) {\n        batches.push(group.slice(i, i + batchSize))\n      }\n    }\n\n    // Worker pool: up to `concurrency` batch-export tasks in flight at once —\n    // Smartcat assembles the archives in parallel, dividing the download time.\n    // Each worker re-checks the caps before claiming the next batch:\n    // - inbox byte cap: the inbox lives on the project document, which must\n    //   stay below Sanity's document size limit;\n    // - time budget: exit cleanly before the platform kills the Function, so a\n    //   slow Smartcat day degrades to \"continue in the next run\", never to a\n    //   project stuck in \"importing\".\n    const effectiveConcurrency = Math.max(1, Math.min(concurrency, batches.length))\n    if (batches.length > 0) {\n      emit({\n        level: 'info',\n        message: `Downloading ${ready.length} target(s) in ${batches.length} batch(es) of up to ${batchSize}, ${effectiveConcurrency} in parallel`,\n      })\n    }\n    const startedAtMs = nowMs()\n    let deferredByBytes = 0\n    let deferredByTime = 0\n    let fallbackDownloads = 0\n    let failedBatches = 0\n    let nextBatch = 0\n    const worker = async () => {\n      while (nextBatch < batches.length) {\n        const index = nextBatch++\n        const batch = batches[index]\n        if (inboxBytes >= maxInboxBytes) {\n          deferredByBytes += batch.length\n          continue\n        }\n        if (nowMs() - startedAtMs >= timeBudgetMs) {\n          deferredByTime += batch.length\n          continue\n        }\n        const batchStartMs = nowMs()\n        const {files, fallbackCount, batchFailed} = await downloadBatch(smartcat, batch, emit)\n        fallbackDownloads += fallbackCount\n        if (batchFailed) failedBatches++\n        for (const {target, locjson} of files) {\n          inbox.push({\n            _key: target.key,\n            sourceDocId: target.sourceDocId,\n            targetLanguage: target.language,\n            smartcatDocumentId: target.smartcatDocumentId,\n            locjson,\n          })\n          inboxBytes += locjson.length\n        }\n        emit({\n          level: 'success',\n          message:\n            `Batch ${index + 1}/${batches.length} (${batch[0].language}): ${files.length} doc(s) in ` +\n            `${((nowMs() - batchStartMs) / 1000).toFixed(1)}s` +\n            `${fallbackCount ? ` — ${fallbackCount} via per-document fallback` : ''}`,\n        })\n      }\n    }\n    await Promise.all(Array.from({length: effectiveConcurrency}, worker))\n    remaining = deferredByBytes + deferredByTime\n\n    // One line that answers \"where did the time go and why was anything left\n    // behind\" — the silent-degradation postmortems start here.\n    if (ready.length > 0) {\n      emit({\n        level: failedBatches || fallbackDownloads ? 'error' : 'info',\n        message:\n          `Download phase: ${((nowMs() - startedAtMs) / 1000).toFixed(1)}s — ` +\n          `${batches.length} batch(es), ${failedBatches} failed, ${fallbackDownloads} per-document fallback download(s); ` +\n          `deferred ${deferredByBytes} (inbox size cap) + ${deferredByTime} (time budget)`,\n      })\n    }\n\n    emit({\n      level: 'info',\n      message:\n        `Downloaded ${inbox.length} target(s)` +\n        `${skipped ? `, skipped ${skipped} not ready` : ''}` +\n        `${alreadyImported ? `, ${alreadyImported} already imported` : ''}` +\n        `${remaining ? `, ${remaining} deferred — run Import again to continue` : ''}`,\n    })\n\n    await sanity\n      .patch(projectId)\n      .set({\n        inbox,\n        progress,\n        progressSyncedAt: timestamp,\n        status: 'downloaded',\n        // Deferred-target count for the dashboard: after applying this batch it\n        // auto-continues the import instead of asking for another click.\n        importRemaining: remaining,\n        lastError: null,\n        functionLog: JSON.stringify(log),\n      })\n      .commit()\n\n    return {downloaded: inbox.length, skipped, remaining, alreadyImported}\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err)\n    emit({level: 'error', message})\n    await sanity\n      .patch(projectId)\n      .set({status: 'error', lastError: message, lastImportAt: now(), functionLog: JSON.stringify(log)})\n      .commit()\n      .catch(() => {})\n    throw err\n  }\n}\n"],"names":["files"],"mappings":"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"}