@agent-native/core 0.136.0 → 0.136.3

package/corpus/templates/clips/server/lib/agent-views.ts

@@ -36,13 +36,16 @@ const AGENT_LABELS: [RegExp, string][] = [
   [/bytespider|amazonbot|ccbot|diffbot|youbot/i, "Crawler"],
 ];
 
-export const UNKNOWN_AGENT_LABEL = "Agent";
-
-export function agentLabelFromUserAgent(userAgent: string): string {
+/**
+ * Null, not a placeholder string: an agent we could not name is a different
+ * fact from one that names itself "Agent", and only the null case should be
+ * rendered as unknown or fed back into {@link AGENT_LABELS}.
+ */
+export function agentLabelFromUserAgent(userAgent: string): string | null {
   for (const [pattern, label] of AGENT_LABELS) {
     if (pattern.test(userAgent)) return label;
   }
-  return UNKNOWN_AGENT_LABEL;
+  return null;
 }
 
 export function agentViewSessionId(
@@ -66,15 +69,20 @@ export function agentKeyFor(userAgent: string, ip: string): string {
 export async function recordAgentView(
   event: H3Event,
   recordingId: string,
-  nowMs: number = Date.now(),
+  options: { agentLabel?: string | null; nowMs?: number } = {},
 ): Promise<void> {
   try {
+    const nowMs = options.nowMs ?? Date.now();
     const userAgent = (getRequestHeader(event, "user-agent") ?? "").slice(
       0,
       512,
     );
     const ip = getRequestIP(event) || "unknown";
     const now = new Date(nowMs).toISOString();
+    // A label the link was minted with beats user-agent sniffing: it was set by
+    // whoever created the agent link and is carried in the signed token.
+    const agentLabel =
+      options.agentLabel?.trim() || agentLabelFromUserAgent(userAgent);
 
     await getDb()
       .insert(schema.recordingAgentViews)
@@ -82,7 +90,8 @@ export async function recordAgentView(
         id: nanoid(),
         recordingId,
         agentKey: agentKeyFor(userAgent, ip),
-        agentLabel: agentLabelFromUserAgent(userAgent),
+        agentLabel,
+        userAgent: userAgent || null,
         viewSessionId: agentViewSessionId(nowMs),
         firstSeenAt: now,
         lastSeenAt: now,
@@ -96,6 +105,10 @@ export async function recordAgentView(
         ],
         set: {
           lastSeenAt: now,
+          // A later poll in the same session can arrive without the token that
+          // carried the name (public clips are readable without one), so an
+          // absent label must never erase a stored one — a new name still wins.
+          agentLabel: sql`COALESCE(excluded.agent_label, ${schema.recordingAgentViews.agentLabel})`,
           requestCount: sql`${schema.recordingAgentViews.requestCount} + 1`,
         },
       });
@@ -115,30 +128,44 @@ export async function countRecordingAgentViews(
 }
 
 export interface AgentViewerSummary {
-  agentLabel: string;
+  /** Null when nothing named the agent — render it as unknown, don't invent one. */
+  agentLabel: string | null;
+  /** Raw user-agent, so an unnamed agent is still identifiable by a human. */
+  userAgent: string | null;
   views: number;
   lastSeenAt: string;
 }
 
-/** Agents that read this clip, most recent first, grouped by product label. */
+/**
+ * Agents that read this clip, most recent first. Named agents group by label;
+ * unnamed ones group by user-agent so two different unknown readers stay two
+ * rows instead of collapsing into one meaningless "unknown" bucket.
+ */
 export async function listRecordingAgentViewers(
   recordingId: string,
   limit = 8,
 ): Promise<AgentViewerSummary[]> {
+  const groupKey = sql<string>`COALESCE(${schema.recordingAgentViews.agentLabel}, ${schema.recordingAgentViews.userAgent}, '')`;
   const rows = await getDb()
     .select({
-      agentLabel: schema.recordingAgentViews.agentLabel,
+      agentLabel: sql<
+        string | null
+      >`MAX(${schema.recordingAgentViews.agentLabel})`,
+      userAgent: sql<
+        string | null
+      >`MAX(${schema.recordingAgentViews.userAgent})`,
       views: count(),
       lastSeenAt: sql<string>`MAX(${schema.recordingAgentViews.lastSeenAt})`,
     })
     .from(schema.recordingAgentViews)
     .where(eq(schema.recordingAgentViews.recordingId, recordingId))
-    .groupBy(schema.recordingAgentViews.agentLabel)
+    .groupBy(groupKey)
     .orderBy(desc(sql`MAX(${schema.recordingAgentViews.lastSeenAt})`))
     .limit(limit);
 
   return rows.map((r) => ({
-    agentLabel: r.agentLabel || UNKNOWN_AGENT_LABEL,
+    agentLabel: r.agentLabel || null,
+    userAgent: r.userAgent || null,
     views: Number(r.views ?? 0),
     lastSeenAt: r.lastSeenAt,
   }));

package/corpus/templates/clips/server/lib/media-storage-provenance.ts

@@ -0,0 +1,16 @@
+export function allowsLegacyS3ObjectForPersistedMedia(params: {
+  requestedUrl: string;
+  persistedUrl: string | null | undefined;
+  editsJson: string | null | undefined;
+}): boolean {
+  if (!params.persistedUrl || params.persistedUrl !== params.requestedUrl) {
+    return false;
+  }
+  try {
+    const edits = JSON.parse(params.editsJson || "{}");
+    return edits?.mediaStorageLayout !== "external";
+    // coercion-ok: malformed provenance is an explicit deny, never successful authorization.
+  } catch {
+    return false;
+  }
+}

package/corpus/templates/clips/server/lib/public-agent-context.ts

@@ -294,7 +294,9 @@ export async function loadPublicAgentAccess(
   // Every agent API route funnels through here, so this is the one place that
   // sees an outside agent read a clip. Owner requests are previews, not views.
   if (!viewerIsOwner) {
-    await recordAgentView(event, recording.id);
+    await recordAgentView(event, recording.id, {
+      agentLabel: tokenAccess?.ok ? tokenAccess.agentLabel : null,
+    });
   }
 
   return {

package/corpus/templates/clips/server/lib/recap-metrics.ts

@@ -0,0 +1,373 @@
+/**
+ * Monthly recap metrics — what an owner's clips did over one calendar month.
+ *
+ * Human and agent audiences are counted from separate tables on purpose
+ * (`recording_views` vs `recording_agent_views`), matching the split described
+ * in `agent-views.ts`: no human-view query can ever pick agents up.
+ *
+ * Months are closed on UTC boundaries. Per-user timezones are not yet stored,
+ * so a recap covers the same wall-clock window for everyone.
+ */
+
+import { and, asc, desc, eq, gte, inArray, isNull, lt, sql } from "drizzle-orm";
+
+import { getDb, schema } from "../db/index.js";
+import { ownerEmailMatches } from "./recordings.js";
+
+export interface RecapMonthRange {
+  month: string;
+  startAt: string;
+  endAt: string;
+}
+
+export interface RecapAgentBreakdownEntry {
+  /** Null when the reader could not be identified. */
+  agentLabel: string | null;
+  sessions: number;
+}
+
+export interface RecapTopClip {
+  recordingId: string;
+  title: string;
+  thumbnailUrl: string | null;
+  durationMs: number;
+  recordedAt: string;
+  humanViews: number;
+  agentSessions: number;
+  /** Mean completion across the humans who watched it this month, 0-100. */
+  completedPct: number;
+  /** Video-time position where watching last stopped, or null if unreported. */
+  dropOffMs: number | null;
+  agentBreakdown: RecapAgentBreakdownEntry[];
+}
+
+export interface MonthlyRecap {
+  month: string;
+  humanViews: number;
+  agentSessions: number;
+  topClip: RecapTopClip;
+}
+
+/** `2026-07` -> the half-open UTC range `[2026-07-01, 2026-08-01)`. */
+export function recapMonthRange(month: string): RecapMonthRange {
+  const match = /^(\d{4})-(0[1-9]|1[0-2])$/.exec(month);
+  if (!match) throw new Error(`Invalid recap month: ${month}`);
+  const year = Number(match[1]);
+  const monthIndex = Number(match[2]) - 1;
+  return {
+    month,
+    startAt: new Date(Date.UTC(year, monthIndex, 1)).toISOString(),
+    endAt: new Date(Date.UTC(year, monthIndex + 1, 1)).toISOString(),
+  };
+}
+
+/** The calendar month immediately before the one containing `now`, in UTC. */
+export function previousRecapMonth(now: Date): string {
+  const year = now.getUTCFullYear();
+  const monthIndex = now.getUTCMonth();
+  const previous = new Date(Date.UTC(year, monthIndex - 1, 1));
+  return `${previous.getUTCFullYear()}-${String(previous.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+
+export function recapMonthLabel(month: string): string {
+  const { startAt } = recapMonthRange(month);
+  return new Date(startAt).toLocaleString("en-US", {
+    month: "long",
+    timeZone: "UTC",
+  });
+}
+
+/**
+ * Trashed, archived, and unfinished clips are excluded so the top clip is
+ * always one the recap can link to — the ranking is recomputed at send time,
+ * and a clip the owner deleted must not headline it.
+ */
+async function ownerRecordingIds(ownerEmail: string): Promise<string[]> {
+  const rows = await getDb()
+    .select({ id: schema.recordings.id })
+    .from(schema.recordings)
+    .where(
+      and(
+        ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+        eq(schema.recordings.status, "ready"),
+        isNull(schema.recordings.archivedAt),
+        isNull(schema.recordings.trashedAt),
+      ),
+    );
+  return rows.map((row) => row.id);
+}
+
+/**
+ * Counts view rows, not distinct people. Deduping an identity across a month
+ * was both ambiguous — `viewerKey` is nullable on rows predating it — and
+ * expensive, so the recap reports human views and leaves unique audience out
+ * of scope. Summing these per-recording counts is therefore correct: one
+ * person watching two clips is genuinely two views.
+ */
+async function humanViewCounts(
+  recordingIds: string[],
+  range: RecapMonthRange,
+): Promise<Map<string, number>> {
+  if (recordingIds.length === 0) return new Map();
+  const rows = await getDb()
+    .select({
+      recordingId: schema.recordingViews.recordingId,
+      views: sql<number>`count(*)`,
+    })
+    .from(schema.recordingViews)
+    .where(
+      and(
+        inArray(schema.recordingViews.recordingId, recordingIds),
+        gte(schema.recordingViews.viewedAt, range.startAt),
+        lt(schema.recordingViews.viewedAt, range.endAt),
+      ),
+    )
+    .groupBy(schema.recordingViews.recordingId);
+  return new Map(rows.map((row) => [row.recordingId, Number(row.views)]));
+}
+
+async function agentSessionCounts(
+  recordingIds: string[],
+  range: RecapMonthRange,
+): Promise<Map<string, number>> {
+  if (recordingIds.length === 0) return new Map();
+  const rows = await getDb()
+    .select({
+      recordingId: schema.recordingAgentViews.recordingId,
+      sessions: sql<number>`count(*)`,
+    })
+    .from(schema.recordingAgentViews)
+    .where(
+      and(
+        inArray(schema.recordingAgentViews.recordingId, recordingIds),
+        gte(schema.recordingAgentViews.firstSeenAt, range.startAt),
+        lt(schema.recordingAgentViews.firstSeenAt, range.endAt),
+      ),
+    )
+    .groupBy(schema.recordingAgentViews.recordingId);
+  return new Map(rows.map((row) => [row.recordingId, Number(row.sessions)]));
+}
+
+async function agentBreakdown(
+  recordingId: string,
+  range: RecapMonthRange,
+): Promise<RecapAgentBreakdownEntry[]> {
+  const rows = await getDb()
+    .select({
+      agentLabel: schema.recordingAgentViews.agentLabel,
+      sessions: sql<number>`count(*)`,
+    })
+    .from(schema.recordingAgentViews)
+    .where(
+      and(
+        eq(schema.recordingAgentViews.recordingId, recordingId),
+        gte(schema.recordingAgentViews.firstSeenAt, range.startAt),
+        lt(schema.recordingAgentViews.firstSeenAt, range.endAt),
+      ),
+    )
+    .groupBy(schema.recordingAgentViews.agentLabel)
+    .orderBy(desc(sql`count(*)`), asc(schema.recordingAgentViews.agentLabel));
+  return rows.map((row) => ({
+    agentLabel: row.agentLabel || null,
+    sessions: Number(row.sessions),
+  }));
+}
+
+/**
+ * Mean completion across viewers who watched this month, and the video-time
+ * position where watching last stopped.
+ *
+ * `recording_viewers` holds no per-month completion, so this reflects each
+ * viewer's lifetime progress on a clip they watched during the month. A viewer
+ * who finished it in June and reopened it in July reports June's completion.
+ */
+async function watchDepth(
+  recordingId: string,
+  range: RecapMonthRange,
+): Promise<{ completedPct: number; dropOffMs: number | null }> {
+  const db = getDb();
+  const monthViewerIds = await db
+    .selectDistinct({ viewerId: schema.recordingViews.viewerId })
+    .from(schema.recordingViews)
+    .where(
+      and(
+        eq(schema.recordingViews.recordingId, recordingId),
+        gte(schema.recordingViews.viewedAt, range.startAt),
+        lt(schema.recordingViews.viewedAt, range.endAt),
+      ),
+    );
+  const viewerIds = monthViewerIds.map((row) => row.viewerId);
+  if (viewerIds.length === 0) return { completedPct: 0, dropOffMs: null };
+
+  const [completion] = await db
+    .select({ mean: sql<number>`avg(${schema.recordingViewers.completedPct})` })
+    .from(schema.recordingViewers)
+    .where(
+      and(
+        eq(schema.recordingViewers.recordingId, recordingId),
+        inArray(schema.recordingViewers.id, viewerIds),
+      ),
+    );
+
+  const [lastProgress] = await db
+    .select({ timestampMs: schema.recordingEvents.timestampMs })
+    .from(schema.recordingEvents)
+    .where(
+      and(
+        eq(schema.recordingEvents.recordingId, recordingId),
+        inArray(schema.recordingEvents.viewerId, viewerIds),
+        inArray(schema.recordingEvents.kind, ["watch-progress", "pause"]),
+        gte(schema.recordingEvents.createdAt, range.startAt),
+        lt(schema.recordingEvents.createdAt, range.endAt),
+      ),
+    )
+    .orderBy(desc(schema.recordingEvents.timestampMs))
+    .limit(1);
+
+  return {
+    completedPct: Math.round(Number(completion?.mean ?? 0)),
+    dropOffMs: lastProgress ? Number(lastProgress.timestampMs) : null,
+  };
+}
+
+/**
+ * Rank by total audience (human views + agent sessions), breaking
+ * ties on the more recently recorded clip.
+ */
+export function rankTopClip<
+  T extends { recordingId: string; audience: number; recordedAt: string },
+>(candidates: readonly T[]): T | null {
+  return (
+    [...candidates].sort(
+      (left, right) =>
+        right.audience - left.audience ||
+        right.recordedAt.localeCompare(left.recordedAt) ||
+        left.recordingId.localeCompare(right.recordingId),
+    )[0] ?? null
+  );
+}
+
+/**
+ * Returns null when the owner had no human or agent audience that month, which
+ * is also the signal not to send them a recap at all.
+ */
+export async function computeMonthlyRecap(
+  ownerEmail: string,
+  month: string,
+): Promise<MonthlyRecap | null> {
+  const range = recapMonthRange(month);
+  const recordingIds = await ownerRecordingIds(ownerEmail);
+  if (recordingIds.length === 0) return null;
+
+  const [humansByRecording, agentsByRecording] = await Promise.all([
+    humanViewCounts(recordingIds, range),
+    agentSessionCounts(recordingIds, range),
+  ]);
+
+  const humanViews = [...humansByRecording.values()].reduce(
+    (total, value) => total + value,
+    0,
+  );
+  const agentSessions = [...agentsByRecording.values()].reduce(
+    (total, value) => total + value,
+    0,
+  );
+  if (humanViews === 0 && agentSessions === 0) return null;
+
+  const watchedIds = [
+    ...new Set([...humansByRecording.keys(), ...agentsByRecording.keys()]),
+  ];
+  const watched = await getDb()
+    .select({
+      id: schema.recordings.id,
+      title: schema.recordings.title,
+      thumbnailUrl: schema.recordings.thumbnailUrl,
+      durationMs: schema.recordings.durationMs,
+      createdAt: schema.recordings.createdAt,
+    })
+    .from(schema.recordings)
+    .where(
+      and(
+        inArray(schema.recordings.id, watchedIds),
+        ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+      ),
+    );
+
+  const ranked = rankTopClip(
+    watched.map((recording) => ({
+      recordingId: recording.id,
+      audience:
+        (humansByRecording.get(recording.id) ?? 0) +
+        (agentsByRecording.get(recording.id) ?? 0),
+      recordedAt: recording.createdAt,
+      recording,
+    })),
+  );
+  if (!ranked) return null;
+
+  const [depth, breakdown] = await Promise.all([
+    watchDepth(ranked.recordingId, range),
+    agentBreakdown(ranked.recordingId, range),
+  ]);
+
+  return {
+    month,
+    humanViews,
+    agentSessions,
+    topClip: {
+      recordingId: ranked.recordingId,
+      title: ranked.recording.title,
+      thumbnailUrl: ranked.recording.thumbnailUrl,
+      durationMs: ranked.recording.durationMs,
+      recordedAt: ranked.recording.createdAt,
+      humanViews: humansByRecording.get(ranked.recordingId) ?? 0,
+      agentSessions: agentsByRecording.get(ranked.recordingId) ?? 0,
+      completedPct: depth.completedPct,
+      dropOffMs: depth.dropOffMs,
+      agentBreakdown: breakdown,
+    },
+  };
+}
+
+/** Owners with any human or agent audience in the month, for reconciliation. */
+export async function listOwnersWithMonthlyAudience(
+  month: string,
+): Promise<string[]> {
+  const range = recapMonthRange(month);
+  const db = getDb();
+  const [humanOwners, agentOwners] = await Promise.all([
+    db
+      .selectDistinct({ ownerEmail: schema.recordings.ownerEmail })
+      .from(schema.recordingViews)
+      .innerJoin(
+        schema.recordings,
+        eq(schema.recordings.id, schema.recordingViews.recordingId),
+      )
+      .where(
+        and(
+          gte(schema.recordingViews.viewedAt, range.startAt),
+          lt(schema.recordingViews.viewedAt, range.endAt),
+        ),
+      ),
+    db
+      .selectDistinct({ ownerEmail: schema.recordings.ownerEmail })
+      .from(schema.recordingAgentViews)
+      .innerJoin(
+        schema.recordings,
+        eq(schema.recordings.id, schema.recordingAgentViews.recordingId),
+      )
+      .where(
+        and(
+          gte(schema.recordingAgentViews.firstSeenAt, range.startAt),
+          lt(schema.recordingAgentViews.firstSeenAt, range.endAt),
+        ),
+      ),
+  ]);
+  return [
+    ...new Set(
+      [...humanOwners, ...agentOwners]
+        .map((row) => row.ownerEmail.trim().toLowerCase())
+        .filter(Boolean),
+    ),
+  ].sort();
+}

package/corpus/templates/clips/server/lib/s3-upload-provider.ts

@@ -54,14 +54,18 @@ async function fetchWithTimeout(
     });
   } catch (err) {
     if (err instanceof Error && err.name === "TimeoutError") {
-      throw new Error(
+      const timeoutError = new Error(
         `S3 request timed out after ${timeoutMs}ms: ${init.method ?? "GET"} ${url}`,
       );
+      timeoutError.name = "TimeoutError";
+      throw timeoutError;
     }
     if (err instanceof Error && err.name === "AbortError") {
-      throw new Error(
+      const abortError = new Error(
         `S3 request aborted (timeout ${timeoutMs}ms): ${init.method ?? "GET"} ${url}`,
       );
+      abortError.name = "AbortError";
+      throw abortError;
     }
     throw err;
   }
@@ -199,6 +203,7 @@ async function signedS3Request(
     query?: Record<string, string>;
     body?: Uint8Array;
     contentType?: string;
+    range?: string;
     timeoutMs: number;
   },
 ): Promise<Response> {
@@ -265,6 +270,9 @@ async function signedS3Request(
         ...(options.body
           ? { "Content-Length": String(options.body.byteLength) }
           : {}),
+        ...(options.range?.startsWith("bytes=")
+          ? { Range: options.range }
+          : {}),
       },
       ...(options.body
         ? {
@@ -350,6 +358,35 @@ function objectKeyFromUrl(cfg: S3Config, rawUrl: string): string | null {
   return decodeUrlPathSegment(encodedKey);
 }
 
+function isCompletedClipObjectKey(key: string): boolean {
+  if (!key.startsWith("clips/") || key.length > 1024) return false;
+  if (key.includes("\\") || key.includes("\0")) return false;
+  const segments = key.split("/");
+  if (
+    segments.some((segment) => !segment || segment === "." || segment === "..")
+  ) {
+    return false;
+  }
+  return !key.startsWith("clips/.multipart/") && !key.endsWith(".pending");
+}
+
+function safeClipFilename(value: string): string {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+
+function isRecordingObjectKey(key: string, recordingId: string): boolean {
+  const safeRecordingId = safeClipFilename(recordingId);
+  if (key.startsWith(`clips/${safeRecordingId}/`)) return true;
+  const directObjectPrefix = `clips/${safeRecordingId}.`;
+  if (!key.startsWith(directObjectPrefix)) return false;
+  const extension = key.slice(directObjectPrefix.length);
+  return /^[a-zA-Z0-9_-]+$/.test(extension);
+}
+
+function isLegacyUnscopedObjectKey(key: string): boolean {
+  return /^clips\/\d{13}-[a-z0-9]{8}\.[a-zA-Z0-9_-]+$/.test(key);
+}
+
 async function deleteObject(cfg: S3Config, key: string): Promise<void> {
   const res = await signedS3Request(cfg, key, {
     method: "DELETE",
@@ -561,6 +598,47 @@ export async function deleteS3ObjectByUrl(url: string): Promise<boolean> {
   return true;
 }
 
+export async function isS3ObjectUrlBoundToRecording(
+  url: string,
+  recordingId: string,
+): Promise<boolean | null> {
+  const cfg = await readS3Config();
+  if (!cfg) return null;
+  const key = objectKeyFromUrl(cfg, url);
+  if (!key) return null;
+  return (
+    isCompletedClipObjectKey(key) && isRecordingObjectKey(key, recordingId)
+  );
+}
+
+export async function fetchS3ObjectByUrl(
+  url: string,
+  options: {
+    range?: string;
+    timeoutMs?: number;
+    recordingId: string;
+    allowLegacyObjectKey?: boolean;
+  },
+): Promise<Response | null> {
+  const cfg = await readS3Config();
+  if (!cfg) return null;
+  const key = objectKeyFromUrl(cfg, url);
+  if (
+    !key ||
+    !isCompletedClipObjectKey(key) ||
+    !options.recordingId ||
+    (!isRecordingObjectKey(key, options.recordingId) &&
+      !(options.allowLegacyObjectKey && isLegacyUnscopedObjectKey(key)))
+  ) {
+    return null;
+  }
+  return signedS3Request(cfg, key, {
+    method: "GET",
+    range: options.range,
+    timeoutMs: options.timeoutMs ?? S3_PUT_TIMEOUT_MS,
+  });
+}
+
 // ── Provider ──────────────────────────────────────────────────────────
 
 export const s3FileUploadProvider: FileUploadProvider = {
@@ -573,9 +651,11 @@ export const s3FileUploadProvider: FileUploadProvider = {
     if (!cfg) throw new Error("S3 credentials are not configured");
 
     const ext = filename?.split(".").pop() ?? "bin";
+    const basename = filename?.slice(0, -(ext.length + 1)) || "file";
+    const safeBasename = safeClipFilename(basename);
     const stamp = Date.now();
     const rand = Math.random().toString(36).slice(2, 10);
-    const objectKey = `clips/${stamp}-${rand}.${ext}`;
+    const objectKey = `clips/${safeBasename}/${stamp}-${rand}.${ext}`;
     const contentType = mimeType || "application/octet-stream";
 
     const bytes =
@@ -591,7 +671,7 @@ export const s3FileUploadProvider: FileUploadProvider = {
       const cfg = await readS3Config();
       if (!cfg) throw new Error("S3 credentials are not configured");
 
-      const safeFilename = filename.replace(/[^a-zA-Z0-9._-]/g, "-");
+      const safeFilename = safeClipFilename(filename);
       if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
         throw new Error("S3 resumable upload requires a positive byte limit");
       }