@madewithremy/admin 0.1.6 → 0.1.8

package/dist/prod.js

@@ -36,10 +36,10 @@ function fatal(message) {
   throw new CliError(message);
 }
 var AdminApiError = class extends Error {
-  constructor(method, path5, status2, body) {
-    super(`API ${method} ${path5} returned ${status2}: ${JSON.stringify(body)}`);
+  constructor(method, path7, status2, body) {
+    super(`API ${method} ${path7} returned ${status2}: ${JSON.stringify(body)}`);
     this.method = method;
-    this.path = path5;
+    this.path = path7;
     this.status = status2;
     this.body = body;
     this.name = "AdminApiError";
@@ -935,7 +935,7 @@ async function waitForCommit(ctx, params) {
   const { commitSha, onProgress } = params;
   const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const shortSha = commitSha.slice(0, 8);
-  const start = Date.now();
+  const start2 = Date.now();
   let release;
   while (true) {
     const r = await byCommit(ctx, commitSha);
@@ -948,7 +948,7 @@ async function waitForCommit(ctx, params) {
         `Failed to resolve release for ${shortSha}: HTTP ${r.status} ${JSON.stringify(r.body)}`
       );
     }
-    if (Date.now() - start > RESOLVE_GRACE_MS) {
+    if (Date.now() - start2 > RESOLVE_GRACE_MS) {
       return {
         outcome: "not_found",
         error: `No release created for commit ${commitSha} within ${RESOLVE_GRACE_MS / 1e3}s \u2014 either the push hasn't registered yet or this SHA never produced a build`
@@ -976,7 +976,7 @@ async function waitForCommit(ctx, params) {
         summary: summarizeRelease(release)
       };
     }
-    if (Date.now() - start > timeoutMs) {
+    if (Date.now() - start2 > timeoutMs) {
       return {
         outcome: "timeout",
         release,
@@ -985,7 +985,7 @@ async function waitForCommit(ctx, params) {
       };
     }
     onProgress?.(
-      `${release.status}\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
+      `${release.status}\u2026 (${Math.round((Date.now() - start2) / 1e3)}s)`
     );
     await sleep(POLL_MS);
     const r = await byCommit(ctx, commitSha);
@@ -1247,14 +1247,14 @@ async function diagnosticsGet(ctx, a) {
   const releaseId = await resolveReleaseId(ctx, a);
   if (a.bool("wait")) {
     const timeout = (a.num("timeout") ?? 120) * 1e3;
-    const start = Date.now();
+    const start2 = Date.now();
     while (true) {
       const release2 = await getRelease(ctx, releaseId);
       if (release2.diagnostics) {
         out(release2.diagnostics);
         return;
       }
-      if (Date.now() - start > timeout) {
+      if (Date.now() - start2 > timeout) {
         out(DIAGNOSTICS_PENDING);
         return;
       }
@@ -2869,11 +2869,55 @@ Notes:
   - Public image URLs accept transform params, e.g. ?w=400&fit=cover.`;
 
 // src/commands/dataSources.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/ops/dataSources.ts
 import { createHash as createHash2 } from "crypto";
+
+// src/poll.ts
+async function pollUntil(read, isSettled, options) {
+  const start2 = Date.now();
+  let transientSince = null;
+  while (true) {
+    let value;
+    try {
+      value = await read();
+      transientSince = null;
+    } catch (err) {
+      if (!isTransientError(err)) {
+        throw err;
+      }
+      transientSince ??= Date.now();
+      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
+        throw err;
+      }
+      options.onProgress?.(
+        `retrying after a gateway error\u2026 (${elapsedSeconds(start2)}s)`
+      );
+      await sleep(options.pollMs);
+      continue;
+    }
+    if (isSettled(value)) {
+      return { settled: true, value };
+    }
+    if (Date.now() - start2 > options.timeoutMs) {
+      return { settled: false, value };
+    }
+    if (options.describe) {
+      options.onProgress?.(options.describe(value, start2));
+    }
+    await sleep(options.pollMs);
+  }
+}
+function elapsedSeconds(start2) {
+  return Math.round((Date.now() - start2) / 1e3);
+}
+function timedOut(timeoutMs, still) {
+  return `Timed out after ${Math.round(timeoutMs / 1e3)}s ${still}`;
+}
+
+// src/ops/dataSources.ts
 var DEFAULT_WAIT_TIMEOUT_MS = 15 * 60 * 1e3;
 var POLL_MS2 = 3e3;
 function base(appId) {
@@ -2903,7 +2947,12 @@ async function addDocument(ctx, params) {
   );
   if (token.alreadyCurrent) {
     onProgress?.(`${filename}: unchanged, skipped`);
-    return { filename, skipped: true, document: token.document };
+    return {
+      filename,
+      skipped: true,
+      document: token.document,
+      documents: token.documents ?? [token.document]
+    };
   }
   onProgress?.(
     `${filename}: uploading ${(content.length / 1024 / 1024).toFixed(1)}MB\u2026`
@@ -2926,7 +2975,9 @@ async function addDocument(ctx, params) {
     filename,
     skipped: false,
     queued: confirmed.queued,
-    document: confirmed.document
+    document: confirmed.document,
+    documents: confirmed.documents ?? (confirmed.document ? [confirmed.document] : []),
+    outcome: confirmed.outcome
   };
 }
 async function waitForIngest(ctx, params) {
@@ -2936,50 +2987,64 @@ async function waitForIngest(ctx, params) {
     return { status: "up-to-date", documents: [] };
   }
   const wanted = new Set(documentIds);
-  const start = Date.now();
-  let transientSince = null;
-  for (; ; ) {
-    let docs;
-    try {
-      docs = await allDocuments(ctx, { slug, ids: documentIds });
-      transientSince = null;
-    } catch (err) {
-      if (!isTransientError(err)) {
-        throw err;
-      }
-      transientSince ??= Date.now();
-      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
-        throw err;
-      }
-      onProgress?.(
-        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
-      );
-      await sleep(POLL_MS2);
-      continue;
-    }
-    const tracked = (docs ?? []).filter((d) => wanted.has(d.id));
-    const pending = tracked.filter((d) => d.status === "processing");
-    const failed = tracked.filter((d) => d.status === "error");
-    if (pending.length === 0) {
-      return {
-        status: failed.length ? "error" : "done",
-        documents: tracked.map(summarize)
-      };
+  const pendingOf = (docs) => docs.filter((d) => d.status === "processing");
+  const outcome = await pollUntil(
+    async () => {
+      const docs = await allDocuments(ctx, { slug, ids: documentIds });
+      return (docs ?? []).filter((d) => wanted.has(d.id));
+    },
+    (tracked2) => pendingOf(tracked2).length === 0,
+    {
+      timeoutMs,
+      pollMs: POLL_MS2,
+      describe: (tracked2, start2) => `ingesting\u2026 ${tracked2.length - pendingOf(tracked2).length}/${tracked2.length} done (${elapsedSeconds(start2)}s)`,
+      onProgress
     }
-    if (Date.now() - start > timeoutMs) {
-      return {
-        status: "timeout",
-        documents: tracked.map(summarize),
-        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s with ${pending.length} document(s) still processing`
-      };
+  );
+  const tracked = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      documents: tracked.map(summarize),
+      error: timedOut(
+        timeoutMs,
+        `with ${pendingOf(tracked).length} document(s) still processing`
+      )
+    };
+  }
+  return {
+    status: tracked.some((d) => d.status === "error") ? "error" : "done",
+    documents: tracked.map(summarize)
+  };
+}
+async function waitForCandidate(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const pendingOf = (docs2) => docs2.filter((d) => d.status === "processing");
+  const outcome = await pollUntil(
+    () => allDocuments(ctx, { slug: params.slug, candidate: true }),
+    (docs2) => pendingOf(docs2).length === 0,
+    {
+      timeoutMs,
+      pollMs: POLL_MS2,
+      describe: (docs2, start2) => `rebuilding\u2026 ${docs2.length - pendingOf(docs2).length}/${docs2.length} done (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
     }
-    onProgress?.(
-      `ingesting\u2026 ${tracked.length - pending.length}/${tracked.length} done (${Math.round(
-        (Date.now() - start) / 1e3
-      )}s)`
-    );
-    await sleep(POLL_MS2);
+  );
+  const docs = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      documents: docs.map(summarize),
+      error: timedOut(
+        timeoutMs,
+        `with ${pendingOf(docs).length} document(s) still building`
+      )
+    };
   }
+  return {
+    status: docs.some((d) => d.status === "error") ? "error" : "ready",
+    documents: docs.map(summarize)
+  };
 }
 var DOCUMENTS_IDS_MAX = 200;
 function documents(ctx, params) {
@@ -3079,6 +3144,48 @@ function create2(ctx, params) {
     ...placement !== void 0 ? { placement } : {}
   });
 }
+function move(ctx, params) {
+  return call(ctx, "POST", `${base(ctx.appId)}/move`, {
+    slug: params.slug,
+    placement: params.placement
+  });
+}
+async function waitForMove(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const outcome = await pollUntil(
+    async () => {
+      const { dataSources } = await list8(ctx);
+      const source2 = dataSources.find((s) => s.slug === params.slug);
+      if (!source2) {
+        throw new Error(`Data source "${params.slug}" not found.`);
+      }
+      return source2;
+    },
+    (source2) => !source2.migration || source2.migration.error !== null,
+    {
+      timeoutMs,
+      pollMs: POLL_MS2,
+      describe: (source2, start2) => `moving\u2026 ${source2.migration.copied}/${source2.migration.total} documents (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
+    }
+  );
+  const source = outcome.value;
+  const migration = source.migration;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      source,
+      error: timedOut(
+        timeoutMs,
+        `with ${migration.copied}/${migration.total} documents copied`
+      )
+    };
+  }
+  if (migration?.error) {
+    return { status: "failed", source, error: migration.error };
+  }
+  return { status: "done", source };
+}
 function revectorize(ctx, params) {
   const { slug, ingest } = params;
   return call(
@@ -3091,51 +3198,1712 @@ function revectorize(ctx, params) {
     }
   );
 }
-function promote(ctx, params) {
-  return call(
-    ctx,
-    "POST",
-    `${base(ctx.appId)}/promote`,
-    {
-      slug: params.slug,
-      ...params.force ? { force: true } : {}
-    }
+function promote(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/promote`,
+    {
+      slug: params.slug,
+      ...params.force ? { force: true } : {}
+    }
+  );
+}
+function drop(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/versions/drop`,
+    {
+      slug: params.slug,
+      ...params.version !== void 0 ? { version: params.version } : {}
+    }
+  );
+}
+function rm(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/documents/delete`,
+    {
+      slug: params.slug,
+      documentId: params.documentId
+    }
+  );
+}
+function rmWhere(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/documents/delete-many`,
+    { slug: params.slug, filter: params.filter }
+  );
+}
+async function rmWhereAll(ctx, params) {
+  let deleted = 0;
+  while (true) {
+    const page = await rmWhere(ctx, params);
+    deleted += page.deleted;
+    if (page.remaining === 0 || page.deleted === 0) {
+      return { deleted };
+    }
+    params.onProgress?.(
+      `removed ${deleted.toLocaleString()} so far, ${page.remaining.toLocaleString()} remaining\u2026`
+    );
+  }
+}
+function deleteSource(ctx, slug) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/delete`,
+    { slug }
+  );
+}
+
+// src/ops/dataSourceJobs.ts
+var DEFAULT_WAIT_TIMEOUT_MS2 = 60 * 60 * 1e3;
+var POLL_MS3 = 5e3;
+function base2(appId) {
+  return `/_internal/v2/apps/${appId}/datasources/jobs`;
+}
+function start(ctx, params) {
+  const { slug, source, approve: approve2, budgetDollars, concurrency, limit } = params;
+  return call(ctx, "POST", base2(ctx.appId), {
+    slug,
+    source,
+    ...approve2 ? { approve: true } : {},
+    ...budgetDollars !== void 0 ? { budgetDollars } : {},
+    ...concurrency !== void 0 ? { concurrency } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+}
+async function uploadManifest(ctx, params) {
+  const token = await call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/manifest-token`,
+    { slug: params.slug }
+  );
+  await uploadDirect(token.upload, params.content, "manifest.jsonl");
+  return { key: token.key };
+}
+function list9(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base2(ctx.appId)}${qs({ slug: params?.slug })}`
+  );
+}
+function get7(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}`
+  );
+}
+function approve(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/approve`
+  );
+}
+function pause(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/pause`
+  );
+}
+function resume(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/resume`
+  );
+}
+function cancel(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/cancel`
+  );
+}
+function waitForPlan(ctx, params) {
+  return settle(ctx, params, (job) => job.state !== "planning");
+}
+function waitForJob(ctx, params) {
+  return settle(
+    ctx,
+    params,
+    (job) => !["planning", "planned", "running"].includes(job.state) || job.state === "planned" && (job.error !== null || !job.autoApprove)
+  );
+}
+async function settle(ctx, params, isSettled) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS2;
+  const outcome = await pollUntil(
+    async () => (await get7(ctx, { id: params.id })).job,
+    isSettled,
+    {
+      timeoutMs,
+      pollMs: POLL_MS3,
+      describe: describeProgress,
+      onProgress: params.onProgress
+    }
+  );
+  const job = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      job,
+      error: timedOut(timeoutMs, `; job is still ${job.state}`)
+    };
+  }
+  if (job.state === "failed" || job.state === "cancelled") {
+    return {
+      status: "failed",
+      job,
+      error: job.error ?? `The job was ${job.state}.`
+    };
+  }
+  if (job.state === "paused") {
+    return {
+      status: "failed",
+      job,
+      error: job.error ?? `The job paused (${job.pauseReason ?? "user"}). Resume it to continue.`
+    };
+  }
+  if (job.state === "planned" && (job.error !== null || job.autoApprove)) {
+    return {
+      status: "planned",
+      job,
+      error: job.error ?? "The plan is ready but the job did not start. Approve it once the cause is fixed."
+    };
+  }
+  return { status: "done", job };
+}
+function describeProgress(job, start2) {
+  const elapsed = `(${elapsedSeconds(start2)}s)`;
+  if (job.state === "planning") {
+    return job.enumerationDone ? `planning\u2026 reading a sample of ${job.counts.objectsSeen.toLocaleString()} objects ${elapsed}` : `planning\u2026 ${job.counts.objectsSeen.toLocaleString()} objects counted ${elapsed}`;
+  }
+  const total = job.plan?.projected.documents ?? job.counts.objectsSeen;
+  const processed = job.counts.documentsDone + job.counts.documentsSkipped + job.counts.documentsFailed;
+  const spend = `$${job.estimatedDollars.toFixed(2)}${job.budgetDollars !== null ? ` of $${job.budgetDollars.toFixed(2)}` : ""}`;
+  return `${job.state}\u2026 ${processed.toLocaleString()}/${total.toLocaleString()} documents \xB7 ${spend} ${elapsed}`;
+}
+
+// src/commands/_shared/dataSources.ts
+var DEFAULT_SOURCE = "default";
+var sourceOf = (a) => a.str("source") || DEFAULT_SOURCE;
+var timeoutOf = (a) => {
+  const seconds = a.str("timeout");
+  return seconds ? { timeoutMs: Number(seconds) * 1e3 } : {};
+};
+function failOnWait(result) {
+  if (result.status === "timeout") {
+    throw new CliError(result.error ?? "Timed out.", EXIT.timeout);
+  }
+  if (result.status === "failed" || result.status === "error") {
+    throw new CliError(result.error ?? "Failed.", EXIT.buildFailed);
+  }
+  if (result.status === "planned") {
+    throw new CliError(
+      `${result.error ?? "The plan is ready but the job did not start."} Fix the cause, then \`datasources jobs approve <id>\`.`,
+      EXIT.buildFailed
+    );
+  }
+}
+async function waitAndReport(ctx, a, id, mode, summary2) {
+  const wait = mode === "plan" ? waitForPlan : waitForJob;
+  const result = await wait(ctx, { id, ...timeoutOf(a), onProgress: progress });
+  out({ ...summary2, ...result });
+  failOnWait(result);
+}
+
+// src/ops/dataSourceConnectors.ts
+function base3(appId) {
+  return `/_internal/v2/apps/${appId}/datasources`;
+}
+function connect(ctx, params) {
+  const {
+    slug,
+    bucket,
+    region,
+    prefix,
+    endpoint,
+    accessKeyIdSecret,
+    secretAccessKeySecret,
+    deletions,
+    budgetDollarsPerSync
+  } = params;
+  return call(
+    ctx,
+    "POST",
+    `${base3(ctx.appId)}/connector`,
+    {
+      slug,
+      bucket,
+      region,
+      ...prefix !== void 0 ? { prefix } : {},
+      ...endpoint !== void 0 ? { endpoint } : {},
+      accessKeyIdSecret,
+      secretAccessKeySecret,
+      ...deletions !== void 0 ? { deletions } : {},
+      ...budgetDollarsPerSync !== void 0 ? { budgetDollarsPerSync } : {}
+    }
+  );
+}
+function get8(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base3(ctx.appId)}/connector${qs({ slug: params.slug })}`
+  );
+}
+function disconnect(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base3(ctx.appId)}/connector/remove`,
+    { slug: params.slug }
+  );
+}
+function sync(ctx, params) {
+  return call(ctx, "POST", `${base3(ctx.appId)}/sync`, {
+    slug: params.slug,
+    ...params.budgetDollars !== void 0 ? { budgetDollars: params.budgetDollars } : {}
+  });
+}
+
+// src/commands/dataSourceConnectors.ts
+var dataSourceConnectorsSpecs = {
+  "datasources connect": {
+    usage: "Usage: remy-admin datasources connect --source <slug> --bucket <name> --region <aws-region> [--prefix <p>] [--endpoint <url>] --access-key-secret <NAME> --secret-key-secret <NAME> [--deletions mirror|keep] [--budget-per-sync <dollars>]",
+    flags: {
+      source: { type: "string" },
+      bucket: { type: "string" },
+      region: { type: "string" },
+      prefix: { type: "string" },
+      endpoint: { type: "string" },
+      "access-key-secret": { type: "string" },
+      "secret-key-secret": { type: "string" },
+      deletions: { type: "string" },
+      "budget-per-sync": { type: "number", min: 0.01 }
+    }
+  },
+  "datasources connector": {
+    usage: "Usage: remy-admin datasources connector [--source <slug>]",
+    flags: { source: { type: "string" } }
+  },
+  "datasources disconnect": {
+    usage: "Usage: remy-admin datasources disconnect --source <slug>",
+    flags: { source: { type: "string" } }
+  },
+  "datasources sync": {
+    usage: "Usage: remy-admin datasources sync [--source <slug>] [--budget <dollars>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      budget: { type: "number", min: 0.01 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  }
+};
+async function connect2(ctx, a) {
+  const slug = a.str("source");
+  if (!slug) {
+    fatal("--source is required \u2014 a connector is bound to one named source.");
+  }
+  const bucket = a.str("bucket");
+  const region = a.str("region");
+  const accessKeyIdSecret = a.str("access-key-secret");
+  const secretAccessKeySecret = a.str("secret-key-secret");
+  for (const [flag, value] of [
+    ["bucket", bucket],
+    ["region", region],
+    ["access-key-secret", accessKeyIdSecret],
+    ["secret-key-secret", secretAccessKeySecret]
+  ]) {
+    if (!value) {
+      fatal(`--${flag} is required.`);
+    }
+  }
+  const deletions = a.str("deletions");
+  if (deletions && deletions !== "mirror" && deletions !== "keep") {
+    fatal(`--deletions must be "mirror" or "keep" (got "${deletions}").`);
+  }
+  const prefix = a.str("prefix");
+  const endpoint = a.str("endpoint");
+  const budget = a.num("budget-per-sync");
+  const { connector } = await connect(ctx, {
+    slug,
+    bucket,
+    region,
+    ...prefix !== void 0 ? { prefix } : {},
+    ...endpoint !== void 0 ? { endpoint } : {},
+    accessKeyIdSecret,
+    secretAccessKeySecret,
+    ...deletions ? { deletions } : {},
+    ...budget !== void 0 ? { budgetDollarsPerSync: budget } : {}
+  });
+  out({
+    dataSource: slug,
+    connector,
+    note: "Connected. Run `datasources sync --source " + slug + " --wait` to load the bucket; the first sync plans first and stops for `datasources jobs approve <id>` when the plan is over the per-sync budget."
+  });
+}
+async function show(ctx, a) {
+  const slug = sourceOf(a);
+  out({ dataSource: slug, ...await get8(ctx, { slug }) });
+}
+async function disconnect2(ctx, a) {
+  const slug = a.str("source");
+  if (!slug) {
+    fatal(
+      "--source is required \u2014 disconnecting never falls back to the default source."
+    );
+  }
+  const result = await disconnect(ctx, { slug });
+  out({
+    dataSource: slug,
+    ...result,
+    note: "The documents stay. Connect again to follow a bucket; unchanged files are recognised by content and cost nothing to re-sync."
+  });
+}
+async function sync2(ctx, a) {
+  const slug = sourceOf(a);
+  const budget = a.num("budget");
+  const { job } = await sync(ctx, {
+    slug,
+    ...budget !== void 0 ? { budgetDollars: budget } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: slug,
+      job,
+      note: "Syncing. Poll `datasources jobs status <id>`, or re-run with --wait. A plan over the per-sync budget waits in `planned` for `datasources jobs approve <id>`."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, "job", {
+    dataSource: slug,
+    action: "sync"
+  });
+}
+var dataSourceConnectorsHandlers = {
+  "datasources connect": connect2,
+  "datasources connector": show,
+  "datasources disconnect": disconnect2,
+  "datasources sync": sync2
+};
+var dataSourceConnectorsHelp = `
+Following an S3 bucket (connectors):
+  remy-admin datasources connect --source <slug> --bucket <name> --region <aws-region> [--prefix <p>] --access-key-secret <NAME> --secret-key-secret <NAME> [--deletions mirror|keep] [--budget-per-sync <dollars>]
+  remy-admin datasources connector [--source <slug>]
+  remy-admin datasources sync [--source <slug>] [--budget <dollars>] [--wait] [--timeout <sec>]
+  remy-admin datasources disconnect --source <slug>
+
+  A connector makes a bucket the customer owns the origin of a source. The
+  credentials are the NAMES of two app secrets \u2014 set them first with
+  \`remy-admin secrets set ARCHIVE_S3_KEY --prod <value>\` (or in the dashboard);
+  never put a key on a command line or in code. connect checks that both
+  secrets exist and that the keys can list the prefix before it records
+  anything, and refuses otherwise with the S3 error.
+
+  sync lists the bucket, compares every object's ETag with what was ingested
+  before, and runs a job (see above) over what is new or changed: the same
+  plan, the same gates, auto-approved under the connector's per-sync budget.
+  A plan over the budget \u2014 the first backfill of a big bucket \u2014 waits in
+  \`planned\` for \`jobs approve <id>\`; the nightly deltas run unattended.
+  A sync over an unchanged bucket costs nothing. Keys that disappeared from
+  the bucket are removed from the source at the end of a full sync under the
+  default \`--deletions mirror\`; \`--deletions keep\` leaves them. A changed
+  object replaces its document; the old one is kept as lineage.
+
+  Scheduling is the app's: a nightly sync is an ordinary cron interface job
+  whose method calls \`Source.sync()\` from the SDK. There is no platform
+  schedule to configure.
+
+  On a source without a mapper, objects whose extension no extractor reads
+  are skipped, not failed. Re-running connect with the same bucket, region,
+  prefix and endpoint updates credentials and policy in place; pointing a
+  source at a different bucket needs a disconnect first. disconnect keeps
+  every document \u2014 only the link and its object index go.
+`;
+
+// src/commands/dataSourceEvals.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/ops/dataSourceEvals.ts
+var DEFAULT_WAIT_TIMEOUT_MS3 = 30 * 60 * 1e3;
+var POLL_MS4 = 4e3;
+function base4(appId) {
+  return `/_internal/v2/apps/${appId}/datasources`;
+}
+function hydrate(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/hydrate`,
+    { slug: params.slug }
+  );
+}
+async function waitForHydration(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS3;
+  const outcome = await pollUntil(
+    async () => {
+      const { dataSources } = await list8(ctx);
+      const source2 = dataSources.find((s) => s.slug === params.slug);
+      if (!source2) {
+        throw new Error(`Data source "${params.slug}" not found.`);
+      }
+      return source2;
+    },
+    (source2) => !source2.hydration || source2.hydration.error !== null,
+    {
+      timeoutMs,
+      pollMs: POLL_MS4,
+      describe: (source2, start2) => `loading\u2026 ${source2.hydration.copied}/${source2.hydration.total} documents (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
+    }
+  );
+  const source = outcome.value;
+  const hydration = source.hydration;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      source,
+      error: timedOut(
+        timeoutMs,
+        `with ${hydration.copied}/${hydration.total} documents loaded`
+      )
+    };
+  }
+  if (hydration?.error) {
+    return { status: "failed", source, error: hydration.error };
+  }
+  return { status: "done", source };
+}
+function sample(ctx, params) {
+  const { slug, size, as, filter, stratify, placement } = params;
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/sample`,
+    {
+      slug,
+      size,
+      ...as ? { as } : {},
+      ...filter ? { filter } : {},
+      ...stratify ? { stratify } : {},
+      ...placement !== void 0 ? { placement } : {}
+    }
+  );
+}
+function createSet(ctx, params) {
+  const { slug, name, description, size, style, modelId, tags, seed } = params;
+  return call(ctx, "POST", `${base4(ctx.appId)}/eval/sets`, {
+    slug,
+    name,
+    ...description ? { description } : {},
+    ...size !== void 0 ? { size } : {},
+    ...style ? { style } : {},
+    ...modelId ? { modelId } : {},
+    ...tags?.length ? { tags } : {},
+    ...seed !== void 0 ? { seed } : {}
+  });
+}
+function listSets(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/sets${qs({ slug: params?.slug })}`
+  );
+}
+function getSet(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}${qs({
+      queries: params.queries ? "true" : void 0
+    })}`
+  );
+}
+function deleteSet(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/delete`
+  );
+}
+function addQueries(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/queries`,
+    { queries: params.queries }
+  );
+}
+function listQueries(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/queries`
+  );
+}
+function deleteQuery(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/queries/delete`,
+    { queryId: params.queryId }
+  );
+}
+function run(ctx, params) {
+  const { setId, slug, candidate, label, retrieval } = params;
+  return call(ctx, "POST", `${base4(ctx.appId)}/eval/runs`, {
+    setId,
+    ...slug ? { slug } : {},
+    ...candidate ? { candidate: true } : {},
+    ...label ? { label } : {},
+    ...retrieval && Object.keys(retrieval).length ? { retrieval } : {}
+  });
+}
+function listRuns(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/runs${qs({ setId: params?.setId, slug: params?.slug })}`
+  );
+}
+function getRun(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/runs/${encodeURIComponent(params.id)}${qs({
+      queries: params.queries ? "true" : void 0,
+      worst: params.worst
+    })}`
+  );
+}
+function compare(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/runs/compare${qs({ a: params.a, b: params.b })}`
+  );
+}
+async function waitForRun(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS3;
+  const outcome = await pollUntil(
+    async () => (await getRun(ctx, { id: params.id })).run,
+    (run4) => run4.state === "done" || run4.state === "failed",
+    {
+      timeoutMs,
+      pollMs: POLL_MS4,
+      describe: (run4, start2) => `${run4.state}\u2026 ${run4.completed}/${run4.total} queries (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
+    }
+  );
+  const run3 = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      run: run3,
+      error: timedOut(
+        timeoutMs,
+        `; run is ${run3.state} (${run3.completed}/${run3.total})`
+      )
+    };
+  }
+  if (run3.state === "failed") {
+    return { status: "failed", run: run3, error: run3.error ?? "The run failed." };
+  }
+  return { status: "done", run: run3 };
+}
+async function waitForSet(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS3;
+  const outcome = await pollUntil(
+    async () => (await getSet(ctx, { id: params.id })).set,
+    (set4) => set4.state === "ready" || set4.state === "failed",
+    {
+      timeoutMs,
+      pollMs: POLL_MS4,
+      describe: (set4, start2) => `${set4.state}\u2026 (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
+    }
+  );
+  const set3 = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      set: set3,
+      error: timedOut(timeoutMs, `; set is still ${set3.state}`)
+    };
+  }
+  if (set3.state === "failed") {
+    return { status: "failed", set: set3, error: set3.error ?? "Generation failed." };
+  }
+  return { status: "done", set: set3 };
+}
+
+// src/commands/dataSourceEvals.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var dataSourceEvalsSpecs = {
+  "datasources hydrate": {
+    usage: "Usage: remy-admin datasources hydrate [--source <slug>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  },
+  "datasources sample": {
+    usage: "Usage: remy-admin datasources sample --source <slug> --size <n> [--as <slug>] [--filter <k=v,...|json>] [--stratify <metadata-key>] [--placement <resource-id|shared>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      size: { type: "number", min: 1 },
+      as: { type: "string" },
+      filter: { type: "string" },
+      stratify: { type: "string" },
+      placement: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["size"],
+      message: "--size <n> is required (documents to draw, up to 2000)."
+    }
+  },
+  "datasources eval create": {
+    usage: "Usage: remy-admin datasources eval create --source <slug> --name <name> [--size <n>] [--style cloze|question] [--model <id>] [--tags <a,b>] [--description <text>] [--seed <n>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      name: { type: "string" },
+      size: { type: "number", min: 0 },
+      style: { type: "string" },
+      model: { type: "string" },
+      tags: { type: "string" },
+      description: { type: "string" },
+      seed: { type: "number", min: 0 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: { flags: ["name"], message: "--name is required." }
+  },
+  "datasources eval list": {
+    usage: "Usage: remy-admin datasources eval list [--source <slug>]",
+    flags: { source: { type: "string" } }
+  },
+  "datasources eval get": {
+    usage: "Usage: remy-admin datasources eval get <setId> [--queries]",
+    positionals: [{ name: "id", required: true }],
+    flags: { queries: { type: "boolean" } }
+  },
+  "datasources eval delete": {
+    usage: "Usage: remy-admin datasources eval delete <setId>",
+    positionals: [{ name: "id", required: true }]
+  },
+  "datasources eval add": {
+    usage: "Usage: remy-admin datasources eval add --set <id> --query <text> (--expect <ref,...> | --expect-file <name,...> | --expect-external <id,...>) [--passage <text>] [--tags <a,b>]",
+    flags: {
+      set: { type: "string" },
+      query: { type: "string" },
+      expect: { type: "string" },
+      "expect-file": { type: "string" },
+      "expect-external": { type: "string" },
+      passage: { type: "string" },
+      tags: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["expect", "expect-file", "expect-external"],
+      message: "Say which document should come back: --expect <documentId|filename|externalId,...>, --expect-file <filename,...> or --expect-external <externalId,...>."
+    }
+  },
+  "datasources eval import": {
+    usage: "Usage: remy-admin datasources eval import --set <id> <file.jsonl>",
+    positionals: [{ name: "file", required: true }],
+    flags: { set: { type: "string" } }
+  },
+  "datasources eval queries": {
+    usage: "Usage: remy-admin datasources eval queries --set <id>",
+    flags: { set: { type: "string" } }
+  },
+  "datasources eval rm": {
+    usage: "Usage: remy-admin datasources eval rm --set <id> <queryId>",
+    positionals: [{ name: "queryId", required: true }],
+    flags: { set: { type: "string" } }
+  },
+  "datasources eval run": {
+    usage: "Usage: remy-admin datasources eval run --set <id> [--source <slug>] [--candidate] [--label <text>] [--mode hybrid|semantic|lexical] [--rerank true|false] [--rerank-model <id>] [--candidates <n>] [--hybrid true|false] [--top-k <n>] [--wait] [--timeout <sec>]",
+    flags: {
+      set: { type: "string" },
+      source: { type: "string" },
+      candidate: { type: "boolean" },
+      label: { type: "string" },
+      mode: { type: "string" },
+      rerank: { type: "string" },
+      "rerank-model": { type: "string" },
+      candidates: { type: "number", min: 1 },
+      hybrid: { type: "string" },
+      "top-k": { type: "number", min: 1 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: { flags: ["set"], message: "--set <id> is required." }
+  },
+  "datasources eval runs": {
+    usage: "Usage: remy-admin datasources eval runs [--set <id>] [--source <slug>]",
+    flags: { set: { type: "string" }, source: { type: "string" } }
+  },
+  "datasources eval result": {
+    usage: "Usage: remy-admin datasources eval result <runId> [--queries] [--worst <n>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { queries: { type: "boolean" }, worst: { type: "number", min: 1 } }
+  },
+  "datasources eval compare": {
+    usage: "Usage: remy-admin datasources eval compare <runA> <runB>",
+    positionals: [
+      { name: "a", required: true },
+      { name: "b", required: true }
+    ]
+  }
+};
+var requireSet = (a) => {
+  const id = a.str("set");
+  if (!id) {
+    fatal("--set <id> is required.");
+  }
+  return id;
+};
+var splitList = (raw) => (raw ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+var triState = (a, flag) => {
+  const raw = a.str(flag);
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw !== "true" && raw !== "false") {
+    fatal(`--${flag} must be "true" or "false" (got "${raw}").`);
+  }
+  return raw === "true";
+};
+function selectorFromFlag(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw.trimStart().startsWith("{")) {
+    try {
+      return JSON.parse(raw);
+    } catch (err) {
+      fatal(`--filter is not valid JSON: ${err.message}`);
+    }
+  }
+  const metadata = {};
+  for (const part of raw.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) {
+      fatal(`--filter entries must be key=value (got "${trimmed}").`);
+    }
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim();
+    metadata[key] = value === "true" ? true : value === "false" ? false : value !== "" && !Number.isNaN(Number(value)) ? Number(value) : value;
+  }
+  return { metadata };
+}
+async function hydrate2(ctx, a) {
+  const slug = a.str("source") || DEFAULT_SOURCE;
+  const started = await hydrate(ctx, { slug });
+  if (started.resident || !a.bool("wait")) {
+    out({
+      dataSource: slug,
+      ...started,
+      ...started.resident ? { note: "The index is already loaded." } : {
+        note: "Loading in the background. `datasources list` shows progress; re-run with --wait to block."
+      }
+    });
+    return;
+  }
+  const result = await waitForHydration(ctx, {
+    slug,
+    ...timeoutOf(a),
+    onProgress: progress
+  });
+  out({ dataSource: slug, action: "hydrate", ...result });
+  failOnWait(result);
+}
+async function sampleCmd(ctx, a) {
+  const slug = a.str("source");
+  if (!slug) {
+    fatal("--source is required \u2014 a sample is drawn from one named source.");
+  }
+  const placementRaw = a.str("placement");
+  const placement = placementRaw === void 0 ? void 0 : placementRaw === "shared" ? "shared" : { resourceId: placementRaw };
+  const result = await sample(ctx, {
+    slug,
+    size: a.num("size"),
+    ...a.str("as") ? { as: a.str("as") } : {},
+    ...a.str("filter") ? { filter: selectorFromFlag(a.str("filter")) } : {},
+    ...a.str("stratify") ? { stratify: a.str("stratify") } : {},
+    ...placement !== void 0 ? { placement } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      ...result,
+      note: `Sampling into "${result.dataSource.slug}". Poll \`datasources jobs status ${result.job.id}\` or re-run with --wait.`
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, result.job.id, "job", {
+    dataSource: result.dataSource,
+    action: "sample"
+  });
+}
+async function evalCreate(ctx, a) {
+  const slug = a.str("source") || DEFAULT_SOURCE;
+  const style = a.str("style");
+  if (style && style !== "cloze" && style !== "question") {
+    fatal(`--style must be "cloze" or "question" (got "${style}").`);
+  }
+  const size = a.num("size");
+  const seed = a.num("seed");
+  const { set: set3 } = await createSet(ctx, {
+    slug,
+    name: a.str("name"),
+    ...a.str("description") ? { description: a.str("description") } : {},
+    ...size !== void 0 ? { size } : {},
+    ...style ? { style } : {},
+    ...a.str("model") ? { modelId: a.str("model") } : {},
+    ...a.str("tags") ? { tags: splitList(a.str("tags")) } : {},
+    ...seed !== void 0 ? { seed } : {}
+  });
+  const generating = set3.state === "queued" || set3.state === "generating";
+  if (!generating || !a.bool("wait")) {
+    out({
+      dataSource: slug,
+      set: set3,
+      note: generating ? "Generating in the background. `datasources eval get <id>` shows the state; re-run with --wait to block." : "Empty set. Add queries with `datasources eval add` or `eval import`."
+    });
+    return;
+  }
+  const result = await waitForSet(ctx, {
+    id: set3.id,
+    ...timeoutOf(a),
+    onProgress: progress
+  });
+  out({ dataSource: slug, action: "create", ...result });
+  failOnWait(result);
+}
+async function evalList(ctx, a) {
+  const slug = a.str("source");
+  out(await listSets(ctx, slug ? { slug } : void 0));
+}
+async function evalGet(ctx, a) {
+  out(
+    await getSet(ctx, {
+      id: a.req("id"),
+      ...a.bool("queries") ? { queries: true } : {}
+    })
+  );
+}
+async function evalDelete(ctx, a) {
+  out(await deleteSet(ctx, { id: a.req("id") }));
+}
+function expectFromFlags(a) {
+  const expect = {};
+  for (const ref of splitList(a.str("expect"))) {
+    if (UUID_RE.test(ref)) {
+      (expect.documentIds ??= []).push(ref);
+    } else if (ref.includes(".")) {
+      (expect.filenames ??= []).push(ref);
+    } else {
+      (expect.externalIds ??= []).push(ref);
+    }
+  }
+  for (const name of splitList(a.str("expect-file"))) {
+    (expect.filenames ??= []).push(name);
+  }
+  for (const id of splitList(a.str("expect-external"))) {
+    (expect.externalIds ??= []).push(id);
+  }
+  return expect;
+}
+async function evalAdd(ctx, a) {
+  const id = requireSet(a);
+  const query3 = a.str("query");
+  if (!query3) {
+    fatal("--query is required.");
+  }
+  const result = await addQueries(ctx, {
+    id,
+    queries: [
+      {
+        query: query3,
+        expect: expectFromFlags(a),
+        ...a.str("passage") ? { passage: a.str("passage") } : {},
+        ...a.str("tags") ? { tags: splitList(a.str("tags")) } : {}
+      }
+    ]
+  });
+  out({ set: id, ...result });
+}
+async function evalImport(ctx, a) {
+  const id = requireSet(a);
+  const file = a.req("file");
+  const abs = path3.isAbsolute(file) ? file : path3.join(WORKSPACE_DIR, file);
+  let content;
+  try {
+    content = fs3.readFileSync(abs, "utf8");
+  } catch (err) {
+    fatal(`Could not read "${file}": ${err.message}`);
+  }
+  const rows = [];
+  content.split("\n").forEach((line, i) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      fatal(`${file}:${i + 1} is not valid JSON.`);
+    }
+    if (typeof parsed?.query !== "string" || typeof parsed?.expect !== "object") {
+      fatal(
+        `${file}:${i + 1} needs { "query": "...", "expect": { "filenames" | "documentIds" | "externalIds" | "contentHashes": [...] } }.`
+      );
+    }
+    rows.push(parsed);
+  });
+  if (rows.length === 0) {
+    fatal(`"${file}" has no queries.`);
+  }
+  let added = 0;
+  let queryCount = 0;
+  for (let i = 0; i < rows.length; i += 500) {
+    progress(`importing ${Math.min(i + 500, rows.length)}/${rows.length}\u2026`);
+    const result = await addQueries(ctx, {
+      id,
+      queries: rows.slice(i, i + 500)
+    });
+    added += result.added;
+    queryCount = result.queryCount;
+  }
+  out({ set: id, added, queryCount });
+}
+async function evalQueries(ctx, a) {
+  out(await listQueries(ctx, { id: requireSet(a) }));
+}
+async function evalRm(ctx, a) {
+  out(
+    await deleteQuery(ctx, {
+      id: requireSet(a),
+      queryId: a.req("queryId")
+    })
+  );
+}
+async function evalRun(ctx, a) {
+  const mode = a.str("mode");
+  if (mode && !["hybrid", "semantic", "lexical"].includes(mode)) {
+    fatal(`--mode must be "hybrid", "semantic" or "lexical" (got "${mode}").`);
+  }
+  const rerank = triState(a, "rerank");
+  const hybrid = triState(a, "hybrid");
+  const rerankModel = a.str("rerank-model");
+  const candidates = a.num("candidates");
+  const topK = a.num("top-k");
+  const retrieval = {
+    ...mode ? { mode } : {},
+    ...hybrid !== void 0 ? { hybrid } : {},
+    ...rerank !== void 0 || rerankModel || candidates !== void 0 ? {
+      rerank: {
+        ...rerank !== void 0 ? { enabled: rerank } : {},
+        ...rerankModel ? { modelId: rerankModel } : {},
+        ...candidates !== void 0 ? { candidates } : {}
+      }
+    } : {},
+    ...topK !== void 0 ? { topK } : {}
+  };
+  const { run: run3 } = await run(ctx, {
+    setId: a.str("set"),
+    ...a.str("source") ? { slug: a.str("source") } : {},
+    ...a.bool("candidate") ? { candidate: true } : {},
+    ...a.str("label") ? { label: a.str("label") } : {},
+    retrieval
+  });
+  if (!a.bool("wait")) {
+    out({
+      run: run3,
+      note: "Running in the background. `datasources eval result <id>` shows the numbers when it is done; re-run with --wait to block."
+    });
+    return;
+  }
+  const result = await waitForRun(ctx, {
+    id: run3.id,
+    ...timeoutOf(a),
+    onProgress: progress
+  });
+  out({ action: "run", ...result });
+  failOnWait(result);
+}
+async function evalRuns(ctx, a) {
+  const setId = a.str("set");
+  const slug = a.str("source");
+  out(
+    await listRuns(ctx, {
+      ...setId ? { setId } : {},
+      ...slug ? { slug } : {}
+    })
+  );
+}
+async function evalResult(ctx, a) {
+  const worst = a.num("worst");
+  out(
+    await getRun(ctx, {
+      id: a.req("id"),
+      ...a.bool("queries") ? { queries: true } : {},
+      ...worst !== void 0 ? { worst } : {}
+    })
+  );
+}
+async function evalCompare(ctx, a) {
+  out(await compare(ctx, { a: a.req("a"), b: a.req("b") }));
+}
+var dataSourceEvalsHandlers = {
+  "datasources hydrate": hydrate2,
+  "datasources sample": sampleCmd,
+  "datasources eval create": evalCreate,
+  "datasources eval list": evalList,
+  "datasources eval get": evalGet,
+  "datasources eval delete": evalDelete,
+  "datasources eval add": evalAdd,
+  "datasources eval import": evalImport,
+  "datasources eval queries": evalQueries,
+  "datasources eval rm": evalRm,
+  "datasources eval run": evalRun,
+  "datasources eval runs": evalRuns,
+  "datasources eval result": evalResult,
+  "datasources eval compare": evalCompare
+};
+var dataSourceEvalsHelp = `
+Warming and sampling:
+  remy-admin datasources hydrate [--source <slug>] [--wait]
+  remy-admin datasources sample --source <slug> --size <n> [--as <slug>] [--filter <k=v,...|json>] [--stratify <key>] [--placement <id|shared>] [--wait]
+
+  A large source whose index was evicted (the shared pool holds a working set,
+  not everything) answers searches with index_warming while it reloads in the
+  background; small sources reload inside the search and never show it.
+  \`hydrate\` starts that reload ahead of time \u2014 before a demo, say \u2014 and
+  \`--wait\` blocks until the index is back. \`datasources list\` shows the
+  reload's progress under \`hydration\`.
+
+  \`sample\` draws documents from a source into a new one that shares its
+  exact pinned config, so what you measure on the sample says something about
+  the parent. Uniform by default; --stratify <metadata key> takes each value
+  in proportion; --filter scopes the draw. It runs as a job (auto-approved;
+  extraction is reused, so the plan is chunk + embed only). Documents keep
+  their content hashes, which is what lets a query set built on the sample
+  score the parent as well. Up to 2,000 documents.
+
+Retrieval evals:
+  remy-admin datasources eval create --source <slug> --name <name> [--size <n>] [--style cloze|question] [--model <id>] [--tags <a,b>] [--wait]
+  remy-admin datasources eval list [--source <slug>]
+  remy-admin datasources eval get <setId> [--queries]
+  remy-admin datasources eval add --set <id> --query <text> --expect <ref,...> [--passage <text>] [--tags <a,b>]
+  remy-admin datasources eval import --set <id> <file.jsonl>
+  remy-admin datasources eval queries --set <id>
+  remy-admin datasources eval rm --set <id> <queryId>
+  remy-admin datasources eval delete <setId>
+  remy-admin datasources eval run --set <id> [--source <slug>] [--candidate] [--label <text>] [retrieval options] [--wait]
+  remy-admin datasources eval runs [--set <id>] [--source <slug>]
+  remy-admin datasources eval result <runId> [--queries] [--worst <n>]
+  remy-admin datasources eval compare <runA> <runB>
+
+  A query SET is a list of questions with the documents that should come
+  back. \`create --size N\` generates them from the corpus: the default
+  \`cloze\` style holds one sentence out of a chunk and uses it as the query
+  (free and deterministic, but it flatters keyword matching \u2014 a real user
+  does not type sentences from the document); \`--style question\` has a
+  chat model write the question a user would ask (a model call per query,
+  cost recorded on the set). Both record the document AND the chunk that
+  answers, and both skip sentences that restate the title. Add real user
+  questions with \`add\` (--expect takes document ids, filenames or external
+  ids, comma-separated; every reference must exist) or \`import\` a JSONL of
+  {"query","expect":{"filenames":[...]},"passage"?,"tags"?}.
+
+  A RUN scores a set against one target: the set's own source by default,
+  --source another (the parent of a sample, or a sample of the parent \u2014
+  expectations resolve by content hash), --candidate the target's candidate
+  version. Every query is a real search through the same code apps use, ten
+  results deep, with explain on. Retrieval options override the target's
+  live config for the run only: --mode, --rerank true|false, --rerank-model
+  <id>, --candidates <n>, --hybrid true|false, --top-k <n>. Runs are capped
+  at 2,000 queries and cost what 2,000 searches cost.
+
+  \`result\` prints the aggregates \u2014 recall@1/5/10, chunk recall, MRR,
+  nDCG@10, latency p50/p95, cost per query, how often reranking ran, and
+  which branch (dense, lexical, both) found the expected document, per tag
+  too \u2014 plus \`--worst N\` for the queries that missed and what came back
+  instead, or \`--queries\` for every row. \`compare\` puts two runs side by
+  side with deltas and, when they share a set, per-query wins and losses.
+  The output is JSON; the table is yours to write.
+
+  The workflow: sample the source, create a set on the sample, run it against
+  the live version, revectorize with the change you want to test, run again
+  with --candidate, compare, promote or drop.
+`;
+
+// src/commands/dataSourceJobs.ts
+import fs4 from "fs";
+import path4 from "path";
+var dataSourceJobsSpecs = {
+  "datasources jobs start": {
+    usage: "Usage: remy-admin datasources jobs start [--source <slug>] (--store <name> [--access <private|public>] [--prefix <p>] | --manifest <file.jsonl>) [--limit <n>] [--budget <dollars>] [--concurrency <n>] [--approve] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      store: { type: "string" },
+      access: { type: "string" },
+      prefix: { type: "string" },
+      manifest: { type: "string" },
+      limit: { type: "number", min: 1 },
+      budget: { type: "number", min: 0.01 },
+      concurrency: { type: "number", min: 1 },
+      approve: { type: "boolean" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["store", "manifest"],
+      message: "Give the job something to read: --store <name> [--prefix <p>], or --manifest <file.jsonl>."
+    }
+  },
+  "datasources jobs list": {
+    usage: "Usage: remy-admin datasources jobs list [--source <slug>]",
+    flags: { source: { type: "string" } }
+  },
+  "datasources jobs status": {
+    usage: "Usage: remy-admin datasources jobs status <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "datasources jobs approve": {
+    usage: "Usage: remy-admin datasources jobs approve <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "datasources jobs pause": {
+    usage: "Usage: remy-admin datasources jobs pause <id>",
+    positionals: [{ name: "id", required: true }]
+  },
+  "datasources jobs resume": {
+    usage: "Usage: remy-admin datasources jobs resume <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "datasources jobs cancel": {
+    usage: "Usage: remy-admin datasources jobs cancel <id>",
+    positionals: [{ name: "id", required: true }]
+  }
+};
+async function jobsStart(ctx, a) {
+  const slug = sourceOf(a);
+  const store = a.str("store");
+  const manifest = a.str("manifest");
+  if (store && manifest) {
+    fatal("Give --store or --manifest, not both.");
+  }
+  let source;
+  if (manifest) {
+    const abs = path4.isAbsolute(manifest) ? manifest : path4.join(WORKSPACE_DIR, manifest);
+    let content;
+    try {
+      content = fs4.readFileSync(abs);
+    } catch (err) {
+      fatal(`Could not read manifest "${manifest}": ${err.message}`);
+    }
+    progress(`uploading manifest (${(content.length / 1024).toFixed(0)} KB)\u2026`);
+    const { key } = await uploadManifest(ctx, { slug, content });
+    source = { type: "manifest", key };
+  } else {
+    const access = a.str("access") ?? "private";
+    if (access !== "private" && access !== "public") {
+      fatal(`--access must be "private" or "public" (got "${access}").`);
+    }
+    source = {
+      type: "store",
+      store,
+      access,
+      prefix: a.str("prefix") ?? ""
+    };
+  }
+  const budget = a.num("budget");
+  const concurrency = a.num("concurrency");
+  const limit = a.num("limit");
+  const { job } = await start(ctx, {
+    slug,
+    source,
+    ...a.bool("approve") ? { approve: true } : {},
+    ...budget !== void 0 ? { budgetDollars: budget } : {},
+    ...concurrency !== void 0 ? { concurrency } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: slug,
+      job,
+      note: job.autoApprove ? "Planning, then running once the plan passes the gates. Poll `datasources jobs status <id>` or re-run with --wait." : "Planning. When the plan is ready, review it with `datasources jobs status <id>` and run `datasources jobs approve <id>`."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, job.autoApprove ? "job" : "plan", {
+    dataSource: slug,
+    action: "start",
+    ...job.autoApprove ? {} : { note: "Review the plan, then `datasources jobs approve <id>`." }
+  });
+}
+async function jobsList(ctx, a) {
+  const slug = a.str("source");
+  out(await list9(ctx, slug ? { slug } : void 0));
+}
+async function jobsStatus(ctx, a) {
+  const id = a.req("id");
+  if (!a.bool("wait")) {
+    out(await get7(ctx, { id }));
+    return;
+  }
+  await waitAndReport(ctx, a, id, "job", { action: "status" });
+}
+async function jobsApprove(ctx, a) {
+  const id = a.req("id");
+  const { job } = await approve(ctx, { id });
+  if (!a.bool("wait")) {
+    out({
+      job,
+      note: "Running. Poll `datasources jobs status <id>` or re-run with --wait."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, id, "job", { action: "approve" });
+}
+async function jobsPause(ctx, a) {
+  out(await pause(ctx, { id: a.req("id") }));
+}
+async function jobsResume(ctx, a) {
+  const id = a.req("id");
+  const { job } = await resume(ctx, { id });
+  if (!a.bool("wait")) {
+    out({ job });
+    return;
+  }
+  await waitAndReport(ctx, a, id, "job", { action: "resume" });
+}
+async function jobsCancel(ctx, a) {
+  out(await cancel(ctx, { id: a.req("id") }));
+}
+var dataSourceJobsHandlers = {
+  "datasources jobs start": jobsStart,
+  "datasources jobs list": jobsList,
+  "datasources jobs status": jobsStatus,
+  "datasources jobs approve": jobsApprove,
+  "datasources jobs pause": jobsPause,
+  "datasources jobs resume": jobsResume,
+  "datasources jobs cancel": jobsCancel
+};
+var dataSourceJobsHelp = `
+Bulk ingestion (jobs):
+  remy-admin datasources jobs start [--source <slug>] --store <name> [--access <private|public>] [--prefix <p>] [options]
+  remy-admin datasources jobs start [--source <slug>] --manifest <file.jsonl> [options]
+  remy-admin datasources jobs list [--source <slug>]
+  remy-admin datasources jobs status <id> [--wait] [--timeout <sec>]
+  remy-admin datasources jobs approve <id> [--wait] [--timeout <sec>]
+  remy-admin datasources jobs pause|resume|cancel <id>
+
+  A job loads a whole corpus at once. It reads either every object under a
+  prefix of one of the app's file stores (\`files put\` fills one; an app can
+  write one at runtime) or a manifest you upload: JSONL, one line per document,
+  {"url": "https://\u2026", "filename": "x.pdf", "externalId": "\u2026", "metadata": {\u2026}}.
+  filename, externalId and metadata are optional; the URL must be public.
+
+  Nothing is spent until you say so. The platform counts the source, reads a
+  sample of about a hundred documents, and writes a plan: documents, chunks,
+  cost per stage (embedding, extraction, contextual) at today's rates, storage,
+  whether it fits where the source lives, and a duration. \`jobs status\` shows
+  it; \`jobs approve\` starts the run. Two gates: the corpus has to fit the
+  source's placement (a shared-pool source over the per-source cap answers
+  plan_requires_dedicated: place it on dedicated capacity first), and the
+  workspace has to be able to cover the projection (insufficient_credits).
+
+  Options on start:
+    --approve          Run as soon as the plan passes the gates, no separate approve
+    --budget <dollars> Pause when estimated spend reaches this (default 1.5x the plan)
+    --concurrency <n>  Batches in flight at once (default 8, max 64)
+    --limit <n>        Only the first N objects: a cheap sample of the corpus
+    --wait             Block until the plan is ready (or, with --approve, until done)
+
+  While running, documents are read in batches of fifty with one embedding
+  call per batch. Unchanged documents are skipped by content hash, so re-running
+  a job over the same source costs nothing new. Per-document failures are kept
+  on the job (\`jobs status\` lists the last twenty) and the run continues; five
+  failed batches in a row pause it, as does the budget. \`jobs resume\` continues
+  from the checkpoint and retries failed batches; \`jobs cancel\` stops it and
+  keeps what was indexed. Search works on the partial corpus throughout.
+
+  One bulk operation per source: a job refuses to start during a move or while
+  a candidate version exists, and moves, re-vectorizes and deletes refuse while
+  a job is in flight (data_source_busy). Interactive \`add\` keeps working.
+
+  --wait exit codes: 0 done \xB7 1 the job failed, paused, was cancelled, or sits
+  in planned because a gate refused it (approve once the cause is fixed) \xB7
+  2 still running when --timeout elapsed (default 3600s).
+`;
+
+// src/ops/dataSourceMappers.ts
+function base5(appId) {
+  return `/_internal/v2/apps/${appId}/datasources`;
+}
+function selectionBody(selection) {
+  if ("connector" in selection) {
+    return { connector: true };
+  }
+  return {
+    store: selection.store,
+    ...selection.access ? { access: selection.access } : {},
+    ...selection.prefix !== void 0 ? { prefix: selection.prefix } : {}
+  };
+}
+function inspect(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base5(ctx.appId)}/inspect`,
+    {
+      ...params.slug ? { slug: params.slug } : {},
+      ...selectionBody(params.selection),
+      ...params.keys ? { keys: params.keys } : {},
+      ...params.limit !== void 0 ? { limit: params.limit } : {}
+    }
+  );
+}
+function mapTest(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base5(ctx.appId)}/map-test`,
+    {
+      slug: params.slug,
+      ...selectionBody(params.selection),
+      ...params.keys ? { keys: params.keys } : {},
+      ...params.limit !== void 0 ? { limit: params.limit } : {},
+      ...params.dev ? { dev: true } : {}
+    }
+  );
+}
+function remap(ctx, params) {
+  return call(ctx, "POST", `${base5(ctx.appId)}/remap`, {
+    slug: params.slug,
+    ...params.budgetDollars !== void 0 ? { budgetDollars: params.budgetDollars } : {},
+    ...params.limit !== void 0 ? { limit: params.limit } : {}
+  });
+}
+function quarantine(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base5(ctx.appId)}/jobs/${params.id}/quarantine${qs({
+      ...params.kind ? { kind: params.kind } : {},
+      ...params.reason ? { reason: params.reason } : {},
+      ...params.cursor ? { cursor: params.cursor } : {},
+      ...params.limit !== void 0 ? { limit: params.limit } : {}
+    })}`
+  );
+}
+function replay(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base5(ctx.appId)}/jobs/${params.id}/replay`,
+    params.kind ? { kind: params.kind } : {}
+  );
+}
+
+// src/commands/dataSourceMappers.ts
+var SELECTION_FLAGS = {
+  store: { type: "string" },
+  access: { type: "string" },
+  prefix: { type: "string" },
+  connector: { type: "boolean" },
+  keys: { type: "string" }
+};
+var dataSourceMappersSpecs = {
+  "datasources inspect": {
+    usage: "Usage: remy-admin datasources inspect [--source <slug>] (--store <name> [--access <private|public>] [--prefix <p>] | --connector) [--keys k1,k2,...] [--limit <n>]",
+    flags: {
+      source: { type: "string" },
+      ...SELECTION_FLAGS,
+      limit: { type: "number", min: 1 }
+    },
+    requireAnyOf: {
+      flags: ["store", "connector"],
+      message: "Name the objects: --store <name> [--prefix <p>], or --connector for the source's bucket."
+    }
+  },
+  "datasources map test": {
+    usage: "Usage: remy-admin datasources map test [--source <slug>] (--store <name> [--access <private|public>] [--prefix <p>] | --connector) [--keys k1,k2,...] [--limit <n>] [--dev] [--full]",
+    flags: {
+      source: { type: "string" },
+      ...SELECTION_FLAGS,
+      limit: { type: "number", min: 1 },
+      dev: { type: "boolean" },
+      full: { type: "boolean" }
+    },
+    requireAnyOf: {
+      flags: ["store", "connector"],
+      message: "Name the objects: --store <name> [--prefix <p>], or --connector for the source's bucket."
+    }
+  },
+  "datasources remap": {
+    usage: "Usage: remy-admin datasources remap [--source <slug>] [--budget <dollars>] [--limit <n>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      budget: { type: "number", min: 0.01 },
+      limit: { type: "number", min: 1 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  },
+  "datasources jobs quarantine": {
+    usage: "Usage: remy-admin datasources jobs quarantine <id> [--kind skip|error] [--reason <text>] [--cursor <id>] [--limit <n>]",
+    positionals: [{ name: "id", required: true }],
+    flags: {
+      kind: { type: "string" },
+      reason: { type: "string" },
+      cursor: { type: "string" },
+      limit: { type: "number", min: 1 }
+    }
+  },
+  "datasources jobs replay": {
+    usage: "Usage: remy-admin datasources jobs replay <id> [--kind skip|error] [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: {
+      kind: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  }
+};
+function selectionOf(a) {
+  const store = a.str("store");
+  if (a.bool("connector") && store) {
+    fatal("Give --store or --connector, not both.");
+  }
+  if (a.bool("connector")) {
+    return { connector: true };
+  }
+  const access = a.str("access") ?? "private";
+  if (access !== "private" && access !== "public") {
+    fatal(`--access must be "private" or "public" (got "${access}").`);
+  }
+  return {
+    store,
+    access,
+    ...a.str("prefix") !== void 0 ? { prefix: a.str("prefix") } : {}
+  };
+}
+function keysOf(a) {
+  const raw = a.str("keys");
+  if (!raw) {
+    return void 0;
+  }
+  const keys = raw.split(",").map((k) => k.trim()).filter(Boolean);
+  if (keys.length === 0) {
+    fatal("--keys needs at least one key.");
+  }
+  return keys;
+}
+function kindOf(a) {
+  const kind = a.str("kind");
+  if (kind === void 0) {
+    return void 0;
+  }
+  if (kind !== "skip" && kind !== "error") {
+    fatal(`--kind must be "skip" or "error" (got "${kind}").`);
+  }
+  return kind;
+}
+async function inspect2(ctx, a) {
+  const slug = a.str("source");
+  const selection = selectionOf(a);
+  if ("connector" in selection && !slug) {
+    fatal("--connector needs --source: the bucket is the source's.");
+  }
+  const limit = a.num("limit");
+  const result = await inspect(ctx, {
+    ...slug ? { slug } : {},
+    selection,
+    ...keysOf(a) ? { keys: keysOf(a) } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  out({
+    ...slug ? { dataSource: slug } : {},
+    ...result,
+    note: result.report.truncated ? `Listed the first ${result.report.objects.toLocaleString()} objects; raise --limit to see more of the shape.` : `Listed every object (${result.report.objects.toLocaleString()}).`
+  });
+}
+async function mapTest2(ctx, a) {
+  const slug = sourceOf(a);
+  const limit = a.num("limit");
+  const result = await mapTest(ctx, {
+    slug,
+    selection: selectionOf(a),
+    ...keysOf(a) ? { keys: keysOf(a) } : {},
+    ...limit !== void 0 ? { limit } : {},
+    ...a.bool("dev") ? { dev: true } : {}
+  });
+  const results = a.bool("full") ? result.results : result.results.map(
+    (r) => r.outcome.kind === "documents" ? {
+      ...r,
+      outcome: {
+        ...r.outcome,
+        documents: r.outcome.documents.map((d) => ({
+          ...d,
+          preview: d.preview.slice(0, 200)
+        }))
+      }
+    } : r
   );
+  out({
+    dataSource: slug,
+    ...result,
+    results,
+    note: result.dev ? "Ran the LOCAL mapper through the dev session. Nothing was ingested; deploy to make it live." : "Ran the live release's mapper. Nothing was ingested."
+  });
+  if (result.counts.error > 0) {
+    throw new CliError(
+      `${result.counts.error} of ${result.objects} object(s) errored in the mapper.`,
+      EXIT.buildFailed
+    );
+  }
 }
-function drop(ctx, params) {
-  return call(
-    ctx,
-    "POST",
-    `${base(ctx.appId)}/versions/drop`,
-    {
-      slug: params.slug,
-      ...params.version !== void 0 ? { version: params.version } : {}
-    }
-  );
+async function remap2(ctx, a) {
+  const slug = sourceOf(a);
+  const budget = a.num("budget");
+  const limit = a.num("limit");
+  const { job, mapper } = await remap(ctx, {
+    slug,
+    ...budget !== void 0 ? { budgetDollars: budget } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: slug,
+      job,
+      mapper,
+      note: "Remapping from the raw copies. Poll `datasources jobs status <id>`, or re-run with --wait. Unchanged documents are skipped by hash; changed ones supersede their predecessors."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, "job", {
+    dataSource: slug,
+    action: "remap",
+    mapper
+  });
 }
-function rm(ctx, params) {
-  return call(
-    ctx,
-    "POST",
-    `${base(ctx.appId)}/documents/delete`,
-    {
-      slug: params.slug,
-      documentId: params.documentId
-    }
-  );
+async function quarantine2(ctx, a) {
+  const id = a.req("id");
+  const limit = a.num("limit");
+  const kind = kindOf(a);
+  const reason = a.str("reason");
+  const cursor = a.str("cursor");
+  const result = await quarantine(ctx, {
+    id,
+    ...kind ? { kind } : {},
+    ...reason ? { reason } : {},
+    ...cursor ? { cursor } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  out({
+    ...result,
+    note: result.counts.skipped + result.counts.errors === 0 ? "Nothing quarantined: the mapper produced documents (or deletions) for every object." : `Fix the mapper, deploy, then \`datasources jobs replay ${id}\` to run these through it again.`
+  });
 }
-function deleteSource(ctx, slug) {
-  return call(
-    ctx,
-    "POST",
-    `${base(ctx.appId)}/delete`,
-    { slug }
-  );
+async function replay2(ctx, a) {
+  const id = a.req("id");
+  const kind = kindOf(a);
+  const { job, mapper, dataSource } = await replay(ctx, {
+    id,
+    ...kind ? { kind } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: dataSource.slug,
+      fromJob: id,
+      job,
+      mapper,
+      note: "Replaying the quarantined objects through the current mapper. Poll `datasources jobs status <id>`, or re-run with --wait."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, "job", {
+    dataSource: dataSource.slug,
+    fromJob: id,
+    action: "replay",
+    mapper
+  });
 }
+var dataSourceMappersHandlers = {
+  "datasources inspect": inspect2,
+  "datasources map test": mapTest2,
+  "datasources remap": remap2,
+  "datasources jobs quarantine": quarantine2,
+  "datasources jobs replay": replay2
+};
+var dataSourceMappersHelp = `
+Mapping raw objects into documents (mappers):
+  remy-admin datasources inspect [--source <slug>] (--store <name> [--prefix <p>] | --connector) [--keys k1,k2] [--limit <n>]
+  remy-admin datasources map test [--source <slug>] (--store <name> [--prefix <p>] | --connector) [--keys k1,k2] [--limit <n>] [--dev] [--full]
+  remy-admin datasources remap [--source <slug>] [--budget <dollars>] [--limit <n>] [--wait] [--timeout <sec>]
+  remy-admin datasources jobs quarantine <id> [--kind skip|error] [--reason <text>] [--cursor <id>] [--limit <n>]
+  remy-admin datasources jobs replay <id> [--kind skip|error] [--wait] [--timeout <sec>]
+
+  A source takes every object it is given as one document. When the file is
+  not the document \u2014 JSON records that should become markdown plus metadata,
+  a JSONL object holding many articles, a kill notice that means "remove this
+  story" \u2014 the app declares a MAPPER for the source in mindstudio.json:
+    "dataSources": [{ "slug": "archive", "mapper": { "path": "dist/datasources/archive.mapper.ts" } }]
+  The file exports defineMapper(Archive, { map }) from @mindstudio-ai/agent.
+  map(object) reads the raw object (object.key, .bytes(), .text(), .json())
+  and answers documents([{ externalId, title, markdown, metadata?, replaces? }]),
+  passthrough() (ingest the raw object as-is), skip(reason) or
+  deletes([externalId, ...]); throwing is the object's error. It may call
+  models or fetch \u2014 every call is spend per object. Everything entering a
+  mapped source is mapped: jobs, syncs and Source.add() alike.
+
+  The loop: \`inspect\` profiles the objects (key shapes, extensions, sizes,
+  JSON key signatures of ten sampled heads) before a line is written;
+  \`map test --dev\` runs the LOCAL mapper through the running dev session
+  over real objects and prints every outcome without ingesting anything;
+  deploy; a job or sync runs the compiled mapper; \`jobs quarantine <id>\`
+  lists what it skipped or failed on, by reason; fix, deploy, \`jobs replay
+  <id>\` runs just those objects again; \`remap\` re-applies a changed mapper
+  to every raw copy the source holds \u2014 no origin traffic, unchanged markdown
+  skipped by hash, changed documents superseding their predecessors.
+
+  externalId is the identity the platform replaces by: a later object
+  producing the same id supersedes the earlier document; \`replaces\` names
+  ids this document supersedes (a writethru's original); deletes([...])
+  removes by id. A plan on a mapped source records the mapper's outcome mix
+  on its sample; a run whose skip share climbs past twice that (floor 5%)
+  pauses with pauseReason 'skips' for a look at the quarantine.
+`;
 
 // src/commands/dataSources.ts
-var DEFAULT_SOURCE = "default";
-var POLL_MS3 = 3e3;
 var INGEST_FLAGS = {
   chunking: { type: "string" },
   "max-chars": { type: "number", min: 200 },
@@ -3182,8 +4950,16 @@ var dataSourcesSpecs = {
     flags: { source: { type: "string" } }
   },
   "datasources rm": {
-    usage: "Usage: remy-admin datasources rm [--source <slug>] --document <id>",
-    flags: { source: { type: "string" }, document: { type: "string" } }
+    usage: "Usage: remy-admin datasources rm [--source <slug>] (--document <id> | --filter <k=v,...|json>)",
+    flags: {
+      source: { type: "string" },
+      document: { type: "string" },
+      filter: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["document", "filter"],
+      message: "Say what to remove: --document <id> for one document, or --filter <k=v,...|json> for every document that matches."
+    }
   },
   "datasources search": {
     usage: "Usage: remy-admin datasources search [--source <slug>] [--top-k <n>] [--mode <hybrid|semantic|lexical>] [--filter <k=v,...|json>] [--phrase <text>] [--contains <words>] [--max-per-document <n>] [--rerank <true|false>] [--hybrid <true|false>] [--highlight] [--candidate] <query>",
@@ -3216,11 +4992,24 @@ var dataSourcesSpecs = {
     flags: {
       source: { type: "string" },
       // Where the corpus lives: a dedicated resource id from `infra list`, or
-      // `shared`. Only changeable while the source has nothing built.
+      // `shared`. A populated source starts a background move (see `move`).
       placement: { type: "string" },
       ...CONFIG_FLAGS
     }
   },
+  "datasources move": {
+    usage: "Usage: remy-admin datasources move [--source <slug>] --to <resource-id|shared> [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      to: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["to"],
+      message: "--to is required: a resource id from `infra list`, or `shared`."
+    }
+  },
   "datasources revectorize": {
     usage: "Usage: remy-admin datasources revectorize [--source <slug>] [settings...] [--wait]",
     flags: {
@@ -3243,21 +5032,20 @@ var dataSourcesSpecs = {
     flags: { source: { type: "string" } }
   }
 };
-var sourceOf = (a) => a.str("source") || DEFAULT_SOURCE;
 async function dataSourcesAdd(ctx, a) {
   const files = a.rest("file");
   const slug = sourceOf(a);
   const metadata = parseKeyValuePairs(a.str("metadata"), "metadata");
   const results = [];
   for (const file of files) {
-    const abs = path3.isAbsolute(file) ? file : path3.join(WORKSPACE_DIR, file);
+    const abs = path5.isAbsolute(file) ? file : path5.join(WORKSPACE_DIR, file);
     let bytes;
     try {
-      bytes = fs3.readFileSync(abs);
+      bytes = fs5.readFileSync(abs);
     } catch (err) {
       fatal(`Could not read file "${file}": ${err.message}`);
     }
-    const filename = path3.basename(file);
+    const filename = path5.basename(file);
     results.push(
       await addDocument(ctx, {
         slug,
@@ -3273,32 +5061,24 @@ async function dataSourcesAdd(ctx, a) {
     const timeoutMs = timeoutSec ? timeoutSec * 1e3 : DEFAULT_WAIT_TIMEOUT_MS;
     const result = await waitForIngest(ctx, {
       slug,
-      documentIds: results.filter((r) => !r.skipped).map((r) => r.document.id),
+      // Every document the files became: a mapped source can make several
+      // from one file, or none (a deletes outcome).
+      documentIds: results.filter((r) => !r.skipped).flatMap((r) => r.documents.map((d) => d.id)),
       timeoutMs,
       onProgress: progress
     });
-    if (result.status === "timeout") {
-      out({
-        dataSource: slug,
-        status: result.status,
-        error: result.error,
-        documents: result.documents
-      });
-      process.exit(EXIT.timeout);
-    }
-    if (result.status === "error") {
-      out({
-        dataSource: slug,
-        status: result.status,
-        documents: result.documents
-      });
-      process.exit(EXIT.buildFailed);
-    }
     out({
       dataSource: slug,
       status: result.status,
+      ...result.error ? { error: result.error } : {},
       documents: result.documents
     });
+    if (result.status === "timeout") {
+      throw new CliError(result.error ?? "Timed out.", EXIT.timeout);
+    }
+    if (result.status === "error") {
+      throw new CliError("At least one document failed.", EXIT.buildFailed);
+    }
     return;
   }
   out({ dataSource: slug, documents: results });
@@ -3316,11 +5096,32 @@ async function dataSourcesStatus(ctx, a) {
 }
 async function dataSourcesRm(ctx, a) {
   const documentId = a.str("document");
-  if (!documentId) {
-    fatal("--document is required.");
+  const rawFilter = a.str("filter");
+  if (documentId && rawFilter) {
+    fatal("Give --document or --filter, not both.");
+  }
+  if (documentId) {
+    await rm(ctx, { slug: sourceOf(a), documentId });
+    out({ deleted: documentId });
+    return;
+  }
+  let filter;
+  if (rawFilter.trimStart().startsWith("{")) {
+    try {
+      filter = JSON.parse(rawFilter);
+    } catch (err) {
+      fatal(`--filter is not valid JSON: ${err.message}`);
+    }
+  } else {
+    filter = { metadata: parseKeyValuePairs(rawFilter, "filter") };
   }
-  await rm(ctx, { slug: sourceOf(a), documentId });
-  out({ deleted: documentId });
+  const slug = sourceOf(a);
+  const result = await rmWhereAll(ctx, {
+    slug,
+    filter,
+    onProgress: progress
+  });
+  out({ dataSource: slug, filter, ...result });
 }
 async function dataSourcesDelete(ctx, a) {
   const slug = a.str("source");
@@ -3335,8 +5136,8 @@ async function dataSourcesDelete(ctx, a) {
 async function dataSourcesSearch(ctx, a) {
   const topK = a.num("top-k");
   const retrieval = {
-    ...triState(a, "rerank", "rerank"),
-    ...triState(a, "hybrid", "hybrid")
+    ...triState2(a, "rerank", "rerank"),
+    ...triState2(a, "hybrid", "hybrid")
   };
   const mode = a.str("mode");
   if (mode && !["hybrid", "semantic", "lexical"].includes(mode)) {
@@ -3408,7 +5209,7 @@ function parseKeyValuePairs(raw, flag) {
   }
   return pairs2;
 }
-function triState(a, flag, key) {
+function triState2(a, flag, key) {
   const raw = a.str(flag);
   if (raw === void 0) {
     return {};
@@ -3440,11 +5241,11 @@ function configFromFlags(a) {
     chunking.dropBlockTypes = dropBlocks.split(",").map((s) => s.trim()).filter(Boolean);
   }
   const contextual = {
-    ...triState(a, "contextual", "enabled"),
+    ...triState2(a, "contextual", "enabled"),
     ...a.str("contextual-model") ? { modelId: a.str("contextual-model") } : {}
   };
   const images = {
-    ...triState(a, "describe-images", "describe"),
+    ...triState2(a, "describe-images", "describe"),
     ...a.str("image-model") ? { modelId: a.str("image-model") } : {}
   };
   const embeddingModel = a.str("embedding-model");
@@ -3470,10 +5271,10 @@ function configFromFlags(a) {
     ingest.extraction = { modelId: extractionModel };
   }
   const retrieval = {
-    ...triState(a, "hybrid", "hybrid")
+    ...triState2(a, "hybrid", "hybrid")
   };
   const rerank = {
-    ...triState(a, "rerank", "enabled"),
+    ...triState2(a, "rerank", "enabled"),
     ...a.str("rerank-model") ? { modelId: a.str("rerank-model") } : {}
   };
   if (Object.keys(rerank).length) {
@@ -3491,6 +5292,7 @@ var placementOf = (a) => {
   const flag = a.str("placement");
   return flag === void 0 ? void 0 : flag === "shared" ? "shared" : { resourceId: flag };
 };
+var MOVE_NOTE = "Moving in the background; `datasources list` shows progress, or re-run with `datasources move --wait`.";
 async function dataSourcesCreate(ctx, a) {
   const slug = a.str("source");
   if (!slug) {
@@ -3499,13 +5301,14 @@ async function dataSourcesCreate(ctx, a) {
   const { ingest } = configFromFlags(a);
   const name = a.str("name");
   const placement = placementOf(a);
+  const result = await create2(ctx, {
+    slug,
+    ...name ? { name } : {},
+    ...ingest ? { ingest } : {},
+    ...placement !== void 0 ? { placement } : {}
+  });
   out(
-    await create2(ctx, {
-      slug,
-      ...name ? { name } : {},
-      ...ingest ? { ingest } : {},
-      ...placement !== void 0 ? { placement } : {}
-    })
+    result.migration && !result.migration.error ? { ...result, note: MOVE_NOTE } : result
   );
 }
 async function dataSourcesConfig(ctx, a) {
@@ -3516,15 +5319,49 @@ async function dataSourcesConfig(ctx, a) {
     out(await configGet(ctx, slug));
     return;
   }
+  const result = await configSet(ctx, {
+    slug,
+    ...ingest ? { ingest } : {},
+    ...retrieval ? { retrieval } : {},
+    ...placement !== void 0 ? { placement } : {}
+  });
   out(
-    await configSet(ctx, {
-      slug,
-      ...ingest ? { ingest } : {},
-      ...retrieval ? { retrieval } : {},
-      ...placement !== void 0 ? { placement } : {}
-    })
+    result.placementChanged && result.migration && !result.migration.error ? { ...result, note: MOVE_NOTE } : result
   );
 }
+async function dataSourcesMove(ctx, a) {
+  const slug = sourceOf(a);
+  const to = a.str("to");
+  const placement = to === "shared" ? "shared" : { resourceId: to };
+  const started = await move(ctx, { slug, placement });
+  if (!started.migration || !a.bool("wait")) {
+    out({
+      dataSource: slug,
+      ...started,
+      ...started.migration ? { note: MOVE_NOTE } : {}
+    });
+    return;
+  }
+  const timeoutSec = a.num("timeout");
+  const result = await waitForMove(ctx, {
+    slug,
+    ...timeoutSec ? { timeoutMs: timeoutSec * 1e3 } : {},
+    onProgress: progress
+  });
+  out({
+    dataSource: slug,
+    status: result.status,
+    placement: result.source.placement,
+    migration: result.source.migration,
+    ..."error" in result ? { error: result.error } : {}
+  });
+  if (result.status === "failed") {
+    throw new CliError(result.error, EXIT.buildFailed);
+  }
+  if (result.status === "timeout") {
+    throw new CliError(result.error, EXIT.timeout);
+  }
+}
 async function dataSourcesRevectorize(ctx, a) {
   const slug = sourceOf(a);
   const { ingest } = configFromFlags(a);
@@ -3537,42 +5374,24 @@ async function dataSourcesRevectorize(ctx, a) {
     return;
   }
   const timeoutSec = a.num("timeout");
-  const timeoutMs = timeoutSec ? timeoutSec * 1e3 : DEFAULT_WAIT_TIMEOUT_MS;
-  const start = Date.now();
-  for (; ; ) {
-    const documents2 = await allDocuments(ctx, {
-      slug,
-      candidate: true
-    });
-    const pending = documents2.filter((d) => d.status === "processing");
-    const failed = documents2.filter((d) => d.status === "error");
-    if (pending.length === 0) {
-      out({
-        dataSource: slug,
-        candidateVersion: started.candidateVersion,
-        status: failed.length ? "error" : "ready",
-        documents: (documents2 ?? []).map(summarize),
-        note: failed.length ? "Some documents failed. Promote with --force to accept, or fix and re-run." : "Run `promote` to make this version live."
-      });
-      if (failed.length) {
-        process.exit(EXIT.buildFailed);
-      }
-      return;
-    }
-    if (Date.now() - start > timeoutMs) {
-      out({
-        dataSource: slug,
-        status: "timeout",
-        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s with ${pending.length} document(s) still building`
-      });
-      process.exit(EXIT.timeout);
-    }
-    progress(
-      `rebuilding\u2026 ${documents2.length - pending.length}/${documents2.length} done (${Math.round(
-        (Date.now() - start) / 1e3
-      )}s)`
-    );
-    await sleep(POLL_MS3);
+  const result = await waitForCandidate(ctx, {
+    slug,
+    ...timeoutSec ? { timeoutMs: timeoutSec * 1e3 } : {},
+    onProgress: progress
+  });
+  if (result.status === "timeout") {
+    out({ dataSource: slug, status: "timeout", error: result.error });
+    throw new CliError(result.error ?? "Timed out.", EXIT.timeout);
+  }
+  out({
+    dataSource: slug,
+    candidateVersion: started.candidateVersion,
+    status: result.status,
+    documents: result.documents,
+    note: result.status === "error" ? "Some documents failed. Promote with --force to accept, or fix and re-run." : "Run `promote` to make this version live."
+  });
+  if (result.status === "error") {
+    throw new CliError("At least one document failed.", EXIT.buildFailed);
   }
 }
 async function dataSourcesPromote(ctx, a) {
@@ -3600,6 +5419,7 @@ var dataSourcesHandlers = {
   "datasources search": dataSourcesSearch,
   "datasources create": dataSourcesCreate,
   "datasources config": dataSourcesConfig,
+  "datasources move": dataSourcesMove,
   "datasources revectorize": dataSourcesRevectorize,
   "datasources promote": dataSourcesPromote,
   "datasources drop": dataSourcesDrop,
@@ -3614,10 +5434,22 @@ Subcommands:
   add          Add one or more documents (skips unchanged files)
   list         List data sources with document counts
   status       Show per-document ingest state
-  rm           Remove a document and its vectors
+  rm           Remove a document, or every document matching a filter
   search       Query a corpus \u2014 useful to sanity-check one you just built
   create       Create an empty source, optionally on dedicated capacity
   config       Show or change how a corpus is processed and searched
+  move         Move a corpus between shared and dedicated capacity, data intact
+  jobs         Bulk-load a corpus from a file store or a manifest, with a plan first
+  connect      Follow an S3 bucket the customer owns (credentials = app secret names)
+  sync         Bring a connected source up to date with its bucket
+  connector    Show a source's connector and what it tracks
+  disconnect   Stop following the bucket; documents stay
+  inspect      Profile raw objects (key shapes, types, sizes, JSON keys) before writing a mapper
+  map test     Run a source's mapper over real objects and show the outcomes; nothing ingested
+  remap        Re-apply the live mapper to every raw copy the source holds
+  hydrate      Reload an evicted index ahead of the first search
+  sample       Draw a sample of a source into a new one with the same config
+  eval         Query sets and runs: measure recall, MRR and latency, compare versions
   revectorize  Rebuild a corpus under new settings, alongside the live one
   promote      Make a rebuilt version live
   drop         Discard a candidate or a superseded version
@@ -3627,10 +5459,15 @@ Usage:
   remy-admin datasources add [--source <slug>] [--metadata <k=v,...>] [--wait] [--timeout <sec>] <file...>
   remy-admin datasources list
   remy-admin datasources status [--source <slug>]
-  remy-admin datasources rm [--source <slug>] --document <id>
+  remy-admin datasources rm [--source <slug>] (--document <id> | --filter <k=v,...|json>)
   remy-admin datasources search [--source <slug>] [search options] <query>
   remy-admin datasources create --source <slug> [--name <name>] [--placement <resource-id|shared>] [rebuild settings...]
   remy-admin datasources config [--source <slug>] [--placement <resource-id|shared>] [settings...]
+  remy-admin datasources move [--source <slug>] --to <resource-id|shared> [--wait] [--timeout <sec>]
+  remy-admin datasources jobs start|list|status|approve|pause|resume|cancel \u2026 (see below)
+  remy-admin datasources connect|sync|connector|disconnect \u2026 (see below)
+  remy-admin datasources hydrate|sample \u2026 (see below)
+  remy-admin datasources eval create|list|get|add|import|queries|rm|delete|run|runs|result|compare \u2026 (see below)
   remy-admin datasources revectorize [--source <slug>] [settings...] [--wait]
   remy-admin datasources promote [--source <slug>] [--force]
   remy-admin datasources drop [--source <slug>] [--version <n>]
@@ -3701,16 +5538,33 @@ Tuning a corpus:
                              capacity needs, roughly in proportion.
     --extraction-model <id>
 
-Notes:
+Placement (shared pool vs dedicated capacity, see \`infra --help\`):
   --source defaults to "${DEFAULT_SOURCE}" and is created on first use, on the
-    shared pool. A corpus meant for dedicated capacity (\`infra provision\`)
-    starts with \`create --placement <resource-id>\`, since a source with built
-    documents cannot move; \`config --placement\` moves one that is still empty.
+    shared pool. Start a corpus on a resource with \`create --placement\`, or
+    move one at any time with \`move --to <resource-id|shared>\`.
+  A move copies the corpus's stored vectors onto the new capacity in the
+    background: no re-extraction, no re-embedding, no charge beyond the
+    resource itself. Search keeps working from the old placement until the
+    copy lands; add, rm, config, revectorize and delete are refused with
+    data_source_migrating until then. \`datasources list\` shows progress;
+    \`move --wait\` blocks on it (exits ${EXIT.buildFailed} if the move failed,
+    ${EXIT.timeout} on timeout). Moving to \`shared\` is how a source leaves a
+    resource you mean to destroy.
+  A move is refused while documents are still building or a candidate version
+    exists (data_source_busy), when the target is not active
+    (capacity_<phase>), or when it would not fit (capacity_exceeded).
+
+Notes:
   --wait blocks until processing finishes, so you can search immediately after.
     Exits ${EXIT.buildFailed} if a document failed, ${EXIT.timeout} on timeout.
   Re-adding an unchanged file is free: no upload, no re-embedding. Re-adding
     with a different --metadata updates the tags in place, also free.
   --metadata tags documents for search-time filtering (scalars, \u226416 keys).
+  rm --filter removes every matching document in pages of a thousand: k=v
+    pairs match metadata; a JSON object takes the full selector \u2014 metadata,
+    filename, documentIds, externalIdPrefix (the key a job or connector
+    recorded, e.g. '{"externalIdPrefix":"archive/2019/"}'). An empty filter
+    is refused; to remove everything, delete the source.
   delete requires an explicit --source (no default) and refuses while documents
     are still ingesting. Extraction caches survive deletion, so re-ingesting
     the same files elsewhere costs no re-extraction.
@@ -3728,7 +5582,24 @@ Examples:
   remy-admin datasources revectorize --source policies --max-chars 900 --wait
   remy-admin datasources search --source policies --candidate "payment terms"
   remy-admin datasources promote --source policies
-`;
+
+  # Load a whole corpus: plan first, approve, watch it run
+  remy-admin datasources jobs start --source archive --store raw --prefix 2024/ --wait
+  remy-admin datasources jobs approve <id> --wait
+
+  # Follow a customer's bucket: secrets by name, first sync stops for approval
+  remy-admin secrets set ARCHIVE_S3_KEY --prod <value>      # never on a command line you share
+  remy-admin datasources connect --source archive --bucket acme-docs --region us-east-1 --prefix contracts/ --access-key-secret ARCHIVE_S3_KEY --secret-key-secret ARCHIVE_S3_SECRET --budget-per-sync 5
+  remy-admin datasources sync --source archive --wait
+
+  # Measure before you promote: sample, build a query set, run live vs candidate
+  remy-admin datasources sample --source archive --size 300 --wait
+  remy-admin datasources eval create --source archive-sample --name base --size 150 --wait
+  remy-admin datasources eval run --set <setId> --label live --wait
+  remy-admin datasources revectorize --source archive-sample --max-chars 900 --wait
+  remy-admin datasources eval run --set <setId> --candidate --label small-chunks --wait
+  remy-admin datasources eval compare <runA> <runB>
+${dataSourceJobsHelp}${dataSourceConnectorsHelp}${dataSourceMappersHelp}${dataSourceEvalsHelp}`;
 
 // src/ops/voice.ts
 function normalizeE164(input) {
@@ -4303,7 +6174,7 @@ function runs(ctx, params = {}) {
     `/_internal/v2/apps/${ctx.appId}/jewels/training-runs${qs(params)}`
   );
 }
-function getRun(ctx, runId) {
+function getRun2(ctx, runId) {
   return call(
     ctx,
     "GET",
@@ -4463,9 +6334,9 @@ async function jewelsTimeseries(ctx, a) {
   );
 }
 async function jewelsResolve(ctx, a) {
-  const approve = a.bool("approve");
+  const approve2 = a.bool("approve");
   const dismiss = a.bool("dismiss");
-  if (approve === dismiss) {
+  if (approve2 === dismiss) {
     fatal("Pass exactly one of --approve or --dismiss.");
   }
   if (dismiss && a.str("input") !== void 0) {
@@ -4473,7 +6344,7 @@ async function jewelsResolve(ctx, a) {
   }
   const params = {
     itemId: a.req("itemId"),
-    action: approve ? "approve" : "dismiss"
+    action: approve2 ? "approve" : "dismiss"
   };
   if (a.str("input") !== void 0) {
     params.input = parseJsonFlag(a, "input");
@@ -4521,28 +6392,28 @@ async function jewelsTrain(ctx, a) {
   let lastLogLen = 0;
   while (Date.now() < deadline) {
     await sleep(TRAIN_POLL_MS);
-    const { run: run2 } = await getRun(ctx, runId);
-    const log = Array.isArray(run2.log) ? run2.log : [];
+    const { run: run3 } = await getRun2(ctx, runId);
+    const log = Array.isArray(run3.log) ? run3.log : [];
     const fresh = log.slice(lastLogLen);
     lastLogLen = log.length;
     const isStatus = (x) => x?.kind === "status";
     const isLoss = (x) => x?.kind === "loss";
     for (const e of fresh.filter(isStatus)) {
-      out({ status: run2.status, at: e.ts, message: e.message });
+      out({ status: run3.status, at: e.ts, message: e.message });
     }
     const losses = fresh.filter(isLoss);
     if (losses.length) {
       const last = losses[losses.length - 1];
-      const p = run2.progress;
+      const p = run3.progress;
       out({
-        status: run2.status,
+        status: run3.status,
         step: `${last.step}/${p?.totalSteps ?? "?"}`,
         loss: last.loss
       });
     }
-    if (run2.status === "complete" || run2.status === "failed") {
-      out(compactRunLog(run2));
-      if (run2.status === "failed") {
+    if (run3.status === "complete" || run3.status === "failed") {
+      out(compactRunLog(run3));
+      if (run3.status === "failed") {
         process.exitCode = 1;
       }
       return;
@@ -4552,19 +6423,19 @@ async function jewelsTrain(ctx, a) {
     `Timed out waiting for run ${runId} (still in flight; check 'jewels run ${runId}').`
   );
 }
-function compactRunLog(run2) {
-  let out2 = { ...run2 };
-  if (Array.isArray(run2.log)) {
-    const statusEntries = run2.log.filter((e) => e?.kind === "status");
-    const lossPoints = run2.log.length - statusEntries.length;
+function compactRunLog(run3) {
+  let out2 = { ...run3 };
+  if (Array.isArray(run3.log)) {
+    const statusEntries = run3.log.filter((e) => e?.kind === "status");
+    const lossPoints = run3.log.length - statusEntries.length;
     out2 = { ...out2, log: { statusEntries, lossPoints } };
   }
-  if (Array.isArray(run2.report?.candidates)) {
+  if (Array.isArray(run3.report?.candidates)) {
     out2 = {
       ...out2,
       report: {
-        ...run2.report,
-        candidates: run2.report.candidates.map(
+        ...run3.report,
+        candidates: run3.report.candidates.map(
           (c) => Array.isArray(c?.predictions) ? { ...c, predictions: c.predictions.length } : c
         )
       }
@@ -4581,8 +6452,8 @@ async function jewelsRuns(ctx, a) {
   );
 }
 async function jewelsRunGet(ctx, a) {
-  const { run: run2 } = await getRun(ctx, a.req("runId"));
-  out({ run: compactRunLog(run2) });
+  const { run: run3 } = await getRun2(ctx, a.req("runId"));
+  out({ run: compactRunLog(run3) });
 }
 async function jewelsGrade(ctx, a) {
   out(await grade(ctx, a.req("runId")));
@@ -5029,14 +6900,14 @@ async function resolveDomainId(ctx, direction, domain) {
   }
   return match.id;
 }
-function list9(ctx, params = {}) {
+function list10(ctx, params = {}) {
   return call(
     ctx,
     "GET",
     `/_internal/v2/apps/${ctx.appId}/outbound-email/messages${qs(params)}`
   );
 }
-function get7(ctx, messageId) {
+function get9(ctx, messageId) {
   return call(
     ctx,
     "GET",
@@ -5228,7 +7099,7 @@ var emailSpecs = {
 };
 async function emailList(ctx, a) {
   out(
-    await list9(ctx, {
+    await list10(ctx, {
       status: a.str("status"),
       kind: a.str("kind"),
       recipient: a.str("recipient"),
@@ -5242,7 +7113,7 @@ async function emailList(ctx, a) {
   );
 }
 async function emailGet(ctx, a) {
-  out(await get7(ctx, a.req("messageId")));
+  out(await get9(ctx, a.req("messageId")));
 }
 async function emailStats(ctx, a) {
   out(await stats2(ctx, { start: a.str("start"), end: a.str("end") }));
@@ -5418,14 +7289,14 @@ Examples:
 `;
 
 // src/ops/cron.ts
-function list10(ctx, params = {}) {
+function list11(ctx, params = {}) {
   return call(
     ctx,
     "GET",
     `/_internal/v2/apps/${ctx.appId}/cron/overview${qs(params)}`
   );
 }
-function run(ctx, route) {
+function run2(ctx, route) {
   return call(
     ctx,
     "POST",
@@ -5447,10 +7318,10 @@ var cronSpecs = {
   }
 };
 async function cronList(ctx, a) {
-  out(await list10(ctx, { runs: a.num("runs") }));
+  out(await list11(ctx, { runs: a.num("runs") }));
 }
 async function cronRun(ctx, a) {
-  out(await run(ctx, a.req("route")));
+  out(await run2(ctx, a.req("route")));
 }
 var cronHandlers = {
   "cron list": cronList,
@@ -5481,27 +7352,27 @@ Examples:
   remy-admin cron run dailyDigest`;
 
 // src/ops/infra.ts
-var DEFAULT_WAIT_TIMEOUT_MS2 = 10 * 60 * 1e3;
-var POLL_MS4 = 3e3;
-function base2(appId) {
+var DEFAULT_WAIT_TIMEOUT_MS4 = 10 * 60 * 1e3;
+var POLL_MS5 = 3e3;
+function base6(appId) {
   return `/_internal/v2/apps/${appId}/infra`;
 }
-function list11(ctx, params) {
+function list12(ctx, params) {
   return call(
     ctx,
     "GET",
-    `${base2(ctx.appId)}${params?.includeDestroyed ? "?includeDestroyed=true" : ""}`
+    `${base6(ctx.appId)}${params?.includeDestroyed ? "?includeDestroyed=true" : ""}`
   );
 }
-function get8(ctx, params) {
+function get10(ctx, params) {
   return call(
     ctx,
     "GET",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}`
   );
 }
 function provision(ctx, params) {
-  return call(ctx, "POST", base2(ctx.appId), {
+  return call(ctx, "POST", base6(ctx.appId), {
     offeringId: params.offeringId,
     ...params.name ? { name: params.name } : {}
   });
@@ -5510,77 +7381,69 @@ function hibernate(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/hibernate`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/hibernate`
   );
 }
-function resume(ctx, params) {
+function resume2(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/resume`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/resume`
   );
 }
 function destroy(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/destroy`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/destroy`
+  );
+}
+function resize(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/resize`,
+    { offeringId: params.offeringId }
   );
 }
 function rename(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/rename`,
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/rename`,
     { name: params.name }
   );
 }
 async function waitForPhase(ctx, params) {
-  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS2;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS4;
   const wanted = new Set(params.phases);
-  const start = Date.now();
-  let transientSince = null;
-  for (; ; ) {
-    let resource;
-    try {
-      ({ resource } = await get8(ctx, { id: params.id }));
-      transientSince = null;
-    } catch (err) {
-      if (!isTransientError(err)) {
-        throw err;
-      }
-      transientSince ??= Date.now();
-      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
-        throw err;
-      }
-      params.onProgress?.(
-        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
-      );
-      await sleep(POLL_MS4);
-      continue;
-    }
-    if (wanted.has(resource.phase)) {
-      return { status: "done", resource };
-    }
-    if (resource.phase === "failed") {
-      return {
-        status: "failed",
-        resource,
-        error: resource.lastError ?? "The platform could not complete the change."
-      };
-    }
-    if (Date.now() - start > timeoutMs) {
-      return {
-        status: "timeout",
-        resource,
-        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s; resource is still ${resource.phase}`
-      };
+  const arrived = (resource2) => wanted.has(resource2.phase) && (params.until?.(resource2) ?? true);
+  const outcome = await pollUntil(
+    async () => (await get10(ctx, { id: params.id })).resource,
+    (resource2) => arrived(resource2) || resource2.phase === "failed",
+    {
+      timeoutMs,
+      pollMs: POLL_MS5,
+      describe: (resource2, start2) => `${resource2.phase}${resource2.detail ? ` \xB7 ${resource2.detail}` : ""}${resource2.resizingTo ? ` \xB7 resizing to ${resource2.resizingTo.label}` : ""}\u2026 (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
     }
-    params.onProgress?.(
-      `${resource.phase}${resource.detail ? ` \xB7 ${resource.detail}` : ""}\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
-    );
-    await sleep(POLL_MS4);
+  );
+  const resource = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      resource,
+      error: timedOut(timeoutMs, `; resource is still ${resource.phase}`)
+    };
   }
+  if (arrived(resource)) {
+    return { status: "done", resource };
+  }
+  return {
+    status: "failed",
+    resource,
+    error: resource.lastError ?? "The platform could not complete the change."
+  };
 }
 
 // src/commands/infra.ts
@@ -5626,13 +7489,27 @@ var infraSpecs = {
     positionals: [{ name: "id", required: true }],
     flags: { name: { type: "string" } },
     requireAnyOf: { flags: ["name"], message: "--name is required." }
+  },
+  "infra resize": {
+    usage: "Usage: remy-admin infra resize <id> --offering <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: {
+      offering: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["offering"],
+      message: "--offering is required (see `infra list` for the sizes)."
+    }
   }
 };
-async function waitAndReport(ctx, a, id, phases, summary2) {
+async function waitAndReport2(ctx, a, id, phases, summary2, until) {
   const timeoutSec = a.str("timeout");
   const result = await waitForPhase(ctx, {
     id,
     phases,
+    ...until ? { until } : {},
     ...timeoutSec ? { timeoutMs: Number(timeoutSec) * 1e3 } : {},
     onProgress: progress
   });
@@ -5645,10 +7522,22 @@ async function waitAndReport(ctx, a, id, phases, summary2) {
   }
 }
 async function infraList(ctx, a) {
-  out(await list11(ctx, { includeDestroyed: a.bool("include-destroyed") }));
+  out(await list12(ctx, { includeDestroyed: a.bool("include-destroyed") }));
 }
 async function infraGet(ctx, a) {
-  out(await get8(ctx, { id: a.req("id") }));
+  out(await get10(ctx, { id: a.req("id") }));
+}
+function pricingOf(resource) {
+  const offering = resource.offering;
+  if (!offering) {
+    return null;
+  }
+  return {
+    offering: offering.id,
+    activeMonthlyDollars: offering.monthlyPriceDollars,
+    hibernatedMonthlyDollars: offering.hibernatedMonthlyPriceDollars,
+    note: "Bills hourly from activation. A month's credits were verified before the lease was accepted."
+  };
 }
 async function infraProvision(ctx, a) {
   const offeringId = a.str("offering");
@@ -5657,14 +7546,19 @@ async function infraProvision(ctx, a) {
     offeringId,
     ...name ? { name } : {}
   });
+  const pricing = pricingOf(resource);
   if (!a.bool("wait")) {
     out({
       resource,
+      pricing,
       note: "Provisioning; poll `infra get <id>` or re-run with --wait."
     });
     return;
   }
-  await waitAndReport(ctx, a, resource.id, ["active"], { action: "provision" });
+  await waitAndReport2(ctx, a, resource.id, ["active"], {
+    action: "provision",
+    pricing
+  });
 }
 async function infraHibernate(ctx, a) {
   const id = a.req("id");
@@ -5673,16 +7567,16 @@ async function infraHibernate(ctx, a) {
     out({ resource });
     return;
   }
-  await waitAndReport(ctx, a, id, ["hibernated"], { action: "hibernate" });
+  await waitAndReport2(ctx, a, id, ["hibernated"], { action: "hibernate" });
 }
 async function infraResume(ctx, a) {
   const id = a.req("id");
-  const { resource } = await resume(ctx, { id });
+  const { resource } = await resume2(ctx, { id });
   if (!a.bool("wait")) {
     out({ resource });
     return;
   }
-  await waitAndReport(ctx, a, id, ["active"], { action: "resume" });
+  await waitAndReport2(ctx, a, id, ["active"], { action: "resume" });
 }
 async function infraDestroy(ctx, a) {
   const id = a.req("id");
@@ -5691,7 +7585,7 @@ async function infraDestroy(ctx, a) {
     out({ resource });
     return;
   }
-  await waitAndReport(ctx, a, id, ["destroyed"], { action: "destroy" });
+  await waitAndReport2(ctx, a, id, ["destroyed"], { action: "destroy" });
 }
 async function infraRename(ctx, a) {
   out(
@@ -5701,6 +7595,33 @@ async function infraRename(ctx, a) {
     })
   );
 }
+async function infraResize(ctx, a) {
+  const id = a.req("id");
+  const { resource } = await resize(ctx, {
+    id,
+    offeringId: a.str("offering")
+  });
+  const pricing = pricingOf({
+    ...resource,
+    offering: resource.resizingTo ?? resource.offering
+  });
+  if (!a.bool("wait")) {
+    out({
+      resource,
+      pricing,
+      note: "Resizing; searches on its sources pause while it is parked and restored. Poll `infra get <id>` or re-run with --wait."
+    });
+    return;
+  }
+  await waitAndReport2(
+    ctx,
+    a,
+    id,
+    [resource.phase],
+    { action: "resize", pricing },
+    (r) => r.resizingTo === null
+  );
+}
 var infraHandlers = {
   "infra list": infraList,
   "infra get": infraGet,
@@ -5708,7 +7629,8 @@ var infraHandlers = {
   "infra hibernate": infraHibernate,
   "infra resume": infraResume,
   "infra destroy": infraDestroy,
-  "infra rename": infraRename
+  "infra rename": infraRename,
+  "infra resize": infraResize
 };
 var infraHelp = `remy-admin infra \u2014 Dedicated infrastructure your app leases from the platform.
 
@@ -5717,16 +7639,18 @@ for data sources, isolated from the shared pool. Sizes and prices come from the
 platform catalog (\`infra list\` prints them); nothing is priced client-side.
 
 A resource bills by the hour from activation, at the retained-storage rate while
-hibernated, and not at all once destroyed. Provisioning needs a month's worth of
-credits available in the workspace; nothing is charged until activation. Every
-action below is audited.
+hibernated, and not at all once destroyed. Provisioning (and growing) needs a
+month's worth of credits available in the workspace, checked before the request
+is accepted; nothing is charged until activation. The provision output prints
+the price it committed to. Every action below is audited.
 
 Subcommands:
   list        Resources on this app, plus the offerings you can provision
   get         One resource with its state timeline and attached sources
-  provision   Lease a new resource (spends credits)
+  provision   Lease a new resource (needs a month's credits; prints the price)
   hibernate   Park it: data kept, searches paused, compute charge stops
   resume      Bring a hibernated resource back
+  resize      Change its size, data intact (passes through hibernated)
   destroy     Delete it (refused while data sources are placed on it)
   rename      Change the display name
 
@@ -5736,26 +7660,44 @@ Usage:
   remy-admin infra provision --offering <id> [--name <name>] [--wait] [--timeout <sec>]
   remy-admin infra hibernate <id> [--wait] [--timeout <sec>]
   remy-admin infra resume <id> [--wait] [--timeout <sec>]
+  remy-admin infra resize <id> --offering <id> [--wait] [--timeout <sec>]
   remy-admin infra destroy <id> [--wait] [--timeout <sec>]
   remy-admin infra rename <id> --name <name>
 
 Placing a data source on a resource:
   remy-admin datasources create --source <slug> --placement <resource-id>
-  remy-admin datasources config --source <slug> --placement <resource-id>
-  remy-admin datasources config --source <slug> --placement shared
+  remy-admin datasources move --source <slug> --to <resource-id|shared> [--wait]
 
   Start a new corpus on a resource with \`create\`; \`add\` creates a source on
-  the shared pool. Placement can only change while the source has no built
-  documents; moving a populated source is a re-vectorization onto the new
-  capacity, which is not available yet. Searches on a source whose resource is
-  not active fail with capacity_<phase>: capacity_hibernated once parked,
-  capacity_hibernating / capacity_resuming while it moves, and
-  capacity_restoring while a resumed instance reloads its data.
-
-Phases:
+  the shared pool. A populated source moves with \`datasources move\`: its
+  stored vectors are copied onto the new capacity in the background (no
+  re-embedding), search keeps working from the old placement until the copy
+  lands, and adding or removing documents is refused with
+  data_source_migrating until it finishes. Moving to \`shared\` is how a source
+  leaves a resource you mean to destroy. See \`datasources --help\`.
+
+  Searches on a source whose resource is not active fail with
+  capacity_<phase>: capacity_hibernated once parked, capacity_hibernating /
+  capacity_resuming while it moves. \`active\` means searchable: a resumed
+  resource reports active only once its data is restored. capacity_restoring
+  is the rare case of an active instance that was replaced (node loss) and is
+  refilling from its snapshot. The messages are written for the app's end
+  user; the stable code is what to act on.
+
+Resizing:
+  A resize keeps the data. The resource is parked (a fresh snapshot), its spec
+  is swapped, and it comes back up restored from that snapshot, so searches on
+  its sources pause for the few minutes it takes. A hibernated resource swaps
+  in place and stays parked. Growing needs a month's credits at the new rate;
+  shrinking is refused below what the resource holds (resize_too_small).
+  \`infra get\` shows resizingTo until the swap has happened.
+
+Phases and timing:
   requested \u2192 provisioning \u2192 active \u21C4 hibernated \u2192 destroyed, with hibernating /
   resuming / decommissioning in between and failed when a change cannot complete
-  (retried automatically; resume or hibernate to retry by hand).
+  (retried automatically; resume or hibernate to retry by hand). Each transition
+  takes about two minutes, more with more data: snapshots and restores scale
+  with the collection. --wait defaults to 600s; pass --timeout for a large one.
 
 --wait exit codes: 0 reached the target phase \xB7 1 the platform reported failure \xB7
 2 still transitioning when --timeout elapsed (default 600s).`;
@@ -5777,6 +7719,10 @@ var SPECS = {
   ...prerenderSpecs,
   ...filesSpecs,
   ...dataSourcesSpecs,
+  ...dataSourceJobsSpecs,
+  ...dataSourceConnectorsSpecs,
+  ...dataSourceEvalsSpecs,
+  ...dataSourceMappersSpecs,
   ...voiceSpecs,
   ...agentSpecs,
   ...eventsSpecs,
@@ -5802,6 +7748,10 @@ var HANDLERS = {
   ...prerenderHandlers,
   ...filesHandlers,
   ...dataSourcesHandlers,
+  ...dataSourceJobsHandlers,
+  ...dataSourceConnectorsHandlers,
+  ...dataSourceEvalsHandlers,
+  ...dataSourceMappersHandlers,
   ...voiceHandlers,
   ...agentHandlers,
   ...eventsHandlers,
@@ -5838,8 +7788,8 @@ var GROUP_HELP = {
 };
 
 // src/ctx.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path6 from "path";
 
 // src/parseJsonConfig.ts
 import JSON5 from "json5";
@@ -5868,10 +7818,10 @@ function parseJsonConfig(raw) {
 // src/ctx.ts
 var DEFAULT_BASE_URL = "https://api.mindstudio.ai";
 function loadWorkspaceAppId(workspaceDir = WORKSPACE_DIR) {
-  const manifestPath = path4.join(workspaceDir, "mindstudio.json");
+  const manifestPath = path6.join(workspaceDir, "mindstudio.json");
   let raw;
   try {
-    raw = fs4.readFileSync(manifestPath, "utf-8");
+    raw = fs6.readFileSync(manifestPath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       throw new Error(`mindstudio.json not found at ${manifestPath}`);
@@ -5916,6 +7866,7 @@ Commands:
   settings    App settings \u2014 signup allowlist, test accounts, embed origins, toggles
   email       Email \u2014 delivery log, blast stats, unsubscribes, inbox, custom domains
   cron        Scheduled jobs \u2014 schedules, run history, manual trigger
+  infra       Dedicated infrastructure \u2014 provision, hibernate, resize + destroy retrieval capacity
 
 Run 'remy-admin <command> --help' for details on each command.
 
@@ -5974,6 +7925,11 @@ function resolveRoute(argv) {
       error: `Unknown subcommand: settings ${sub} ${action ?? ""}. Run 'remy-admin settings --help'`
     };
   }
+  if (group === "datasources" && (sub === "jobs" || sub === "eval" || sub === "map")) {
+    return {
+      error: `Unknown subcommand: datasources ${sub} ${action ?? ""}. Run 'remy-admin datasources --help'`
+    };
+  }
   if (group === "email" && ["domains", "inbound-domains"].includes(sub ?? "")) {
     return {
       error: `Unknown subcommand: email ${sub} ${action ?? ""}. Run 'remy-admin email --help'`