mcp-scraper 0.41.0 → 0.42.0

package/dist/{server-2JJPCZH4.js → server-MVCGZ4OK.js}

@@ -3,20 +3,20 @@ import {
   cleanupExpiredSiteExtractArtifacts,
   harvestPageMedia,
   renewSiteExtractArtifactDownload
-} from "./chunk-QZXKQB7Y.js";
+} from "./chunk-6Q7V4IQV.js";
 import {
   REQUIRED_LOCATION_STATE_CODES,
   importHostedCensusPlacesCsv,
   importHostedZipGroupsCsv,
   listActiveHostedLocationDatasets
-} from "./chunk-27DUCRAZ.js";
+} from "./chunk-QOWBJ4YY.js";
 import {
   classifyHarvestProblem,
   createHarvestAttemptRecorder,
   deliverWebhook,
   harvestProblemResponse,
   serializeHarvestProblem
-} from "./chunk-CS4HE6QY.js";
+} from "./chunk-ZBQ6EXZW.js";
 import {
   AIModeSelectors,
   AIOverviewSelectors,
@@ -40,11 +40,23 @@ import {
   resolveBackupKernelProxyId,
   resolveKernelProxyId,
   serpArrivalUrl
-} from "./chunk-JVIW4GK2.js";
+} from "./chunk-DH42LIR3.js";
 import {
+  ApiErrorResponseSchema,
+  ArtifactTemplateConfigSchema,
+  CreateArtifactTemplateInputSchema,
   CreateEditorialReadingRoomInputSchema,
+  CreateScheduledRunViewLinkInputSchema,
+  EditorialReadingRoomV1InputSchema,
+  GetScheduledRunResponseSchema,
   HttpMcpToolExecutor,
+  InternalScheduledArtifactRenderRequestSchema,
+  ListScheduledRunsQuerySchema,
+  PublicScheduledRunTokenSchema,
   RenewEditorialReadingRoomDownloadInputSchema,
+  SCHEDULED_ARTIFACT_TEMPLATE_PRESET,
+  ScheduledResultsMcpExecutor,
+  UpdateArtifactTemplateInputSchema,
   WIZPER_LANGUAGES,
   WaybackInventoryOptionsSchema,
   WaybackTimelineSchema,
@@ -63,11 +75,12 @@ import {
   outputBaseDir,
   registerBrowserAgentMcpTools,
   registerMemoryMcpTools,
+  registerScheduledResultsMcpTools,
   registerSerpIntelligenceCaptureTools,
   renewConnectedDataArtifactDownload,
   renewDirectoryArtifactDownload,
   transcribeMediaUrl
-} from "./chunk-SIE5LZ2V.js";
+} from "./chunk-6O6DPKLX.js";
 import {
   auditImageUrls,
   auditImages,
@@ -75,9 +88,10 @@ import {
   computeIssues,
   createPrivateArtifact,
   isPrivateIpAddress,
+  readPrivateArtifactWindow,
   renewPrivateArtifactDownload,
   validatePublicHttpUrl
-} from "./chunk-345BQXZH.js";
+} from "./chunk-MJKVDLVR.js";
 import {
   sanitizeAttempts,
   sanitizeHarvestResult,
@@ -92,7 +106,7 @@ import {
   recordKernelSession,
   recordVendorUsage,
   runWithCostContext
-} from "./chunk-EHES33KB.js";
+} from "./chunk-DAS7L4SF.js";
 import {
   listWorkflowDefinitions,
   runWorkflow,
@@ -119,7 +133,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-CB5C3BPB.js";
-import "./chunk-OOB35KFT.js";
+import "./chunk-S5OVG2MK.js";
 import {
   abandonExtractSettlement,
   countSuccessfulPages,
@@ -142,7 +156,7 @@ import {
   setExtractJobTotal,
   settleExtractJob,
   terminalExtractJobStatus
-} from "./chunk-6J57U6HA.js";
+} from "./chunk-4MFUKI4X.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -298,7 +312,7 @@ import {
   startHarvestAttempt,
   upsertPageSnapshot,
   verifyPassword
-} from "./chunk-IQTT7CAB.js";
+} from "./chunk-FCFQ634B.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -3615,7 +3629,7 @@ async function generateOgImage(post) {
 
 // src/api/server.ts
 import { Resend as Resend3 } from "resend";
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 
 // src/api/kpo-extractor.ts
 import TurndownService from "turndown";
@@ -6236,7 +6250,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono30 } from "hono";
+import { Hono as Hono33 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -8644,7 +8658,7 @@ var siteExtractFn = inngest.createFunction(
       });
     }) : null;
     const finalized = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-SKXEDG4Z.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-DMZ63HZU.js");
       const current = await getExtractJob(jobId2);
       if (!current) throw new Error("extract job disappeared before finalization");
       const stored = await assembleExtractArtifacts(current, { branding, imageAudit });
@@ -9586,7 +9600,7 @@ async function resolveUsZipsPath(requestedPath) {
 async function loadZipGroups(stateAbbr, requestedPath, warnings, sourceMode) {
   const mode = resolvedLocationDataMode({ zipSource: sourceMode });
   if (mode === "hosted") {
-    const { getHostedZipGroups } = await import("./location-data-repository-NBTCOA7B.js");
+    const { getHostedZipGroups } = await import("./location-data-repository-SHEOIBTL.js");
     const hosted = await getHostedZipGroups(stateAbbr);
     if (!hosted.dataset) {
       throw new DirectoryLocationError(
@@ -9649,7 +9663,7 @@ async function resolveDirectoryMarkets(options, config = {}) {
   const sourceUrl = censusStateUrl(state.fips);
   const warnings = [];
   if (resolvedLocationDataMode(config) === "hosted") {
-    const { queryHostedLocationMarkets } = await import("./location-data-repository-NBTCOA7B.js");
+    const { queryHostedLocationMarkets } = await import("./location-data-repository-SHEOIBTL.js");
     const hosted = await queryHostedLocationMarkets({
       state: state.abbr,
       minPopulation: options.minPopulation,
@@ -12635,12 +12649,12 @@ function normalizeIdempotencyKey(value) {
 function tokenFor(id, idempotencyKey2) {
   return createHmac("sha256", billingSecret()).update(id).update(":").update(idempotencyKey2).digest("base64url");
 }
-function tokenHash(token2) {
-  return createHash3("sha256").update(token2).digest("hex");
+function tokenHash(token3) {
+  return createHash3("sha256").update(token3).digest("hex");
 }
-function verifyToken(row, token2) {
+function verifyToken(row, token3) {
   const expected = Buffer.from(row.token_hash, "hex");
-  const actual = Buffer.from(tokenHash(token2), "hex");
+  const actual = Buffer.from(tokenHash(token3), "hex");
   if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
     throw new UnifiedBillingError("unauthorized", "invalid billing authorization token", 401);
   }
@@ -12757,11 +12771,11 @@ async function authorizeScheduledRun(args) {
     );
   }
   const id = randomUUID3();
-  const token2 = tokenFor(id, idempotencyKey2);
+  const token3 = tokenFor(id, idempotencyKey2);
   const expiresAt = new Date(Date.now() + AUTHORIZATION_TTL_MS).toISOString();
   const inserted = await getDb().execute({
     sql: "INSERT OR IGNORE INTO billing_authorizations (id, user_id, idempotency_key, billing_class, status, minimum_amount_mc, maximum_amount_mc, token_hash, metadata, expires_at) VALUES (?, ?, ?, ?, 'authorized', ?, ?, ?, ?, ?)",
-    args: [id, user.id, idempotencyKey2, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_BASE_MC, maximumMc, tokenHash(token2), safeMetadata2(args.metadata), expiresAt]
+    args: [id, user.id, idempotencyKey2, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_BASE_MC, maximumMc, tokenHash(token3), safeMetadata2(args.metadata), expiresAt]
   });
   if (inserted.rowsAffected === 0) {
     const raced = await getDb().execute({
@@ -12777,7 +12791,7 @@ async function authorizeScheduledRun(args) {
   }
   return {
     id,
-    token: token2,
+    token: token3,
     status: "authorized",
     minimumMc: SCHEDULED_RUN_BASE_MC,
     maximumMc,
@@ -13047,11 +13061,11 @@ function signSession(userId) {
   const sig = createHmac2("sha256", secret()).update(payload).digest("hex");
   return `${payload}.${sig}`;
 }
-function verifySession(token2) {
-  const dot = token2.lastIndexOf(".");
+function verifySession(token3) {
+  const dot = token3.lastIndexOf(".");
   if (dot === -1) return null;
-  const payload = token2.slice(0, dot);
-  const sig = token2.slice(dot + 1);
+  const payload = token3.slice(0, dot);
+  const sig = token3.slice(dot + 1);
   const expected = createHmac2("sha256", secret()).update(payload).digest("hex");
   if (!safeEqualHex(sig, expected)) return null;
   const id = parseInt(payload);
@@ -14380,9 +14394,9 @@ var YouTubeExtractor = class {
   }
   async fetchContinuation(page, endpoint, contToken, context) {
     const result = await page.evaluate(
-      async ({ ep, token: token2, ctx }) => {
+      async ({ ep, token: token3, ctx }) => {
         const body = {
-          continuation: token2,
+          continuation: token3,
           context: {
             client: {
               clientName: ctx.clientName,
@@ -16261,7 +16275,7 @@ function advertiserTokenOverlap(query, candidate) {
   const candidateTokens = new Set(normalizeAdvertiserName(candidate).split(" ").filter(Boolean));
   if (queryTokens.size === 0 || candidateTokens.size === 0) return 0;
   let overlap = 0;
-  for (const token2 of queryTokens) if (candidateTokens.has(token2)) overlap++;
+  for (const token3 of queryTokens) if (candidateTokens.has(token3)) overlap++;
   return overlap / queryTokens.size;
 }
 function assessPageIntelMatch(body, result) {
@@ -22638,8 +22652,8 @@ function protectedResourceMetadata() {
 function wwwAuthenticateValue() {
   return `Bearer resource_metadata="${oauthResourceBaseUrl()}/.well-known/oauth-protected-resource"`;
 }
-function isBearerJwt(token2) {
-  return !token2.startsWith("sk_") && token2.split(".").length === 3;
+function isBearerJwt(token3) {
+  return !token3.startsWith("sk_") && token3.split(".").length === 3;
 }
 var jwksSingleton = null;
 function getJwks() {
@@ -22647,8 +22661,8 @@ function getJwks() {
   jwksSingleton = createRemoteJWKSet(new URL(`${oauthIssuer()}/.well-known/jwks.json`));
   return jwksSingleton;
 }
-async function verifyScraperOAuthJwt(token2) {
-  const { payload } = await jwtVerify(token2, getJwks(), {
+async function verifyScraperOAuthJwt(token3) {
+  const { payload } = await jwtVerify(token3, getJwks(), {
     issuer: oauthIssuer(),
     audience: oauthResourceUrl()
   });
@@ -22718,6 +22732,7 @@ mcpApp.all("/", async (c) => {
     const server = buildPaaExtractorMcpServer(executor, { savesReportsLocally: false, ownerId: hashOwnerId(callerKey) });
     registerSerpIntelligenceCaptureTools(server, executor);
     registerBrowserAgentMcpTools(server, { baseUrl, apiKey: callerKey, consoleBaseUrl, savesReportsLocally: false });
+    registerScheduledResultsMcpTools(server, new ScheduledResultsMcpExecutor(baseUrl, callerKey));
     const memoryExecutor = new HybridMemoryToolExecutor(new MemoryMcpToolExecutor(baseUrl, callerKey), user);
     registerMemoryMcpTools(server, memoryExecutor);
     await server.connect(transport);
@@ -25351,9 +25366,9 @@ function negotiateScope(requested, user, resource) {
   if (operator && !unique2.includes("memory.admin")) unique2.push("memory.admin");
   return unique2.join(" ");
 }
-async function sessionUser(token2) {
-  if (!token2) return null;
-  const userId = verifySession(token2);
+async function sessionUser(token3) {
+  if (!token3) return null;
+  const userId = verifySession(token3);
   if (!userId) return null;
   const user = await getUserById(userId);
   return user ?? null;
@@ -25700,35 +25715,35 @@ oauthApp.post("/oauth/token", async (c) => {
 // src/api/chat-routes.ts
 import { Hono as Hono24 } from "hono";
 var chatApp = new Hono24();
-function tokenOk(token2) {
-  return !!token2 && token2.startsWith("mk_") && token2.length > 10;
+function tokenOk(token3) {
+  return !!token3 && token3.startsWith("mk_") && token3.length > 10;
 }
 function jsonError(message, status = 400) {
   return new Response(JSON.stringify({ ok: false, error: message }), { status, headers: { "content-type": "application/json" } });
 }
 chatApp.get("/api/channels", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk(token2)) return jsonError("missing or malformed token", 401);
-  const r = await memoryCall("listVaultsTool", {}, token2);
+  const token3 = c.req.query("token");
+  if (!tokenOk(token3)) return jsonError("missing or malformed token", 401);
+  const r = await memoryCall("listVaultsTool", {}, token3);
   if (!r.ok) return c.json(r);
   const vaults = (r.vaults ?? []).filter((v) => v.kind === "channel");
   return c.json({ ok: true, channels: vaults });
 });
 chatApp.get("/api/messages", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk(token2)) return jsonError("missing or malformed token", 401);
+  const token3 = c.req.query("token");
+  if (!tokenOk(token3)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   if (!vault) return jsonError("vault is required");
   const parentMessageId = c.req.query("parentMessageId") || void 0;
-  const r = await memoryCall("listChannelMessagesTool", { vault, parentMessageId }, token2);
+  const r = await memoryCall("listChannelMessagesTool", { vault, parentMessageId }, token3);
   return c.json(r);
 });
 chatApp.get("/api/poll", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk(token2)) return jsonError("missing or malformed token", 401);
+  const token3 = c.req.query("token");
+  if (!tokenOk(token3)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   if (!vault) return jsonError("vault is required");
-  const r = await memoryCall("pollChannelTool", { vault }, token2);
+  const r = await memoryCall("pollChannelTool", { vault }, token3);
   return c.json(r);
 });
 function parseAttachNote(v) {
@@ -25753,12 +25768,12 @@ chatApp.post("/api/reply", async (c) => {
   return c.json(r);
 });
 chatApp.get("/api/notes-own", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk(token2)) return jsonError("missing or malformed token", 401);
-  const vaultsRes = await memoryCall("listVaultsTool", {}, token2);
+  const token3 = c.req.query("token");
+  if (!tokenOk(token3)) return jsonError("missing or malformed token", 401);
+  const vaultsRes = await memoryCall("listVaultsTool", {}, token3);
   if (!vaultsRes.ok) return c.json(vaultsRes);
   const ownVaults = (vaultsRes.vaults ?? []).filter((v) => v.role === "owner" && v.kind === "notes");
-  const lists = await Promise.all(ownVaults.map((v) => memoryCall("listTool", { vault: v.handle }, token2)));
+  const lists = await Promise.all(ownVaults.map((v) => memoryCall("listTool", { vault: v.handle }, token3)));
   const notes = ownVaults.flatMap((v, i) => {
     const r = lists[i];
     return r.ok ? (r.notes ?? []).map((n) => ({ vault: v.handle, path: n.path, title: n.title })) : [];
@@ -25766,12 +25781,12 @@ chatApp.get("/api/notes-own", async (c) => {
   return c.json({ ok: true, notes });
 });
 chatApp.get("/api/message-note", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk(token2)) return jsonError("missing or malformed token", 401);
+  const token3 = c.req.query("token");
+  if (!tokenOk(token3)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   const messageId = c.req.query("messageId");
   if (!vault || !messageId) return jsonError("vault and messageId are required");
-  const r = await memoryCall("getMessageNoteTool", { vault, messageId }, token2);
+  const r = await memoryCall("getMessageNoteTool", { vault, messageId }, token3);
   return c.json(r);
 });
 chatApp.post("/api/react", async (c) => {
@@ -25782,17 +25797,17 @@ chatApp.post("/api/react", async (c) => {
   return c.json(r);
 });
 chatApp.get("/api/mentions", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk(token2)) return jsonError("missing or malformed token", 401);
-  const r = await memoryCall("myMentionsTool", {}, token2);
+  const token3 = c.req.query("token");
+  if (!tokenOk(token3)) return jsonError("missing or malformed token", 401);
+  const r = await memoryCall("myMentionsTool", {}, token3);
   return c.json(r);
 });
 chatApp.get("/api/members", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk(token2)) return jsonError("missing or malformed token", 401);
+  const token3 = c.req.query("token");
+  if (!tokenOk(token3)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   if (!vault) return jsonError("vault is required");
-  const r = await memoryCall("listChannelMembersTool", { vault }, token2);
+  const r = await memoryCall("listChannelMembersTool", { vault }, token3);
   return c.json(r);
 });
 chatApp.post("/api/channel", async (c) => {
@@ -25828,13 +25843,13 @@ chatApp.post("/api/member-remove", async (c) => {
   return c.json(r);
 });
 chatApp.get("/:token", (c) => {
-  const token2 = c.req.param("token");
-  if (!tokenOk(token2)) {
+  const token3 = c.req.param("token");
+  if (!tokenOk(token3)) {
     return c.html(`<!doctype html><html><body style="font-family:system-ui;padding:40px;color:#3D3548"><h2>This chat link isn't valid.</h2><p>Ask the AI to run get-chat-link again, or revoke-chat-link then get-chat-link if you think it was compromised.</p></body></html>`, 401);
   }
-  return c.html(renderChatPage(token2));
+  return c.html(renderChatPage(token3));
 });
-function renderChatPage(token2) {
+function renderChatPage(token3) {
   return `<!doctype html>
 <html>
 <head>
@@ -26019,7 +26034,7 @@ function renderChatPage(token2) {
 </div>
 
 <script>
-const TOKEN = ${JSON.stringify(token2)};
+const TOKEN = ${JSON.stringify(token3)};
 const state = { channels: [], activeVault: null, activeName: null, members: [], threadParent: null, pollTimer: null, pendingAttach: null, threadPendingAttach: null, ownNotes: null, pickerTarget: 'main' };
 
 function api(path, opts) {
@@ -26389,8 +26404,8 @@ var MAX_VAULT_RECORDS = 200;
 var MAX_MEMORY_READ_CONCURRENCY = 4;
 var MAX_MEMORY_READ_ATTEMPTS = 3;
 var vaultApp = new Hono25();
-function validToken(token2) {
-  return !!token2 && token2.startsWith("mk_") && token2.length > 20 && token2.length < 256;
+function validToken(token3) {
+  return !!token3 && token3.startsWith("mk_") && token3.length > 20 && token3.length < 256;
 }
 function isVault(value) {
   return typeof value === "string" && VAULTS.includes(value);
@@ -26516,11 +26531,11 @@ function shouldRetryMemoryRead(error) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function readMemory(tool, args, token2) {
-  let result = await memoryCall(tool, args, token2);
+async function readMemory(tool, args, token3) {
+  let result = await memoryCall(tool, args, token3);
   for (let attempt = 1; !result.ok && attempt < MAX_MEMORY_READ_ATTEMPTS && shouldRetryMemoryRead(result.error); attempt += 1) {
     await sleep(attempt * 150);
-    result = await memoryCall(tool, args, token2);
+    result = await memoryCall(tool, args, token3);
   }
   return result;
 }
@@ -26537,27 +26552,27 @@ async function mapWithConcurrency3(items, limit, map) {
   await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
   return values;
 }
-async function readVault(vault, token2) {
-  const list = await readMemory("listTool", { vault }, token2);
+async function readVault(vault, token3) {
+  const list = await readMemory("listTool", { vault }, token3);
   if (!list.ok) throw new Error(list.error ?? `unable to read ${vault}`);
   const noteRefs = (list.notes ?? []).slice(0, MAX_VAULT_RECORDS);
   const notes = await mapWithConcurrency3(
     noteRefs,
     MAX_MEMORY_READ_CONCURRENCY,
-    ({ path: path5 }) => readMemory("getTool", { vault, path: path5 }, token2)
+    ({ path: path5 }) => readMemory("getTool", { vault, path: path5 }, token3)
   );
   const failed = notes.find((result) => !result.ok);
   if (failed && !failed.ok) throw new Error(failed.error ?? `unable to read ${vault} record`);
   return notes.filter((result) => result.ok && !!result.note).map((result) => workspaceRecord(vault, result.note));
 }
 vaultApp.get("/api/workspace", async (c) => {
-  const token2 = c.req.query("token");
-  if (!validToken(token2)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token3 = c.req.query("token");
+  if (!validToken(token3)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   try {
     const requested = c.req.query("vault");
     const vaults = isVault(requested) ? [requested] : VAULTS;
     const results = [];
-    for (const vault of vaults) results.push(await readVault(vault, token2));
+    for (const vault of vaults) results.push(await readVault(vault, token3));
     const records = results.flat().sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     return c.json({ ok: true, records, limited: results.some((result) => result.length >= 200) });
   } catch (error) {
@@ -26566,8 +26581,8 @@ vaultApp.get("/api/workspace", async (c) => {
 });
 vaultApp.post("/api/records", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token2 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token2)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token3 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token3)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = body.vault;
   const path5 = stringValue(body.path, 320);
   const title = stringValue(body.title, 320);
@@ -26578,19 +26593,19 @@ vaultApp.post("/api/records", async (c) => {
   const validationError = validateNewRecord(vault, normalizedProps);
   if (validationError) return c.json({ ok: false, error: validationError }, 400);
   const baseRevision = typeof body.baseRevision === "number" && Number.isInteger(body.baseRevision) ? body.baseRevision : void 0;
-  const result = await memoryCall("putTool", { vault, path: path5, title, content: content || title, props: normalizedProps, ...baseRevision === void 0 ? {} : { baseRevision } }, token2);
+  const result = await memoryCall("putTool", { vault, path: path5, title, content: content || title, props: normalizedProps, ...baseRevision === void 0 ? {} : { baseRevision } }, token3);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/records/transition", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token2 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token2)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token3 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token3)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = typeof body.vault === "string" ? body.vault : "";
   const path5 = typeof body.path === "string" ? body.path : "";
   const status = stringValue(body.status, 80);
   const baseRevision = typeof body.baseRevision === "number" && Number.isInteger(body.baseRevision) ? body.baseRevision : void 0;
   if (!isVault(vault) || !path5 || !status) return c.json({ ok: false, error: "valid vault, path, and status are required" }, 400);
-  const current = await readMemory("getTool", { vault, path: path5 }, token2);
+  const current = await readMemory("getTool", { vault, path: path5 }, token3);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   const result = await memoryCall("putTool", {
     vault,
@@ -26599,13 +26614,13 @@ vaultApp.post("/api/records/transition", async (c) => {
     content: current.note.content,
     props: { ...current.note.props ?? {}, status },
     baseRevision: baseRevision ?? current.note.revision
-  }, token2);
+  }, token3);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/records/update", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token2 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token2)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token3 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token3)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = body.vault;
   const path5 = stringValue(body.path, 320);
   const title = typeof body.title === "string" ? stringValue(body.title, 320) : void 0;
@@ -26615,7 +26630,7 @@ vaultApp.post("/api/records/update", async (c) => {
   if (!isVault(vault) || !path5 || body.title !== void 0 && !title || body.props !== void 0 && !props) {
     return c.json({ ok: false, error: "valid vault, path, and optional record fields are required" }, 400);
   }
-  const current = await readMemory("getTool", { vault, path: path5 }, token2);
+  const current = await readMemory("getTool", { vault, path: path5 }, token3);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   const nextProps = normalizeRelationshipProps(vault, { ...current.note.props ?? {}, ...props ?? {} });
   const validationError = validateNewRecord(vault, nextProps);
@@ -26627,18 +26642,18 @@ vaultApp.post("/api/records/update", async (c) => {
     content: content ?? current.note.content,
     props: nextProps,
     baseRevision: baseRevision ?? current.note.revision
-  }, token2);
+  }, token3);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.delete("/api/records", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token2 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token2)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token3 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token3)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = body.vault;
   const path5 = stringValue(body.path, 320);
   const baseRevision = typeof body.baseRevision === "number" && Number.isInteger(body.baseRevision) ? body.baseRevision : void 0;
   if (vault !== "Tasks" || !path5) return c.json({ ok: false, error: "only a valid task record can be deleted" }, 400);
-  const current = await readMemory("getTool", { vault, path: path5 }, token2);
+  const current = await readMemory("getTool", { vault, path: path5 }, token3);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   if (!["task", "milestone"].includes(typeof current.note.props?.type === "string" ? current.note.props.type : defaultType("Tasks"))) {
     return c.json({ ok: false, error: "only task records can be deleted" }, 400);
@@ -26647,13 +26662,13 @@ vaultApp.delete("/api/records", async (c) => {
     vault,
     path: path5,
     baseRevision: baseRevision ?? current.note.revision
-  }, token2);
+  }, token3);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/communications/review", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token2 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token2)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token3 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token3)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const path5 = stringValue(body.path, 320);
   const action = stringValue(body.action, 24);
   const title = typeof body.title === "string" ? stringValue(body.title, 320) : void 0;
@@ -26664,7 +26679,7 @@ vaultApp.post("/api/communications/review", async (c) => {
   if (!path5 || !normalizedAction || !["approve", "deny", "edit"].includes(normalizedAction) || body.title !== void 0 && !title) {
     return c.json({ ok: false, error: "valid path, action, and optional draft fields are required" }, 400);
   }
-  const current = await readMemory("getTool", { vault: "Communications", path: path5 }, token2);
+  const current = await readMemory("getTool", { vault: "Communications", path: path5 }, token3);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   if (current.note.props?.type !== "email") return c.json({ ok: false, error: "only email communications can be reviewed" }, 400);
   const reviewed = normalizedAction === "approve" || normalizedAction === "deny";
@@ -26688,13 +26703,13 @@ vaultApp.post("/api/communications/review", async (c) => {
     content: content ?? current.note.content,
     props,
     baseRevision: baseRevision ?? current.note.revision
-  }, token2);
+  }, token3);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/activity", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token2 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token2)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token3 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token3)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const title = stringValue(body.title, 320);
   const content = typeof body.content === "string" && body.content.length <= 2e4 ? body.content : "";
   const props = propsValue(body.props) ?? {};
@@ -26704,7 +26719,7 @@ vaultApp.post("/api/activity", async (c) => {
     return c.json({ ok: false, error: "Activities require at least one canonical People reference in person_refs" }, 400);
   }
   for (const ref of personRefs) {
-    const person = await readMemory("getTool", { vault: "People", path: ref.replace(/^People::/, "") }, token2);
+    const person = await readMemory("getTool", { vault: "People", path: ref.replace(/^People::/, "") }, token3);
     if (!person.ok || !person.note || !["person", "organization"].includes(String(person.note.props?.type ?? ""))) {
       return c.json({ ok: false, error: `Activity person reference is not a known People record: ${ref}` }, 400);
     }
@@ -26732,37 +26747,37 @@ vaultApp.post("/api/activity", async (c) => {
       ...props,
       person_refs: personRefs
     }
-  }, token2);
+  }, token3);
   return c.json(result, result.ok ? 200 : 502);
 });
 
 // src/api/schedule-routes.ts
 import { Hono as Hono26 } from "hono";
 var scheduleApp = new Hono26();
-function tokenOk2(token2) {
-  return !!token2 && token2.startsWith("mk_") && token2.length > 10;
+function tokenOk2(token3) {
+  return !!token3 && token3.startsWith("mk_") && token3.length > 10;
 }
 function jsonError2(message, status = 400) {
   return new Response(JSON.stringify({ ok: false, error: message }), { status, headers: { "content-type": "application/json" } });
 }
 scheduleApp.get("/api/status", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk2(token2)) return jsonError2("missing or malformed token", 401);
-  const r = await memoryCall("getScheduleStatusTool", {}, token2);
+  const token3 = c.req.query("token");
+  if (!tokenOk2(token3)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("getScheduleStatusTool", {}, token3);
   return c.json(r);
 });
 scheduleApp.get("/api/vaults", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk2(token2)) return jsonError2("missing or malformed token", 401);
-  const r = await memoryCall("listVaultsTool", {}, token2);
+  const token3 = c.req.query("token");
+  if (!tokenOk2(token3)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("listVaultsTool", {}, token3);
   if (!r.ok) return c.json(r);
   const vaults = (r.vaults ?? []).filter((v) => v.kind !== "channel");
   return c.json({ ok: true, vaults });
 });
 scheduleApp.get("/api/actions", async (c) => {
-  const token2 = c.req.query("token");
-  if (!tokenOk2(token2)) return jsonError2("missing or malformed token", 401);
-  const r = await memoryCall("listScheduledActionsTool", {}, token2);
+  const token3 = c.req.query("token");
+  if (!tokenOk2(token3)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("listScheduledActionsTool", {}, token3);
   return c.json(r);
 });
 scheduleApp.post("/api/propose", async (c) => {
@@ -26798,13 +26813,13 @@ scheduleApp.post("/api/actions/:id/delete", async (c) => {
   return c.json(r);
 });
 scheduleApp.get("/:token", (c) => {
-  const token2 = c.req.param("token");
-  if (!tokenOk2(token2)) {
+  const token3 = c.req.param("token");
+  if (!tokenOk2(token3)) {
     return c.html(`<!doctype html><html><body style="font-family:system-ui;padding:40px;color:#3D3548"><h2>This automations link isn't valid.</h2><p>Ask the AI to run get-schedule-link again, or revoke-schedule-link then get-schedule-link if you think it was compromised.</p></body></html>`, 401);
   }
-  return c.html(renderSchedulePage(token2));
+  return c.html(renderSchedulePage(token3));
 });
-function renderSchedulePage(token2) {
+function renderSchedulePage(token3) {
   return `<!doctype html>
 <html>
 <head>
@@ -26902,7 +26917,7 @@ function renderSchedulePage(token2) {
 </div>
 
 <script>
-const TOKEN = ${JSON.stringify(token2)};
+const TOKEN = ${JSON.stringify(token3)};
 const state = { actions: [], vaults: [] };
 
 function api(path, opts) { return fetch('/schedule' + path, opts).then(r => r.json()); }
@@ -27145,8 +27160,8 @@ function supportThreadToken(customerEmail, normalizedSubject) {
   return shortHash(`${customerEmail.trim().toLowerCase()}
 ${normalizeSupportSubject(normalizedSubject).toLowerCase()}`);
 }
-function supportThreadAddress(token2, receivingDomain) {
-  const safeToken = token2.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
+function supportThreadAddress(token3, receivingDomain) {
+  const safeToken = token3.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
   const domain = receivingDomain.trim().toLowerCase();
   if (!safeToken || !/^[a-z0-9.-]+\.[a-z]{2,}$/i.test(domain)) throw new Error("invalid support thread address");
   return `support+${safeToken}@${domain}`;
@@ -27173,8 +27188,8 @@ function personPath(identity) {
   const local = identity.email.split("@")[0];
   return `contacts/${safePathPart(identity.name === identity.email ? local : identity.name)}-${shortHash(identity.email, 12)}`;
 }
-function issuePath(token2) {
-  return `support/threads/${token2}`;
+function issuePath(token3) {
+  return `support/threads/${token3}`;
 }
 function communicationPath(email) {
   const date = cleanLine(email.created_at, (/* @__PURE__ */ new Date()).toISOString()).slice(0, 10).replace(/[^0-9-]/g, "");
@@ -27358,8 +27373,8 @@ function buildIssueContent(email, customer, personPathValue, threadAddressValue)
     `- Person: ${noteRef("People", personPathValue)}`
   ].join("\n");
 }
-async function findOrCreateIssue(memoryKey, email, customer, personPathValue, token2, threadAddressValue) {
-  const path5 = issuePath(token2);
+async function findOrCreateIssue(memoryKey, email, customer, personPathValue, token3, threadAddressValue) {
+  const path5 = issuePath(token3);
   const existing = await getNote(memoryKey, "Issues", path5);
   if (existing) return existing;
   const subject = normalizeSupportSubject(email.subject);
@@ -27369,7 +27384,7 @@ async function findOrCreateIssue(memoryKey, email, customer, personPathValue, to
     path: path5,
     title: `Support thread \u2014 ${subject} \u2014 ${customer.email}`.slice(0, 240),
     content: buildIssueContent(email, customer, personPathValue, threadAddressValue),
-    source: `resend:thread:${token2}`,
+    source: `resend:thread:${token3}`,
     type: "user_friction",
     tagCandidates: ISSUE_TAGS,
     props: {
@@ -27378,7 +27393,7 @@ async function findOrCreateIssue(memoryKey, email, customer, personPathValue, to
       summary,
       pinned: false,
       source_type: "thread",
-      source_ref: `resend:thread:${token2}`,
+      source_ref: `resend:thread:${token3}`,
       related: [],
       related_vault_notes: [noteRef("People", personPathValue)],
       embed: true,
@@ -27393,7 +27408,7 @@ async function findOrCreateIssue(memoryKey, email, customer, personPathValue, to
       customer_email: customer.email,
       customer_name: customer.name,
       normalized_subject: subject,
-      thread_token: token2,
+      thread_token: token3,
       thread_address: threadAddressValue,
       communication_refs: [],
       message_count: 0,
@@ -27436,7 +27451,7 @@ function buildCommunicationContent(email, customer, direction, personPathValue,
     ...parentPath ? [`- Previous message: [[${parentPath}]]`] : []
   ].join("\n");
 }
-async function captureCommunication(memoryKey, email, customer, direction, personPathValue, issuePathValue, token2, parentPath) {
+async function captureCommunication(memoryKey, email, customer, direction, personPathValue, issuePathValue, token3, parentPath) {
   const path5 = communicationPath(email);
   const existing = await getNote(memoryKey, "Communication", path5);
   if (existing) return existing;
@@ -27475,8 +27490,8 @@ async function captureCommunication(memoryKey, email, customer, direction, perso
       provider: "resend",
       provider_connection_ref: "resend:updates.mcpscraper.dev",
       provider_message_ref: providerMessageRef,
-      provider_thread_ref: token2,
-      thread_ref: token2,
+      provider_thread_ref: token3,
+      thread_ref: token3,
       issue_ref: issuePathValue,
       sender_email: supportSender(email)?.email ?? email.from,
       recipient_emails: email.to ?? [],
@@ -27536,8 +27551,8 @@ async function updateIssueThread(memoryKey, issuePathValue, email, communication
     if (!result.conflict || attempt === 1) throw new Error(result.error ?? "support thread issue update failed");
   }
 }
-async function getSupportThreadByToken(memoryKey, token2) {
-  const safeToken = token2.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
+async function getSupportThreadByToken(memoryKey, token3) {
+  const safeToken = token3.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
   if (safeToken.length !== 24) return null;
   const path5 = issuePath(safeToken);
   const issue = await getNote(memoryKey, "Issues", path5);
@@ -27565,8 +27580,8 @@ async function captureSupportMessage(memoryKey, email, options) {
   const customer = options.customer ?? supportSender(email);
   if (!customer) throw new Error("support sender does not contain a usable email address");
   const normalizedSubject = options.existingThread?.normalizedSubject ?? normalizeSupportSubject(email.subject);
-  const token2 = options.existingThread?.threadToken ?? supportThreadToken(customer.email, normalizedSubject);
-  const threadAddressValue = options.existingThread?.threadAddress ?? supportThreadAddress(token2, options.receivingDomain);
+  const token3 = options.existingThread?.threadToken ?? supportThreadToken(customer.email, normalizedSubject);
+  const threadAddressValue = options.existingThread?.threadAddress ?? supportThreadAddress(token3, options.receivingDomain);
   const person = options.existingThread ? await getNote(memoryKey, "People", options.existingThread.personPath) : await findOrCreatePerson(memoryKey, customer, email.created_at);
   if (!person) throw new Error("support person could not be resolved");
   const issue = options.existingThread?.issue ?? await findOrCreateIssue(
@@ -27574,7 +27589,7 @@ async function captureSupportMessage(memoryKey, email, options) {
     email,
     customer,
     person.path,
-    token2,
+    token3,
     threadAddressValue
   );
   const parentPath = typeof issue.props?.last_communication_ref === "string" ? issue.props.last_communication_ref : void 0;
@@ -27585,7 +27600,7 @@ async function captureSupportMessage(memoryKey, email, options) {
     options.direction,
     person.path,
     issue.path,
-    token2,
+    token3,
     parentPath
   );
   await updateIssueThread(memoryKey, issue.path, email, communication.path, options.direction, person.path);
@@ -27594,7 +27609,7 @@ async function captureSupportMessage(memoryKey, email, options) {
     communicationPath: communication.path,
     personPath: person.path,
     parentCommunicationPath: parentPath,
-    threadToken: token2,
+    threadToken: token3,
     threadAddress: threadAddressValue,
     customerEmail: customer.email,
     normalizedSubject,
@@ -27767,8 +27782,8 @@ resendInboundApp.post("/webhooks", async (c) => {
         threadAddress: captured.threadAddress
       });
     }
-    const token2 = extractSupportThreadToken(receivedEvent.data.to ?? [], ...domains);
-    const thread = token2 ? await getSupportThreadByToken(memoryKey, token2) : null;
+    const token3 = extractSupportThreadToken(receivedEvent.data.to ?? [], ...domains);
+    const thread = token3 ? await getSupportThreadByToken(memoryKey, token3) : null;
     if (!thread) return c.json({ ok: true, route, ignored: true, reason: "unknown-support-thread" });
     const operator = parseMailbox(destination);
     if (operator && sender.email === operator.email) {
@@ -28749,6 +28764,88 @@ function renderEditorialReadingRoom(input, now = /* @__PURE__ */ new Date()) {
     warnings
   };
 }
+function markdownLinkLabel(value) {
+  return value.replace(/[[\]\\]/g, "\\$&");
+}
+function scheduledSourceRef(value) {
+  if (/(?:access_token|auth(?:orization)?|signature|sig|token|key)=/i.test(value)) {
+    throw new Error("Editorial reading-room source references cannot contain credentials or authorization URLs.");
+  }
+  const safe = safeUrl(value);
+  return safe ? `[${markdownLinkLabel(value)}](${safe})` : `\`${value.replace(/`/g, "\\`")}\``;
+}
+function scheduledThemeStyles(config) {
+  const palette = config.theme === "ink" ? ":root{--paper:#151719;--ink:#f5f1e8;--muted:#bbb4a7;--rule:#3b3e42;--accent:#e8a85a}" : config.theme === "warm" ? ":root{--paper:#fff7e8;--ink:#30251c;--muted:#735f4d;--rule:#dfccb4;--accent:#a4492d}" : ":root{--paper:#f8f5ed;--ink:#20211f;--muted:#66645e;--rule:#d6d0c3;--accent:#2f5d50}";
+  const density = config.density === "compact" ? "article p,article li{line-height:1.48}.article-shell{gap:1rem}" : "article p,article li{line-height:1.72}";
+  const sourceRail = config.showSourceRail ? "" : ".article-source{display:none!important}";
+  const generatedAt = config.showGeneratedAt ? "" : "#generated-at{display:none!important}";
+  return `<style id="scheduled-reading-room-config">${palette}${density}${sourceRail}${generatedAt}</style>`;
+}
+function renderEditorialReadingRoomV1(input, config, now = /* @__PURE__ */ new Date()) {
+  const filesMarkdown = (input.files ?? []).length === 0 ? "" : [
+    "## Shared files",
+    "",
+    ...(input.files ?? []).map((file) => {
+      const detail = [
+        file.sharedBy ? `shared by ${file.sharedBy}` : "",
+        file.sharedAt ? `at ${file.sharedAt}` : "",
+        file.mimeType ? `(${file.mimeType})` : ""
+      ].filter(Boolean).join(" ");
+      return `- **${file.label.replace(/\*/g, "\\*")}**${detail ? ` \u2014 ${detail}` : ""}: ${scheduledSourceRef(file.sourceRef)}`;
+    })
+  ].join("\n");
+  const siteSlug = slugify2(`${config.brandName ?? input.generatedFor}-${input.title}`) || "scheduled-reading-room";
+  const legacyInput = {
+    site: {
+      slug: siteSlug,
+      title: input.title,
+      product: config.brandName ?? input.generatedFor,
+      edition: "Scheduled result",
+      editionLabel: "Generated report",
+      issueLabel: config.showGeneratedAt ? now.toISOString() : "Current result",
+      eyebrow: "A source-labelled scheduled result",
+      heroTitle: input.title,
+      startLabel: "Start reading"
+    },
+    deck: input.dek ?? `Prepared for ${input.generatedFor}.`,
+    articles: input.sections.map((section, index) => {
+      const provenance = [
+        "",
+        "## Sources",
+        "",
+        ...section.sourceLabels.map((label) => `- ${label}`),
+        ...section.sourceRefs.map((ref) => `- ${scheduledSourceRef(ref)}`)
+      ].join("\n");
+      const withFiles = index === input.sections.length - 1 && filesMarkdown ? `${section.markdown}
+
+${provenance}
+
+${filesMarkdown}` : `${section.markdown}
+
+${provenance}`;
+      return {
+        slug: section.id,
+        category: "Report",
+        kicker: section.summary ?? "Scheduled result",
+        order: index + 1,
+        title: section.title,
+        summary: section.summary ?? section.title,
+        sourceType: "Scheduled result",
+        sourceLabel: section.sourceLabels.join(" \xB7 ").slice(0, 500),
+        markdown: withFiles
+      };
+    }),
+    filename: `${siteSlug}.html`
+  };
+  const rendered = renderEditorialReadingRoom(legacyInput, now);
+  const html = rendered.html.replace("</head>", `${scheduledThemeStyles(config)}</head>`).replace("<body", `<body data-scheduled-renderer="editorial_reading_room_v1" data-theme="${config.theme}" data-density="${config.density}"`);
+  return {
+    ...rendered,
+    html,
+    bytes: Buffer.byteLength(html),
+    sha256: createHash10("sha256").update(html).digest("hex")
+  };
+}
 
 // src/editorial-reading-room/artifacts.ts
 var EDITORIAL_READING_ROOM_ARTIFACT_PREFIX = "editorial-reading-rooms/";
@@ -28864,6 +28961,878 @@ editorialReadingRoomApp.post("/renew-download", async (c) => {
   });
 });
 
+// src/api/scheduled-result-routes.ts
+import { Hono as Hono30 } from "hono";
+import { z as z30 } from "zod";
+
+// src/api/scheduled-artifact-owner.ts
+import { createHash as createHash11 } from "crypto";
+function scheduledArtifactOwnerIdForApiKey(apiKey) {
+  return createHash11("sha256").update(apiKey).digest("hex").slice(0, 24);
+}
+
+// src/api/scheduled-run-view-links.ts
+import { createHash as createHash12, randomBytes as randomBytes3, randomUUID as randomUUID13 } from "crypto";
+var schemaReady2 = false;
+async function ensureScheduledRunViewLinksSchema() {
+  if (schemaReady2) return;
+  const db = getDb();
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS scheduled_run_view_links (
+      share_id      TEXT PRIMARY KEY,
+      owner_id      TEXT NOT NULL,
+      run_id        TEXT NOT NULL,
+      artifact_id   TEXT NOT NULL,
+      title         TEXT NOT NULL,
+      summary       TEXT NOT NULL,
+      renderer_key  TEXT NOT NULL CHECK (renderer_key = 'editorial_reading_room_v1'),
+      token_hash    TEXT NOT NULL UNIQUE,
+      expires_at    TEXT NOT NULL,
+      revoked_at    TEXT,
+      created_at    TEXT NOT NULL
+    )
+  `);
+  await db.execute(`
+    CREATE INDEX IF NOT EXISTS scheduled_run_view_links_owner_run
+    ON scheduled_run_view_links(owner_id, run_id, created_at DESC)
+  `);
+  await db.execute(`
+    CREATE INDEX IF NOT EXISTS scheduled_run_view_links_expiry
+    ON scheduled_run_view_links(expires_at, revoked_at)
+  `);
+  schemaReady2 = true;
+}
+function tokenHash2(token3) {
+  return createHash12("sha256").update(token3).digest("hex");
+}
+function mapRow(row) {
+  return {
+    shareId: String(row.share_id),
+    ownerId: String(row.owner_id),
+    runId: String(row.run_id),
+    artifactId: String(row.artifact_id),
+    title: String(row.title),
+    summary: String(row.summary),
+    rendererKey: "editorial_reading_room_v1",
+    tokenHash: String(row.token_hash),
+    expiresAt: String(row.expires_at),
+    revokedAt: row.revoked_at == null ? null : String(row.revoked_at),
+    createdAt: String(row.created_at)
+  };
+}
+async function createScheduledRunViewLink(input) {
+  await ensureScheduledRunViewLinksSchema();
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const token3 = randomBytes3(32).toString("base64url");
+  const record = {
+    shareId: randomUUID13(),
+    ownerId: input.ownerId,
+    runId: input.runId,
+    artifactId: input.artifactId,
+    title: input.title.slice(0, 300),
+    summary: input.summary.slice(0, 2e3),
+    rendererKey: input.rendererKey,
+    tokenHash: tokenHash2(token3),
+    expiresAt: new Date(now.getTime() + input.expiresInDays * 24 * 60 * 60 * 1e3).toISOString(),
+    revokedAt: null,
+    createdAt: now.toISOString()
+  };
+  await getDb().execute({
+    sql: `
+      INSERT INTO scheduled_run_view_links (
+        share_id, owner_id, run_id, artifact_id, title, summary,
+        renderer_key, token_hash, expires_at, revoked_at, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?)
+    `,
+    args: [
+      record.shareId,
+      record.ownerId,
+      record.runId,
+      record.artifactId,
+      record.title,
+      record.summary,
+      record.rendererKey,
+      record.tokenHash,
+      record.expiresAt,
+      record.createdAt
+    ]
+  });
+  return { record, token: token3 };
+}
+async function resolveScheduledRunViewLink(token3, now = /* @__PURE__ */ new Date()) {
+  await ensureScheduledRunViewLinksSchema();
+  const result = await getDb().execute({
+    sql: `
+      SELECT share_id, owner_id, run_id, artifact_id, title, summary,
+             renderer_key, token_hash, expires_at, revoked_at, created_at
+      FROM scheduled_run_view_links
+      WHERE token_hash = ?
+        AND revoked_at IS NULL
+        AND expires_at > ?
+      LIMIT 1
+    `,
+    args: [tokenHash2(token3), now.toISOString()]
+  });
+  const row = result.rows[0];
+  return row ? mapRow(row) : null;
+}
+async function revokeScheduledRunViewLink(ownerId, runId, shareId, now = /* @__PURE__ */ new Date()) {
+  await ensureScheduledRunViewLinksSchema();
+  const result = await getDb().execute({
+    sql: `
+      UPDATE scheduled_run_view_links
+      SET revoked_at = COALESCE(revoked_at, ?)
+      WHERE share_id = ? AND owner_id = ? AND run_id = ?
+    `,
+    args: [now.toISOString(), shareId, ownerId, runId]
+  });
+  return result.rowsAffected > 0;
+}
+
+// src/api/scheduled-result-routes.ts
+var TemplateParamsSchema = z30.object({ templateId: z30.string().uuid() }).strict();
+var RunParamsSchema = z30.object({ runId: z30.string().min(1).max(200) }).strict();
+var ViewLinkParamsSchema = z30.object({
+  runId: z30.string().min(1).max(200),
+  shareId: z30.string().uuid()
+}).strict();
+function apiError(error, errorCode = "invalid_request") {
+  return { ok: false, error, errorCode };
+}
+async function memoryContext(c) {
+  const user = c.get("user");
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  return { user, key, error };
+}
+function memoryStatus(result) {
+  if (result.errorCode === "not_found") return 404;
+  if (result.errorCode === "conflict" || result.errorCode === "template_archived") return 409;
+  if (result.errorCode === "invalid_request") return 400;
+  return 502;
+}
+function safeMemoryFailure(result) {
+  const errorCode = typeof result.errorCode === "string" ? result.errorCode : "internal_error";
+  const messages = {
+    invalid_request: "The scheduled-results request is invalid.",
+    not_found: "The requested scheduled-results record was not found.",
+    conflict: "The scheduled-results request conflicts with the current record.",
+    template_archived: "The selected artifact template is archived."
+  };
+  return apiError(
+    messages[errorCode] ?? "Scheduled results are temporarily unavailable.",
+    errorCode in messages ? errorCode : "internal_error"
+  );
+}
+var scheduledResultApp = new Hono30();
+scheduledResultApp.use("/artifact-templates", createApiKeyAuth());
+scheduledResultApp.use("/artifact-templates/*", createApiKeyAuth());
+scheduledResultApp.use("/schedule-runs", createApiKeyAuth());
+scheduledResultApp.use("/schedule-runs/*", createApiKeyAuth());
+scheduledResultApp.get("/artifact-templates", async (c) => {
+  const status = c.req.query("status") ?? "active";
+  if (!["active", "archived", "all"].includes(status)) {
+    return c.json(apiError("status must be active, archived, or all."), 400);
+  }
+  const { key, error } = await memoryContext(c);
+  if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+  const result = await memoryCall("listArtifactTemplatesTool", { status }, key);
+  if (!result.ok) return c.json(safeMemoryFailure(result), memoryStatus(result));
+  c.header("Cache-Control", "private, no-store");
+  return c.json({
+    ...result,
+    presets: Array.isArray(result.presets) ? result.presets : [SCHEDULED_ARTIFACT_TEMPLATE_PRESET]
+  });
+});
+scheduledResultApp.post("/artifact-templates", async (c) => {
+  const parsed = CreateArtifactTemplateInputSchema.safeParse(await c.req.json().catch(() => null));
+  if (!parsed.success) return c.json(apiError("The artifact template is invalid."), 400);
+  const { key, error } = await memoryContext(c);
+  if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+  const result = await memoryCall("createArtifactTemplateTool", parsed.data, key);
+  return c.json(result.ok ? result : safeMemoryFailure(result), result.ok ? 201 : memoryStatus(result));
+});
+scheduledResultApp.get("/artifact-templates/:templateId", async (c) => {
+  const params = TemplateParamsSchema.safeParse(c.req.param());
+  if (!params.success) return c.json(apiError("The template id is invalid."), 400);
+  const { key, error } = await memoryContext(c);
+  if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+  const result = await memoryCall("getArtifactTemplateTool", params.data, key);
+  c.header("Cache-Control", "private, no-store");
+  return c.json(result.ok ? result : safeMemoryFailure(result), result.ok ? 200 : memoryStatus(result));
+});
+scheduledResultApp.put("/artifact-templates/:templateId", async (c) => {
+  const params = TemplateParamsSchema.safeParse(c.req.param());
+  const body = UpdateArtifactTemplateInputSchema.safeParse(await c.req.json().catch(() => null));
+  if (!params.success || !body.success) return c.json(apiError("The template update is invalid."), 400);
+  const { key, error } = await memoryContext(c);
+  if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+  const result = await memoryCall("updateArtifactTemplateTool", { ...params.data, ...body.data }, key);
+  return c.json(result.ok ? result : safeMemoryFailure(result), result.ok ? 200 : memoryStatus(result));
+});
+for (const [path5, archived] of [["archive", true], ["restore", false]]) {
+  scheduledResultApp.post(`/artifact-templates/:templateId/${path5}`, async (c) => {
+    const params = TemplateParamsSchema.safeParse(c.req.param());
+    if (!params.success) return c.json(apiError("The template id is invalid."), 400);
+    const { key, error } = await memoryContext(c);
+    if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+    const result = await memoryCall("archiveArtifactTemplateTool", { ...params.data, archived }, key);
+    return c.json(result.ok ? result : safeMemoryFailure(result), result.ok ? 200 : memoryStatus(result));
+  });
+}
+scheduledResultApp.get("/schedule-runs", async (c) => {
+  const parsed = ListScheduledRunsQuerySchema.safeParse(c.req.query());
+  if (!parsed.success) return c.json(apiError("The scheduled result filters are invalid."), 400);
+  const { key, error } = await memoryContext(c);
+  if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+  const result = await memoryCall("listScheduledRunsTool", parsed.data, key);
+  c.header("Cache-Control", "private, no-store");
+  return c.json(result.ok ? result : safeMemoryFailure(result), result.ok ? 200 : memoryStatus(result));
+});
+scheduledResultApp.get("/schedule-runs/:runId", async (c) => {
+  const params = RunParamsSchema.safeParse(c.req.param());
+  if (!params.success) return c.json(apiError("The run id is invalid."), 400);
+  const { key, error } = await memoryContext(c);
+  if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+  const result = await memoryCall("getScheduledRunTool", params.data, key);
+  c.header("Cache-Control", "private, no-store");
+  return c.json(result.ok ? result : safeMemoryFailure(result), result.ok ? 200 : memoryStatus(result));
+});
+for (const [path5, upstreamName, input] of [
+  ["open", "markScheduledRunOpenedTool", {}],
+  ["unopen", "markScheduledRunUnopenedTool", {}],
+  ["archive", "archiveScheduledRunTool", { archived: true }],
+  ["restore", "archiveScheduledRunTool", { archived: false }]
+]) {
+  scheduledResultApp.post(`/schedule-runs/:runId/${path5}`, async (c) => {
+    const params = RunParamsSchema.safeParse(c.req.param());
+    if (!params.success) return c.json(apiError("The run id is invalid."), 400);
+    const { key, error } = await memoryContext(c);
+    if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+    const result = await memoryCall(upstreamName, { ...params.data, ...input }, key);
+    c.header("Cache-Control", "private, no-store");
+    return c.json(result.ok ? result : safeMemoryFailure(result), result.ok ? 200 : memoryStatus(result));
+  });
+}
+scheduledResultApp.post("/schedule-runs/:runId/view-links", async (c) => {
+  const params = RunParamsSchema.safeParse(c.req.param());
+  const body = CreateScheduledRunViewLinkInputSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!params.success || !body.success) return c.json(apiError("The view-link request is invalid."), 400);
+  const { user, key, error } = await memoryContext(c);
+  if (!key) return c.json(apiError(error ?? "Memory is unavailable.", "internal_error"), 503);
+  const rawResult = await memoryCall("getScheduledRunTool", params.data, key);
+  const result = GetScheduledRunResponseSchema.safeParse(rawResult);
+  if (!result.success) return c.json(apiError("The scheduled result was not found.", "not_found"), 404);
+  const artifact = result.data.run.artifactOutputs.find((output) => output.artifactId === body.data.artifactId);
+  if (!artifact) return c.json(apiError("The scheduled result artifact was not found.", "not_found"), 404);
+  const ownerId = scheduledArtifactOwnerIdForApiKey(user.api_key);
+  const { record, token: token3 } = await createScheduledRunViewLink({
+    ownerId,
+    runId: result.data.run.runId,
+    artifactId: artifact.artifactId,
+    title: artifact.title,
+    summary: result.data.run.summary,
+    rendererKey: artifact.rendererKey,
+    expiresInDays: body.data.expiresInDays
+  });
+  const origin = process.env.APP_ORIGIN?.trim() || "https://mcpscraper.dev";
+  return c.json({
+    ok: true,
+    shareId: record.shareId,
+    runId: record.runId,
+    artifactId: record.artifactId,
+    url: `${origin.replace(/\/$/, "")}/view/scheduled-run/${token3}`,
+    expiresAt: record.expiresAt,
+    createdAt: record.createdAt
+  }, 201);
+});
+scheduledResultApp.delete("/schedule-runs/:runId/view-links/:shareId", async (c) => {
+  const params = ViewLinkParamsSchema.safeParse(c.req.param());
+  if (!params.success) return c.json(apiError("The view-link id is invalid."), 400);
+  const user = c.get("user");
+  const revoked = await revokeScheduledRunViewLink(
+    scheduledArtifactOwnerIdForApiKey(user.api_key),
+    params.data.runId,
+    params.data.shareId
+  );
+  if (!revoked) return c.json(apiError("The view link was not found.", "not_found"), 404);
+  return c.json({ ok: true, revoked: true });
+});
+
+// src/api/public-scheduled-result-routes.ts
+import { Hono as Hono31 } from "hono";
+
+// src/scheduled-artifacts/scheduled-run-artifact-store.ts
+import { createHash as createHash13 } from "crypto";
+var SCHEDULED_RUN_ARTIFACT_PREFIX = "scheduled-run-artifacts/";
+var SCHEDULED_RUN_ARTIFACT_DOWNLOAD_TTL_MS = 15 * 60 * 1e3;
+var SCHEDULED_RUN_ARTIFACT_MAX_BYTES = 2e6;
+function token2() {
+  return process.env.SCHEDULED_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.PRIVATE_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_BLOB_READ_WRITE_TOKEN?.trim() || null;
+}
+function policy2() {
+  return {
+    prefix: SCHEDULED_RUN_ARTIFACT_PREFIX,
+    artifactTtlMs: null,
+    downloadTtlMs: SCHEDULED_RUN_ARTIFACT_DOWNLOAD_TTL_MS,
+    token: token2()
+  };
+}
+function runStorageSegment(runId) {
+  return /^[a-zA-Z0-9_-]{1,160}$/.test(runId) ? runId : `run-${createHash13("sha256").update(runId).digest("hex").slice(0, 32)}`;
+}
+async function createScheduledRunArtifact(args) {
+  if (args.rendered.bytes > SCHEDULED_RUN_ARTIFACT_MAX_BYTES) {
+    throw new Error("Scheduled artifact HTML must be 2,000,000 bytes or fewer.");
+  }
+  const stored = await createPrivateArtifact({
+    policy: policy2(),
+    ownerId: args.request.ownerId,
+    scopeSegments: [runStorageSegment(args.request.runId)],
+    artifactKey: `${args.rendered.sha256.slice(0, 16)}-${args.rendered.filename}`,
+    createdAt: args.rendered.generatedAt,
+    filename: args.rendered.filename,
+    contentType: "text/html",
+    content: args.rendered.html
+  });
+  return {
+    artifactId: stored.artifactId,
+    templateId: args.request.templateId,
+    templateVersionId: args.request.templateVersionId,
+    rendererKey: args.request.rendererKey,
+    rendererVersion: args.request.rendererVersion,
+    mimeType: "text/html",
+    title: args.rendered.title,
+    bytes: stored.bytes,
+    sha256: stored.sha256,
+    createdAt: args.rendered.generatedAt,
+    viewerPath: `/scheduled-actions/runs/${encodeURIComponent(args.request.runId)}`
+  };
+}
+async function readScheduledRunArtifact(args) {
+  if (!args.artifactId.startsWith(`${SCHEDULED_RUN_ARTIFACT_PREFIX}${args.ownerId}/`)) return null;
+  const window2 = await readPrivateArtifactWindow({
+    policy: policy2(),
+    artifactId: args.artifactId,
+    offset: 0,
+    maxBytes: SCHEDULED_RUN_ARTIFACT_MAX_BYTES + 1
+  });
+  if (!window2 || window2.nextOffset !== null || window2.totalBytes > SCHEDULED_RUN_ARTIFACT_MAX_BYTES) return null;
+  return window2.text;
+}
+
+// src/api/public-scheduled-result-routes.ts
+var publicScheduledResultApp = new Hono31();
+function allowedFrameAncestors() {
+  const configured = (process.env.SCHEDULED_ARTIFACT_FRAME_ANCESTORS ?? "").split(",").map((value) => value.trim()).filter((value) => /^https?:\/\/[^/\s]+$/.test(value));
+  const origins = configured.length ? configured : ["https://mcpscraper.dev", "https://www.mcpscraper.dev"];
+  return origins.join(" ");
+}
+function publicHeaders(c, content = false) {
+  c.header("Cache-Control", "private, no-store");
+  c.header("Referrer-Policy", "no-referrer");
+  c.header("X-Robots-Tag", "noindex, nofollow");
+  if (content) {
+    c.header("Content-Security-Policy", [
+      "default-src 'none'",
+      "script-src 'unsafe-inline'",
+      "style-src 'unsafe-inline'",
+      "img-src https: data:",
+      "font-src data:",
+      "connect-src 'none'",
+      `frame-ancestors ${allowedFrameAncestors()}`,
+      "base-uri 'none'",
+      "form-action 'none'"
+    ].join("; "));
+  }
+}
+function unavailableJson(c) {
+  publicHeaders(c);
+  return c.json({
+    ok: false,
+    error: "This link is no longer available.",
+    errorCode: "view_link_unavailable"
+  }, 404);
+}
+function unavailableHtml() {
+  return '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Link unavailable</title><style>body{margin:0;min-height:100vh;display:grid;place-items:center;font:16px/1.5 system-ui;background:#f8f5ed;color:#20211f}main{max-width:34rem;padding:2rem}h1{font-size:1.5rem}</style></head><body><main><h1>This link is no longer available</h1><p>Ask the report owner for a new view link.</p></main></body></html>';
+}
+publicScheduledResultApp.get("/scheduled-run-view-links/:token", async (c) => {
+  const parsed = PublicScheduledRunTokenSchema.safeParse(c.req.param());
+  if (!parsed.success) return unavailableJson(c);
+  const grant = await resolveScheduledRunViewLink(parsed.data.token);
+  if (!grant) return unavailableJson(c);
+  publicHeaders(c);
+  const requestUrl = new URL(c.req.url);
+  return c.json({
+    ok: true,
+    title: grant.title,
+    summary: grant.summary,
+    rendererKey: grant.rendererKey,
+    contentUrl: `${requestUrl.origin}/public/scheduled-run-view-links/${parsed.data.token}/content`,
+    expiresAt: grant.expiresAt
+  });
+});
+publicScheduledResultApp.get("/scheduled-run-view-links/:token/content", async (c) => {
+  publicHeaders(c, true);
+  const parsed = PublicScheduledRunTokenSchema.safeParse(c.req.param());
+  const grant = parsed.success ? await resolveScheduledRunViewLink(parsed.data.token) : null;
+  const html = grant ? await readScheduledRunArtifact({ ownerId: grant.ownerId, artifactId: grant.artifactId }) : null;
+  if (!html) return c.html(unavailableHtml(), 404);
+  return c.body(html, 200, { "Content-Type": "text/html; charset=utf-8" });
+});
+
+// src/api/scheduled-artifact-internal-routes.ts
+import { Hono as Hono32 } from "hono";
+
+// src/api/scheduler-integration-auth.ts
+import { createHash as createHash14, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
+
+// src/api/service-connections.ts
+import { randomUUID as randomUUID14 } from "crypto";
+var schemaReady3 = null;
+var schemaDb2 = null;
+function ensureServiceConnectionsSchema() {
+  const currentDb = getDb();
+  if (schemaReady3 && schemaDb2 === currentDb) return schemaReady3;
+  schemaDb2 = currentDb;
+  schemaReady3 = (async () => {
+    const db = currentDb;
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connections (
+        id                         TEXT PRIMARY KEY,
+        user_id                    INTEGER NOT NULL REFERENCES users(id),
+        provider_config_key        TEXT NOT NULL,
+        provider                   TEXT,
+        transport                  TEXT NOT NULL,
+        upstream_connection_id     TEXT,
+        label                      TEXT,
+        lifecycle_status           TEXT NOT NULL DEFAULT 'pending',
+        operational_status         TEXT NOT NULL DEFAULT 'unknown',
+        reconnect_required         INTEGER NOT NULL DEFAULT 0,
+        actions_enabled            INTEGER NOT NULL DEFAULT 0,
+        read_tools_json            TEXT NOT NULL DEFAULT '[]',
+        action_tools_json          TEXT NOT NULL DEFAULT '[]',
+        tool_revision              TEXT,
+        last_checked_at            TEXT,
+        last_successful_call_at    TEXT,
+        last_failure_at            TEXT,
+        last_failure_code          TEXT,
+        last_failure_retryable     INTEGER,
+        consecutive_failures       INTEGER NOT NULL DEFAULT 0,
+        vault_name                 TEXT,
+        table_name                 TEXT,
+        legacy_owner_identity      TEXT,
+        created_at                 TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at                 TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(user_id, provider_config_key, upstream_connection_id)
+      )
+    `);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_user_updated ON service_connections(user_id, updated_at DESC)`);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_upstream ON service_connections(provider_config_key, upstream_connection_id)`);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connection_health_events (
+        id                    TEXT PRIMARY KEY,
+        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
+        operational_status    TEXT NOT NULL,
+        failure_code          TEXT,
+        retryable             INTEGER,
+        evidence_source       TEXT NOT NULL,
+        created_at            TEXT NOT NULL DEFAULT (datetime('now'))
+      )
+    `);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connection_health_events_connection ON service_connection_health_events(connection_id, created_at DESC)`);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connection_action_audit (
+        id                    TEXT PRIMARY KEY,
+        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
+        user_id               INTEGER NOT NULL REFERENCES users(id),
+        tool                  TEXT NOT NULL,
+        request_id            TEXT NOT NULL,
+        status                TEXT NOT NULL,
+        error_code            TEXT,
+        created_at            TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(user_id, request_id)
+      )
+    `);
+  })().catch((error) => {
+    schemaReady3 = null;
+    schemaDb2 = null;
+    throw error;
+  });
+  return schemaReady3;
+}
+function parseTools(value) {
+  if (typeof value !== "string") return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function rowToRecord(row) {
+  return {
+    id: String(row.id),
+    userId: Number(row.user_id),
+    providerConfigKey: String(row.provider_config_key),
+    provider: typeof row.provider === "string" ? row.provider : null,
+    transport: row.transport === "remote_mcp" ? "remote_mcp" : "nango",
+    upstreamConnectionId: typeof row.upstream_connection_id === "string" ? row.upstream_connection_id : null,
+    label: typeof row.label === "string" ? row.label : null,
+    lifecycleStatus: String(row.lifecycle_status),
+    operationalStatus: String(row.operational_status),
+    reconnectRequired: Number(row.reconnect_required) === 1,
+    actionsEnabled: Number(row.actions_enabled) === 1,
+    readTools: parseTools(row.read_tools_json),
+    actionTools: parseTools(row.action_tools_json),
+    toolRevision: typeof row.tool_revision === "string" ? row.tool_revision : null,
+    lastCheckedAt: typeof row.last_checked_at === "string" ? row.last_checked_at : null,
+    lastSuccessfulCallAt: typeof row.last_successful_call_at === "string" ? row.last_successful_call_at : null,
+    lastFailureAt: typeof row.last_failure_at === "string" ? row.last_failure_at : null,
+    lastFailureCode: typeof row.last_failure_code === "string" ? row.last_failure_code : null,
+    lastFailureRetryable: row.last_failure_retryable === null || row.last_failure_retryable === void 0 ? null : Number(row.last_failure_retryable) === 1,
+    consecutiveFailures: Number(row.consecutive_failures ?? 0),
+    vaultName: typeof row.vault_name === "string" ? row.vault_name : null,
+    tableName: typeof row.table_name === "string" ? row.table_name : null,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+async function userIdForIdentity(identity) {
+  const user = await getUserByEmail(identity.normalize("NFKC").trim().toLowerCase());
+  if (!user) throw new Error("service_connection_user_not_found");
+  return Number(user.id);
+}
+async function reconcileDiscoveredNangoConnections(identity, discovered) {
+  await ensureServiceConnectionsSchema();
+  const db = getDb();
+  const userId = await userIdForIdentity(identity);
+  for (const connection of discovered) {
+    await db.execute({
+      sql: `
+        INSERT INTO service_connections (
+          id, user_id, provider_config_key, provider, transport, upstream_connection_id,
+          label, lifecycle_status, reconnect_required, actions_enabled, legacy_owner_identity, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, 'nango', ?, ?, ?, ?, 1, ?, COALESCE(?, datetime('now')), COALESCE(?, datetime('now')))
+        ON CONFLICT(user_id, provider_config_key, upstream_connection_id) DO UPDATE SET
+          provider = excluded.provider,
+          label = COALESCE(excluded.label, service_connections.label),
+          lifecycle_status = excluded.lifecycle_status,
+          reconnect_required = excluded.reconnect_required,
+          updated_at = excluded.updated_at
+      `,
+      args: [
+        randomUUID14(),
+        userId,
+        connection.providerConfigKey,
+        connection.provider,
+        connection.upstreamConnectionId,
+        connection.label,
+        connection.lifecycleStatus,
+        connection.reconnectRequired ? 1 : 0,
+        identity,
+        connection.createdAt,
+        connection.updatedAt
+      ]
+    });
+  }
+  return listServiceConnections(identity, "nango");
+}
+async function listServiceConnections(identity, transport) {
+  await ensureServiceConnectionsSchema();
+  const userId = await userIdForIdentity(identity);
+  const result = await getDb().execute({
+    sql: `SELECT * FROM service_connections WHERE user_id = ?${transport ? " AND transport = ?" : ""} AND lifecycle_status <> 'disconnected' ORDER BY updated_at DESC`,
+    args: transport ? [userId, transport] : [userId]
+  });
+  return result.rows.map((row) => rowToRecord(row));
+}
+async function getOwnedServiceConnection(identity, connectionId) {
+  await ensureServiceConnectionsSchema();
+  const userId = await userIdForIdentity(identity);
+  const result = await getDb().execute({
+    sql: "SELECT * FROM service_connections WHERE id = ? AND user_id = ? LIMIT 1",
+    args: [connectionId, userId]
+  });
+  const row = result.rows[0];
+  return row ? rowToRecord(row) : null;
+}
+async function updateServiceConnectionTools(connectionId, readTools, actionTools, toolRevision) {
+  await ensureServiceConnectionsSchema();
+  await getDb().execute({
+    sql: `UPDATE service_connections SET read_tools_json = ?, action_tools_json = ?, tool_revision = ?, updated_at = datetime('now') WHERE id = ?`,
+    args: [JSON.stringify(readTools), JSON.stringify(actionTools), toolRevision, connectionId]
+  });
+}
+async function recordServiceConnectionHealth(args) {
+  await ensureServiceConnectionsSchema();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await getDb().execute({
+    sql: `
+      UPDATE service_connections SET
+        operational_status = ?, last_checked_at = ?,
+        last_successful_call_at = CASE WHEN ? = 'available' THEN ? ELSE last_successful_call_at END,
+        last_failure_at = CASE WHEN ? IN ('degraded', 'unavailable') THEN ? ELSE NULL END,
+        last_failure_code = ?, last_failure_retryable = ?,
+        consecutive_failures = CASE WHEN ? = 'available' THEN 0 ELSE consecutive_failures + 1 END,
+        updated_at = datetime('now')
+      WHERE id = ?
+    `,
+    args: [
+      args.operationalStatus,
+      now,
+      args.operationalStatus,
+      now,
+      args.operationalStatus,
+      now,
+      args.failureCode ?? null,
+      args.retryable == null ? null : args.retryable ? 1 : 0,
+      args.operationalStatus,
+      args.connectionId
+    ]
+  });
+  await getDb().execute({
+    sql: `INSERT INTO service_connection_health_events (id, connection_id, operational_status, failure_code, retryable, evidence_source) VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [randomUUID14(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
+  });
+}
+async function setServiceConnectionActions(identity, connectionId, enabled) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection || connection.lifecycleStatus === "disconnected") throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connections SET actions_enabled = ?, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
+    args: [enabled ? 1 : 0, connectionId, connection.userId]
+  });
+  return enabled;
+}
+async function markServiceConnectionDisconnected(identity, connectionId) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connections SET lifecycle_status = 'disconnected', operational_status = 'unknown', reconnect_required = 0, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
+    args: [connectionId, connection.userId]
+  });
+  const remaining = await getDb().execute({
+    sql: `SELECT COUNT(*) AS count FROM service_connections WHERE user_id = ? AND transport = 'nango' AND lifecycle_status = 'connected'`,
+    args: [connection.userId]
+  });
+  return Number(remaining.rows[0]?.count ?? 0);
+}
+async function recordServiceConnectionAction(args) {
+  await ensureServiceConnectionsSchema();
+  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connection_action_audit SET status = ?, error_code = ? WHERE user_id = ? AND request_id = ? AND connection_id = ?`,
+    args: [args.status, args.errorCode ?? null, connection.userId, args.requestId, connection.id]
+  });
+}
+async function claimServiceConnectionAction(args) {
+  await ensureServiceConnectionsSchema();
+  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  const inserted = await getDb().execute({
+    sql: `INSERT OR IGNORE INTO service_connection_action_audit (id, connection_id, user_id, tool, request_id, status) VALUES (?, ?, ?, ?, ?, 'started')`,
+    args: [randomUUID14(), connection.id, connection.userId, args.tool, args.requestId]
+  });
+  if (Number(inserted.rowsAffected ?? 0) === 1) return { claimed: true };
+  const existing = await getDb().execute({
+    sql: `SELECT status, error_code FROM service_connection_action_audit WHERE user_id = ? AND request_id = ? LIMIT 1`,
+    args: [connection.userId, args.requestId]
+  });
+  return {
+    claimed: false,
+    status: String(existing.rows[0]?.status ?? "unknown"),
+    errorCode: typeof existing.rows[0]?.error_code === "string" ? existing.rows[0].error_code : null
+  };
+}
+
+// src/api/scheduler-integration-auth.ts
+var MAX_CLOCK_SKEW_MS = 5 * 60 * 1e3;
+var SchedulerIntegrationAuthError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "SchedulerIntegrationAuthError";
+    this.code = code;
+  }
+};
+function signingSecret() {
+  const secret2 = process.env.SCHEDULER_INTEGRATION_SIGNING_SECRET?.trim();
+  if (!secret2) throw new SchedulerIntegrationAuthError("not_configured");
+  return secret2;
+}
+function schedulerIntegrationSignature(args) {
+  const bodyHash = createHash14("sha256").update(args.body).digest("hex");
+  return createHmac4("sha256", args.secret).update(`${args.method.toUpperCase()}
+${args.path}
+${args.timestamp}
+${args.nonce}
+${bodyHash}`).digest("hex");
+}
+async function claimNonce(nonce, timestampMs) {
+  await ensureServiceConnectionsSchema();
+  await getDb().execute(`
+    CREATE TABLE IF NOT EXISTS service_connection_scheduler_nonces (
+      nonce       TEXT PRIMARY KEY,
+      expires_at  TEXT NOT NULL,
+      created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await getDb().execute(`DELETE FROM service_connection_scheduler_nonces WHERE expires_at < datetime('now')`);
+  try {
+    await getDb().execute({
+      sql: `INSERT INTO service_connection_scheduler_nonces (nonce, expires_at) VALUES (?, ?)`,
+      args: [nonce, new Date(timestampMs + MAX_CLOCK_SKEW_MS).toISOString()]
+    });
+  } catch {
+    throw new SchedulerIntegrationAuthError("replayed_request");
+  }
+}
+async function verifySchedulerIntegrationRequest(request, rawBody) {
+  const timestamp = request.headers.get("x-scheduler-timestamp")?.trim() ?? "";
+  const nonce = request.headers.get("x-scheduler-nonce")?.trim() ?? "";
+  const signature = request.headers.get("x-scheduler-signature")?.trim().toLowerCase() ?? "";
+  const requestId = request.headers.get("x-scheduler-request-id")?.trim() ?? "";
+  const timestampMs = Date.parse(timestamp);
+  if (!timestamp || !nonce || !signature || !requestId || nonce.length > 200 || requestId.length > 200 || !Number.isFinite(timestampMs)) {
+    throw new SchedulerIntegrationAuthError("invalid_signature");
+  }
+  if (Math.abs(Date.now() - timestampMs) > MAX_CLOCK_SKEW_MS) {
+    throw new SchedulerIntegrationAuthError("expired_request");
+  }
+  const expected = schedulerIntegrationSignature({
+    method: request.method,
+    path: new URL(request.url).pathname,
+    timestamp,
+    nonce,
+    body: rawBody,
+    secret: signingSecret()
+  });
+  const suppliedBytes = Buffer.from(signature, "hex");
+  const expectedBytes = Buffer.from(expected, "hex");
+  if (suppliedBytes.length !== expectedBytes.length || !timingSafeEqual3(suppliedBytes, expectedBytes)) {
+    throw new SchedulerIntegrationAuthError("invalid_signature");
+  }
+  await claimNonce(nonce, timestampMs);
+  return { requestId };
+}
+
+// src/scheduled-artifacts/scheduled-artifact-renderer-registry.ts
+var editorialReadingRoomV1 = {
+  rendererKey: "editorial_reading_room_v1",
+  rendererVersion: 1,
+  async render(rawInput, rawConfig, generatedAt) {
+    const input = EditorialReadingRoomV1InputSchema.parse(rawInput);
+    const config = ArtifactTemplateConfigSchema.parse(rawConfig);
+    const rendered = renderEditorialReadingRoomV1(input, config, generatedAt);
+    if (rendered.bytes > 2e6) {
+      throw new Error("Scheduled artifact HTML must be 2,000,000 bytes or fewer.");
+    }
+    return {
+      html: rendered.html,
+      filename: rendered.filename,
+      title: input.title,
+      bytes: rendered.bytes,
+      sha256: rendered.sha256,
+      generatedAt: rendered.generatedAt
+    };
+  }
+};
+var scheduledArtifactRendererRegistry = Object.freeze({
+  "editorial_reading_room_v1:1": editorialReadingRoomV1
+});
+function getScheduledArtifactRenderer(rendererKey, rendererVersion) {
+  return scheduledArtifactRendererRegistry[`${rendererKey}:${rendererVersion}`] ?? null;
+}
+
+// src/api/scheduled-artifact-internal-routes.ts
+var scheduledArtifactInternalApp = new Hono32();
+function errorPayload(errorCode, error, requestId) {
+  return ApiErrorResponseSchema.parse({
+    ok: false,
+    error,
+    errorCode,
+    ...requestId ? { requestId } : {}
+  });
+}
+scheduledArtifactInternalApp.post("/render", async (c) => {
+  const rawBody = await c.req.text();
+  let requestId;
+  try {
+    requestId = (await verifySchedulerIntegrationRequest(c.req.raw, rawBody)).requestId;
+  } catch (error) {
+    const code = error instanceof SchedulerIntegrationAuthError ? error.code : "invalid_signature";
+    console.warn("[scheduled-artifact-render] rejected scheduler request", { code });
+    return c.json(errorPayload("not_found", "Scheduled renderer is unavailable."), 401);
+  }
+  if (process.env.SCHEDULED_ARTIFACTS_V1_ENABLED !== "1") {
+    return c.json(errorPayload("renderer_unavailable", "Scheduled renderer is unavailable.", requestId), 503);
+  }
+  const parsedJson = (() => {
+    try {
+      return JSON.parse(rawBody);
+    } catch {
+      return null;
+    }
+  })();
+  const parsed = InternalScheduledArtifactRenderRequestSchema.safeParse(parsedJson);
+  if (!parsed.success) {
+    return c.json(errorPayload("invalid_request", "The scheduled artifact request is invalid.", requestId), 400);
+  }
+  const startedAt = Date.now();
+  const request = parsed.data;
+  const user = await getUserByEmail(request.identity);
+  const expectedOwnerId = user?.api_key ? scheduledArtifactOwnerIdForApiKey(user.api_key) : null;
+  if (!user || user.key_active !== 1 || !expectedOwnerId || expectedOwnerId !== request.ownerId) {
+    console.warn("[scheduled-artifact-render] identity/owner binding rejected", {
+      requestId,
+      runId: request.runId,
+      identityResolved: Boolean(user),
+      ownerMatched: expectedOwnerId === request.ownerId
+    });
+    return c.json(errorPayload("not_found", "Scheduled renderer is unavailable.", requestId), 404);
+  }
+  const renderer = getScheduledArtifactRenderer(request.rendererKey, request.rendererVersion);
+  if (!renderer) {
+    return c.json(errorPayload("renderer_unavailable", "Scheduled renderer is unavailable.", requestId), 409);
+  }
+  try {
+    const rendered = await renderer.render(request.input, request.config, /* @__PURE__ */ new Date());
+    const artifact = await createScheduledRunArtifact({ request, rendered });
+    console.info("[scheduled-artifact-render] completed", {
+      requestId,
+      runId: request.runId,
+      scheduleId: request.scheduleId,
+      templateId: request.templateId,
+      templateVersionId: request.templateVersionId,
+      rendererKey: request.rendererKey,
+      artifactBytes: artifact.bytes,
+      durationMs: Date.now() - startedAt
+    });
+    return c.json({ ok: true, artifact });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "";
+    const tooLarge = message.includes("2,000,000 bytes");
+    console.error("[scheduled-artifact-render] failed", {
+      requestId,
+      runId: request.runId,
+      scheduleId: request.scheduleId,
+      rendererKey: request.rendererKey,
+      durationMs: Date.now() - startedAt,
+      errorCode: tooLarge ? "artifact_too_large" : "render_failed"
+    });
+    return c.json(
+      errorPayload(
+        tooLarge ? "invalid_request" : "internal_error",
+        tooLarge ? "The scheduled artifact is too large." : "The scheduled artifact could not be rendered.",
+        requestId
+      ),
+      tooLarge ? 413 : 500
+    );
+  }
+});
+
 // src/api/site-audit-worker.ts
 var MAX_CONCURRENT_SITE_AUDIT = 1;
 async function drainSiteAuditQueue(budget) {
@@ -28978,13 +29947,13 @@ async function reconcileSiteExtractSettlements(limit = 25) {
 }
 
 // src/api/page-diff.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { diffLines } from "diff";
 var MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
 var MAX_DIFF_HUNKS = 200;
 var MAX_DIFF_LINES_PER_RESPONSE = 2e3;
 function sha256Hex(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -29506,7 +30475,7 @@ function inferredWaybackCapturedAt(content) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 var CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
 var CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
 var CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS = 256e3;
@@ -29536,7 +30505,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash12("sha256").update(value).digest("hex");
+  return createHash16("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -29756,15 +30725,15 @@ async function importServiceConnectionToMemory(identity, input, dependencies) {
 import { readdir, stat, unlink } from "fs/promises";
 import { homedir } from "os";
 import { join as join6 } from "path";
-async function cleanupVercel(token2, cutoff) {
+async function cleanupVercel(token3, cutoff) {
   const { list, del } = await import("@vercel/blob");
   let cursor;
   let deleted = 0;
   do {
-    const res = await list({ prefix: SCRAPE_FALLBACK_PREFIX, cursor, token: token2 });
+    const res = await list({ prefix: SCRAPE_FALLBACK_PREFIX, cursor, token: token3 });
     const expired = res.blobs.filter((b) => new Date(b.uploadedAt).getTime() < cutoff);
     if (expired.length) {
-      await del(expired.map((b) => b.url), { token: token2 });
+      await del(expired.map((b) => b.url), { token: token3 });
       deleted += expired.length;
     }
     cursor = res.hasMore ? res.cursor : void 0;
@@ -29797,15 +30766,15 @@ async function cleanupLocal(cutoff) {
 async function cleanupExpiredScrapeBlobs(maxAgeMs = SCRAPE_BLOB_TTL_MS) {
   const cutoff = Date.now() - maxAgeMs;
   try {
-    const token2 = process.env.BLOB_READ_WRITE_TOKEN;
-    return token2 ? await cleanupVercel(token2, cutoff) : await cleanupLocal(cutoff);
+    const token3 = process.env.BLOB_READ_WRITE_TOKEN;
+    return token3 ? await cleanupVercel(token3, cutoff) : await cleanupLocal(cutoff);
   } catch {
     return { deleted: 0, store: "none" };
   }
 }
 
 // src/api/connected-data-export.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 var CONNECTED_DATA_INLINE_BUDGET_BYTES = Number(
   process.env.MCP_SCRAPER_CONNECTED_DATA_INLINE_BUDGET_BYTES ?? 5e4
 );
@@ -29976,7 +30945,7 @@ function finitePositive(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 async function collectConnectedDataExport(args) {
-  const exportId = randomUUID13();
+  const exportId = randomUUID15();
   const now = args.now ?? Date.now;
   const startedAt = now();
   const budgetMs = finitePositive(CONNECTED_DATA_EXPORT_BUDGET_MS, 24e4);
@@ -30092,7 +31061,7 @@ ${lines.length ? `${lines.join("\n")}
 }
 
 // src/api/search-console-table-export.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 var SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS = 5e4;
 var SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE = 2e3;
 var SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES = 50 * 1024 * 1024;
@@ -30192,7 +31161,7 @@ async function exportSearchConsoleTableData(args) {
     offset += rows.length;
     if (stoppedForBytes || rows.length < limit || offset >= matchedRows) break;
   }
-  const exportId = randomUUID14();
+  const exportId = randomUUID16();
   const artifact = await args.writeArtifact({
     ownerId: args.ownerId,
     exportId,
@@ -30547,7 +31516,7 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash14, randomUUID as randomUUID17 } from "crypto";
+import { createHash as createHash18, randomUUID as randomUUID18 } from "crypto";
 
 // src/api/slack-archive-analysis.ts
 function isRecord2(value) {
@@ -30823,17 +31792,19 @@ async function exportSlackChannelPage(input, dependencies) {
   const state = decodeCursor(input.cursor, channelId, includeThreads);
   const pageSize = Math.max(1, Math.min(200, Math.floor(input.pageSize)));
   if (state.phase === "history") {
+    const oldest = slackBoundaryTimestamp(input.from, -1);
+    const latest = slackBoundaryTimestamp(input.to, 0);
     const result = await callSlackToolWithRetry(dependencies, {
       tool: "get-conversation-history",
       input: {
         channel_id: channelId,
         limit: pageSize,
-        oldest: slackBoundaryTimestamp(input.from, -1),
-        latest: slackBoundaryTimestamp(input.to, 0),
+        oldest,
+        latest,
         inclusive: false,
         ...state.historyCursor ? { cursor: state.historyCursor } : {}
       },
-      requestId: `slack-export:${input.connectionId}:${channelId}:history:${state.historyCursor ?? "start"}`
+      requestId: `slack-export:${input.connectionId}:${channelId}:history:${oldest}:${latest}:${pageSize}:${state.historyCursor ?? "start"}`
     });
     const messages = messagesFromToolResult(result).slice(0, pageSize);
     const historyCursor = nextCursorFromToolResult(result);
@@ -30885,7 +31856,7 @@ async function exportSlackChannelPage(input, dependencies) {
       limit: perThreadLimit,
       ...thread.cursor ? { cursor: thread.cursor } : {}
     },
-    requestId: `slack-export:${input.connectionId}:${channelId}:thread:${thread.threadTs}:${thread.cursor ?? "start"}`
+    requestId: `slack-export:${input.connectionId}:${channelId}:thread:${thread.threadTs}:${perThreadLimit}:${thread.cursor ?? "start"}`
   })));
   const records = [];
   const stillPending = [];
@@ -30919,271 +31890,9 @@ async function exportSlackChannelPage(input, dependencies) {
 }
 
 // src/api/main-nango-transport.ts
-import { createHash as createHash13, randomUUID as randomUUID16 } from "crypto";
+import { createHash as createHash17, randomUUID as randomUUID17 } from "crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// src/api/service-connections.ts
-import { randomUUID as randomUUID15 } from "crypto";
-var schemaReady2 = null;
-var schemaDb2 = null;
-function ensureServiceConnectionsSchema() {
-  const currentDb = getDb();
-  if (schemaReady2 && schemaDb2 === currentDb) return schemaReady2;
-  schemaDb2 = currentDb;
-  schemaReady2 = (async () => {
-    const db = currentDb;
-    await db.execute(`
-      CREATE TABLE IF NOT EXISTS service_connections (
-        id                         TEXT PRIMARY KEY,
-        user_id                    INTEGER NOT NULL REFERENCES users(id),
-        provider_config_key        TEXT NOT NULL,
-        provider                   TEXT,
-        transport                  TEXT NOT NULL,
-        upstream_connection_id     TEXT,
-        label                      TEXT,
-        lifecycle_status           TEXT NOT NULL DEFAULT 'pending',
-        operational_status         TEXT NOT NULL DEFAULT 'unknown',
-        reconnect_required         INTEGER NOT NULL DEFAULT 0,
-        actions_enabled            INTEGER NOT NULL DEFAULT 0,
-        read_tools_json            TEXT NOT NULL DEFAULT '[]',
-        action_tools_json          TEXT NOT NULL DEFAULT '[]',
-        tool_revision              TEXT,
-        last_checked_at            TEXT,
-        last_successful_call_at    TEXT,
-        last_failure_at            TEXT,
-        last_failure_code          TEXT,
-        last_failure_retryable     INTEGER,
-        consecutive_failures       INTEGER NOT NULL DEFAULT 0,
-        vault_name                 TEXT,
-        table_name                 TEXT,
-        legacy_owner_identity      TEXT,
-        created_at                 TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at                 TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(user_id, provider_config_key, upstream_connection_id)
-      )
-    `);
-    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_user_updated ON service_connections(user_id, updated_at DESC)`);
-    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_upstream ON service_connections(provider_config_key, upstream_connection_id)`);
-    await db.execute(`
-      CREATE TABLE IF NOT EXISTS service_connection_health_events (
-        id                    TEXT PRIMARY KEY,
-        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
-        operational_status    TEXT NOT NULL,
-        failure_code          TEXT,
-        retryable             INTEGER,
-        evidence_source       TEXT NOT NULL,
-        created_at            TEXT NOT NULL DEFAULT (datetime('now'))
-      )
-    `);
-    await db.execute(`CREATE INDEX IF NOT EXISTS service_connection_health_events_connection ON service_connection_health_events(connection_id, created_at DESC)`);
-    await db.execute(`
-      CREATE TABLE IF NOT EXISTS service_connection_action_audit (
-        id                    TEXT PRIMARY KEY,
-        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
-        user_id               INTEGER NOT NULL REFERENCES users(id),
-        tool                  TEXT NOT NULL,
-        request_id            TEXT NOT NULL,
-        status                TEXT NOT NULL,
-        error_code            TEXT,
-        created_at            TEXT NOT NULL DEFAULT (datetime('now')),
-        UNIQUE(user_id, request_id)
-      )
-    `);
-  })().catch((error) => {
-    schemaReady2 = null;
-    schemaDb2 = null;
-    throw error;
-  });
-  return schemaReady2;
-}
-function parseTools(value) {
-  if (typeof value !== "string") return [];
-  try {
-    const parsed = JSON.parse(value);
-    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
-  } catch {
-    return [];
-  }
-}
-function rowToRecord(row) {
-  return {
-    id: String(row.id),
-    userId: Number(row.user_id),
-    providerConfigKey: String(row.provider_config_key),
-    provider: typeof row.provider === "string" ? row.provider : null,
-    transport: row.transport === "remote_mcp" ? "remote_mcp" : "nango",
-    upstreamConnectionId: typeof row.upstream_connection_id === "string" ? row.upstream_connection_id : null,
-    label: typeof row.label === "string" ? row.label : null,
-    lifecycleStatus: String(row.lifecycle_status),
-    operationalStatus: String(row.operational_status),
-    reconnectRequired: Number(row.reconnect_required) === 1,
-    actionsEnabled: Number(row.actions_enabled) === 1,
-    readTools: parseTools(row.read_tools_json),
-    actionTools: parseTools(row.action_tools_json),
-    toolRevision: typeof row.tool_revision === "string" ? row.tool_revision : null,
-    lastCheckedAt: typeof row.last_checked_at === "string" ? row.last_checked_at : null,
-    lastSuccessfulCallAt: typeof row.last_successful_call_at === "string" ? row.last_successful_call_at : null,
-    lastFailureAt: typeof row.last_failure_at === "string" ? row.last_failure_at : null,
-    lastFailureCode: typeof row.last_failure_code === "string" ? row.last_failure_code : null,
-    lastFailureRetryable: row.last_failure_retryable === null || row.last_failure_retryable === void 0 ? null : Number(row.last_failure_retryable) === 1,
-    consecutiveFailures: Number(row.consecutive_failures ?? 0),
-    vaultName: typeof row.vault_name === "string" ? row.vault_name : null,
-    tableName: typeof row.table_name === "string" ? row.table_name : null,
-    createdAt: String(row.created_at),
-    updatedAt: String(row.updated_at)
-  };
-}
-async function userIdForIdentity(identity) {
-  const user = await getUserByEmail(identity.normalize("NFKC").trim().toLowerCase());
-  if (!user) throw new Error("service_connection_user_not_found");
-  return Number(user.id);
-}
-async function reconcileDiscoveredNangoConnections(identity, discovered) {
-  await ensureServiceConnectionsSchema();
-  const db = getDb();
-  const userId = await userIdForIdentity(identity);
-  for (const connection of discovered) {
-    await db.execute({
-      sql: `
-        INSERT INTO service_connections (
-          id, user_id, provider_config_key, provider, transport, upstream_connection_id,
-          label, lifecycle_status, reconnect_required, actions_enabled, legacy_owner_identity, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, 'nango', ?, ?, ?, ?, 1, ?, COALESCE(?, datetime('now')), COALESCE(?, datetime('now')))
-        ON CONFLICT(user_id, provider_config_key, upstream_connection_id) DO UPDATE SET
-          provider = excluded.provider,
-          label = COALESCE(excluded.label, service_connections.label),
-          lifecycle_status = excluded.lifecycle_status,
-          reconnect_required = excluded.reconnect_required,
-          updated_at = excluded.updated_at
-      `,
-      args: [
-        randomUUID15(),
-        userId,
-        connection.providerConfigKey,
-        connection.provider,
-        connection.upstreamConnectionId,
-        connection.label,
-        connection.lifecycleStatus,
-        connection.reconnectRequired ? 1 : 0,
-        identity,
-        connection.createdAt,
-        connection.updatedAt
-      ]
-    });
-  }
-  return listServiceConnections(identity, "nango");
-}
-async function listServiceConnections(identity, transport) {
-  await ensureServiceConnectionsSchema();
-  const userId = await userIdForIdentity(identity);
-  const result = await getDb().execute({
-    sql: `SELECT * FROM service_connections WHERE user_id = ?${transport ? " AND transport = ?" : ""} AND lifecycle_status <> 'disconnected' ORDER BY updated_at DESC`,
-    args: transport ? [userId, transport] : [userId]
-  });
-  return result.rows.map((row) => rowToRecord(row));
-}
-async function getOwnedServiceConnection(identity, connectionId) {
-  await ensureServiceConnectionsSchema();
-  const userId = await userIdForIdentity(identity);
-  const result = await getDb().execute({
-    sql: "SELECT * FROM service_connections WHERE id = ? AND user_id = ? LIMIT 1",
-    args: [connectionId, userId]
-  });
-  const row = result.rows[0];
-  return row ? rowToRecord(row) : null;
-}
-async function updateServiceConnectionTools(connectionId, readTools, actionTools, toolRevision) {
-  await ensureServiceConnectionsSchema();
-  await getDb().execute({
-    sql: `UPDATE service_connections SET read_tools_json = ?, action_tools_json = ?, tool_revision = ?, updated_at = datetime('now') WHERE id = ?`,
-    args: [JSON.stringify(readTools), JSON.stringify(actionTools), toolRevision, connectionId]
-  });
-}
-async function recordServiceConnectionHealth(args) {
-  await ensureServiceConnectionsSchema();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await getDb().execute({
-    sql: `
-      UPDATE service_connections SET
-        operational_status = ?, last_checked_at = ?,
-        last_successful_call_at = CASE WHEN ? = 'available' THEN ? ELSE last_successful_call_at END,
-        last_failure_at = CASE WHEN ? IN ('degraded', 'unavailable') THEN ? ELSE NULL END,
-        last_failure_code = ?, last_failure_retryable = ?,
-        consecutive_failures = CASE WHEN ? = 'available' THEN 0 ELSE consecutive_failures + 1 END,
-        updated_at = datetime('now')
-      WHERE id = ?
-    `,
-    args: [
-      args.operationalStatus,
-      now,
-      args.operationalStatus,
-      now,
-      args.operationalStatus,
-      now,
-      args.failureCode ?? null,
-      args.retryable == null ? null : args.retryable ? 1 : 0,
-      args.operationalStatus,
-      args.connectionId
-    ]
-  });
-  await getDb().execute({
-    sql: `INSERT INTO service_connection_health_events (id, connection_id, operational_status, failure_code, retryable, evidence_source) VALUES (?, ?, ?, ?, ?, ?)`,
-    args: [randomUUID15(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
-  });
-}
-async function setServiceConnectionActions(identity, connectionId, enabled) {
-  const connection = await getOwnedServiceConnection(identity, connectionId);
-  if (!connection || connection.lifecycleStatus === "disconnected") throw new Error("service_connection_not_found");
-  await getDb().execute({
-    sql: `UPDATE service_connections SET actions_enabled = ?, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
-    args: [enabled ? 1 : 0, connectionId, connection.userId]
-  });
-  return enabled;
-}
-async function markServiceConnectionDisconnected(identity, connectionId) {
-  const connection = await getOwnedServiceConnection(identity, connectionId);
-  if (!connection) throw new Error("service_connection_not_found");
-  await getDb().execute({
-    sql: `UPDATE service_connections SET lifecycle_status = 'disconnected', operational_status = 'unknown', reconnect_required = 0, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
-    args: [connectionId, connection.userId]
-  });
-  const remaining = await getDb().execute({
-    sql: `SELECT COUNT(*) AS count FROM service_connections WHERE user_id = ? AND transport = 'nango' AND lifecycle_status = 'connected'`,
-    args: [connection.userId]
-  });
-  return Number(remaining.rows[0]?.count ?? 0);
-}
-async function recordServiceConnectionAction(args) {
-  await ensureServiceConnectionsSchema();
-  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
-  if (!connection) throw new Error("service_connection_not_found");
-  await getDb().execute({
-    sql: `UPDATE service_connection_action_audit SET status = ?, error_code = ? WHERE user_id = ? AND request_id = ? AND connection_id = ?`,
-    args: [args.status, args.errorCode ?? null, connection.userId, args.requestId, connection.id]
-  });
-}
-async function claimServiceConnectionAction(args) {
-  await ensureServiceConnectionsSchema();
-  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
-  if (!connection) throw new Error("service_connection_not_found");
-  const inserted = await getDb().execute({
-    sql: `INSERT OR IGNORE INTO service_connection_action_audit (id, connection_id, user_id, tool, request_id, status) VALUES (?, ?, ?, ?, ?, 'started')`,
-    args: [randomUUID15(), connection.id, connection.userId, args.tool, args.requestId]
-  });
-  if (Number(inserted.rowsAffected ?? 0) === 1) return { claimed: true };
-  const existing = await getDb().execute({
-    sql: `SELECT status, error_code FROM service_connection_action_audit WHERE user_id = ? AND request_id = ? LIMIT 1`,
-    args: [connection.userId, args.requestId]
-  });
-  return {
-    claimed: false,
-    status: String(existing.rows[0]?.status ?? "unknown"),
-    errorCode: typeof existing.rows[0]?.error_code === "string" ? existing.rows[0].error_code : null
-  };
-}
-
-// src/api/main-nango-transport.ts
 var DEFAULT_NANGO_MCP_URL = "https://api.nango.dev/mcp";
 var NANGO_TIMEOUT_MS = 2e4;
 var NANGO_CONNECTION_PAGE_SIZE = 100;
@@ -31528,7 +32237,7 @@ async function listNangoToolsDirect(identity, connectionId) {
   });
   const readTools = tools.filter((tool) => classifyTool(tool) === "read").map((tool) => tool.name);
   const actionTools = tools.filter((tool) => classifyTool(tool) === "action").map((tool) => tool.name);
-  const revision = createHash13("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
+  const revision = createHash17("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
   await updateServiceConnectionTools(connection.id, readTools, actionTools, revision);
   const refreshed = await getOwnedServiceConnection(identity, connection.id);
   return { connection: refreshed ?? { ...connection, readTools, actionTools, toolRevision: revision }, tools };
@@ -31548,8 +32257,8 @@ async function callNangoToolDirect(args) {
     identity: args.identity,
     ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
   });
-  const requestId = args.requestId?.trim() || randomUUID16();
-  const idempotencyKey2 = `main-nango:${createHash13("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
+  const requestId = args.requestId?.trim() || randomUUID17();
+  const idempotencyKey2 = `main-nango:${createHash17("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
   const startedAt = /* @__PURE__ */ new Date();
   const started = performance.now();
   let result;
@@ -31574,7 +32283,7 @@ async function callNangoToolDirect(args) {
       toolName: args.tool,
       operationKind: args.operationKind ?? args.classification,
       outcome: providerError ? "error" : "partial",
-      requestId: requestId.length <= 200 ? requestId : createHash13("sha256").update(requestId).digest("hex"),
+      requestId: requestId.length <= 200 ? requestId : createHash17("sha256").update(requestId).digest("hex"),
       startedAt: startedAt.toISOString(),
       completedAt: completedAt.toISOString()
     }
@@ -31611,7 +32320,7 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
     providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
     protocolVersion: null,
     schemaSource: "live_tools_list",
-    schemaHash: createHash13("sha256").update(JSON.stringify(projected)).digest("hex"),
+    schemaHash: createHash17("sha256").update(JSON.stringify(projected)).digest("hex"),
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -32335,7 +33044,7 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
   return data.connection.actionsEnabled === true;
 }
 async function callScheduleConnectionAction(identity, connectionId, input, tool, idempotencyKey2) {
-  const requestId = `main-connected-action:${createHash14("sha256").update(identity).update("\0").update(idempotencyKey2?.trim() || randomUUID17()).digest("hex")}`;
+  const requestId = `main-connected-action:${createHash18("sha256").update(identity).update("\0").update(idempotencyKey2?.trim() || randomUUID18()).digest("hex")}`;
   if (mainOwnsIntegrations()) {
     const selectedTool = tool?.trim();
     if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
@@ -32477,7 +33186,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash14("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash18("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   if (mainOwnsIntegrations()) {
@@ -33078,78 +33787,6 @@ async function callResendExportPage(identity, input) {
   };
 }
 
-// src/api/scheduler-integration-auth.ts
-import { createHash as createHash15, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
-var MAX_CLOCK_SKEW_MS = 5 * 60 * 1e3;
-var SchedulerIntegrationAuthError = class extends Error {
-  code;
-  constructor(code) {
-    super(code);
-    this.name = "SchedulerIntegrationAuthError";
-    this.code = code;
-  }
-};
-function signingSecret() {
-  const secret2 = process.env.SCHEDULER_INTEGRATION_SIGNING_SECRET?.trim();
-  if (!secret2) throw new SchedulerIntegrationAuthError("not_configured");
-  return secret2;
-}
-function schedulerIntegrationSignature(args) {
-  const bodyHash = createHash15("sha256").update(args.body).digest("hex");
-  return createHmac4("sha256", args.secret).update(`${args.method.toUpperCase()}
-${args.path}
-${args.timestamp}
-${args.nonce}
-${bodyHash}`).digest("hex");
-}
-async function claimNonce(nonce, timestampMs) {
-  await ensureServiceConnectionsSchema();
-  await getDb().execute(`
-    CREATE TABLE IF NOT EXISTS service_connection_scheduler_nonces (
-      nonce       TEXT PRIMARY KEY,
-      expires_at  TEXT NOT NULL,
-      created_at  TEXT NOT NULL DEFAULT (datetime('now'))
-    )
-  `);
-  await getDb().execute(`DELETE FROM service_connection_scheduler_nonces WHERE expires_at < datetime('now')`);
-  try {
-    await getDb().execute({
-      sql: `INSERT INTO service_connection_scheduler_nonces (nonce, expires_at) VALUES (?, ?)`,
-      args: [nonce, new Date(timestampMs + MAX_CLOCK_SKEW_MS).toISOString()]
-    });
-  } catch {
-    throw new SchedulerIntegrationAuthError("replayed_request");
-  }
-}
-async function verifySchedulerIntegrationRequest(request, rawBody) {
-  const timestamp = request.headers.get("x-scheduler-timestamp")?.trim() ?? "";
-  const nonce = request.headers.get("x-scheduler-nonce")?.trim() ?? "";
-  const signature = request.headers.get("x-scheduler-signature")?.trim().toLowerCase() ?? "";
-  const requestId = request.headers.get("x-scheduler-request-id")?.trim() ?? "";
-  const timestampMs = Date.parse(timestamp);
-  if (!timestamp || !nonce || !signature || !requestId || nonce.length > 200 || requestId.length > 200 || !Number.isFinite(timestampMs)) {
-    throw new SchedulerIntegrationAuthError("invalid_signature");
-  }
-  if (Math.abs(Date.now() - timestampMs) > MAX_CLOCK_SKEW_MS) {
-    throw new SchedulerIntegrationAuthError("expired_request");
-  }
-  const expected = schedulerIntegrationSignature({
-    method: request.method,
-    path: new URL(request.url).pathname,
-    timestamp,
-    nonce,
-    body: rawBody,
-    secret: signingSecret()
-  });
-  const suppliedBytes = Buffer.from(signature, "hex");
-  const expectedBytes = Buffer.from(expected, "hex");
-  if (suppliedBytes.length !== expectedBytes.length || !timingSafeEqual3(suppliedBytes, expectedBytes)) {
-    throw new SchedulerIntegrationAuthError("invalid_signature");
-  }
-  await claimNonce(nonce, timestampMs);
-  return { requestId };
-}
-
 // src/api/server.ts
 var secureCookies2 = process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
 var isProduction2 = secureCookies2;
@@ -33211,9 +33848,9 @@ var auth2 = createMiddleware4(async (c, next) => {
   return next();
 });
 var sessionAuth = createMiddleware4(async (c, next) => {
-  const token2 = getCookie2(c, "session");
-  if (!token2) return c.json({ error: "Not authenticated" }, 401);
-  const userId = verifySession(token2);
+  const token3 = getCookie2(c, "session");
+  if (!token3) return c.json({ error: "Not authenticated" }, 401);
+  const userId = verifySession(token3);
   if (!userId) return c.json({ error: "Session expired" }, 401);
   const user = await getUserById(userId);
   if (!user) return c.json({ error: "User not found" }, 401);
@@ -33238,7 +33875,7 @@ var requirePaidSchedulingTier = createMiddleware4(async (c, next) => {
   if (!hasPaidSchedulingAccess(user)) return c.json(paidPlanRequiredPayload(), 403);
   return next();
 });
-var app = new Hono30();
+var app = new Hono33();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -33355,8 +33992,8 @@ app.post("/auth/register", requireAllowedOrigin, async (c) => {
         console.warn("[auth/register] memory provision failed (will retry on first write):", err instanceof Error ? err.message : String(err));
       }
     })();
-    const token2 = signSession(user.id);
-    setCookie2(c, "session", token2, sessionCookieOptions2);
+    const token3 = signSession(user.id);
+    setCookie2(c, "session", token3, sessionCookieOptions2);
     return c.json({ email: user.email, api_key: newKey }, 201);
   } catch (err) {
     const msg = err instanceof Error ? err.message : "";
@@ -33374,8 +34011,8 @@ app.post("/auth/login", requireAllowedOrigin, async (c) => {
   if (!user || !user.password_hash || !verifyPassword(password, user.password_hash)) {
     return c.json({ error: "Invalid email or password" }, 401);
   }
-  const token2 = signSession(user.id);
-  setCookie2(c, "session", token2, sessionCookieOptions2);
+  const token3 = signSession(user.id);
+  setCookie2(c, "session", token3, sessionCookieOptions2);
   return c.json({ email: user.email, api_key: user.key_active ? user.api_key : null });
 });
 app.post("/auth/logout", requireAllowedOrigin, (c) => {
@@ -33430,9 +34067,9 @@ app.post("/auth/forgot-password", requireAllowedOrigin, async (c) => {
   if (emailLimited) return emailLimited;
   const user = await getUserByEmail(normalizedEmail);
   if (!user) return c.json({ ok: true });
-  const token2 = await createPasswordResetToken(user.id);
+  const token3 = await createPasswordResetToken(user.id);
   const appUrl = process.env.APP_URL ?? "https://mcpscraper.dev";
-  const resetUrl = `${appUrl}/reset-password?token=${token2}`;
+  const resetUrl = `${appUrl}/reset-password?token=${token3}`;
   if (process.env.RESEND_API_KEY) {
     try {
       const resend = new Resend3(process.env.RESEND_API_KEY);
@@ -33452,12 +34089,12 @@ app.post("/auth/forgot-password", requireAllowedOrigin, async (c) => {
   return c.json({ ok: true });
 });
 app.post("/auth/reset-password", requireAllowedOrigin, async (c) => {
-  const { token: token2, password } = await c.req.json();
-  if (!token2 || !password) return c.json({ error: "Token and password required" }, 400);
+  const { token: token3, password } = await c.req.json();
+  if (!token3 || !password) return c.json({ error: "Token and password required" }, 400);
   if (password.length < 8) return c.json({ error: "Password must be at least 8 characters" }, 400);
   const limited = await enforceRateLimit(c, "auth_reset", rateLimitKey(c), 10, 60 * 60);
   if (limited) return limited;
-  const userId = await consumePasswordResetToken(token2);
+  const userId = await consumePasswordResetToken(token3);
   if (!userId) return c.json({ error: "Invalid or expired reset link" }, 400);
   await setPassword(userId, password);
   return c.json({ ok: true });
@@ -33494,9 +34131,9 @@ function sessionBootstrapPayload(user) {
 }
 app.get("/me", async (c) => {
   c.header("Cache-Control", "no-store");
-  const token2 = getCookie2(c, "session");
-  if (!token2) return c.json({ authenticated: false });
-  const userId = verifySession(token2);
+  const token3 = getCookie2(c, "session");
+  if (!token3) return c.json({ authenticated: false });
+  const userId = verifySession(token3);
   if (!userId) {
     deleteCookie(c, "session", { path: "/", secure: secureCookies2, sameSite: "Strict" });
     return c.json({ authenticated: false });
@@ -34738,11 +35375,11 @@ app.put("/schedule-actions/:id", auth2, requirePaidSchedulingTier, async (c) =>
   if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
   const body = await c.req.json().catch(() => ({}));
   const updates = {};
-  for (const field of ["description", "vault", "cadence", "timeOfDay", "timezone"]) {
+  for (const field of ["description", "vault", "cadence", "timeOfDay", "timezone", "artifactSelection"]) {
     if (Object.prototype.hasOwnProperty.call(body, field)) updates[field] = body[field];
   }
   if (Object.keys(updates).length === 0) {
-    return c.json({ ok: false, error: "Provide at least one of description, vault, cadence, timeOfDay, timezone." }, 400);
+    return c.json({ ok: false, error: "Provide at least one of description, vault, cadence, timeOfDay, timezone, artifactSelection." }, 400);
   }
   const r = await memoryCall("updateScheduledActionTool", { id: c.req.param("id"), ...updates }, key);
   return c.json(r);
@@ -34910,7 +35547,7 @@ app.post("/harvest", auth2, async (c) => {
     if (!harvestOk) return c.json(insufficientBalanceResponse(harvestBal, harvestCost), 402);
     jobId2 = await createJob(user.id, options.query, { ...options, billingHoldMc: harvestCost }, body.callback_url);
   } else {
-    jobId2 = randomUUID18();
+    jobId2 = randomUUID19();
     const billingDebitKey = `paa-harvest:${jobId2}:hold`;
     const description = `PAA harvest: ${options.query}`.slice(0, 500);
     const hold = await debitMcIdempotent(
@@ -36064,7 +36701,7 @@ app.get("/cron/tick", async (c) => {
   if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
     return c.json({ error: "Unauthorized" }, 401);
   }
-  const { drainQueue } = await import("./worker-5RWLFSAJ.js");
+  const { drainQueue } = await import("./worker-4R3UWQZS.js");
   const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
   const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
   const [results, sweepResult, reapResult, expiredResult, blobCleanup, connectedDataArtifactCleanup, connectedAccountBilling, directoryWorkflowDispatch, directoryWorkflowReconciliation, directoryArtifactCleanup, siteExtractArtifactCleanup, siteExtractRedispatch, siteExtractReconciliation, paaHarvestRedispatch, paaHarvestReconciliation] = await Promise.all([
@@ -36117,8 +36754,8 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     finishExtractJob: finishExtractJob2,
     terminalExtractJobStatus: terminalExtractJobStatus2,
     extractJobLimitInfo: extractJobLimitInfo2
-  } = await import("./site-extract-repository-6GX72U4N.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-SKXEDG4Z.js");
+  } = await import("./site-extract-repository-B42SIGAZ.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-DMZ63HZU.js");
   const existing = await getExtractJob2(jobId2);
   if (!existing) return c.json({ error: "job not found" }, 404);
   if (existing.status !== "failed") {
@@ -36145,7 +36782,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   if (!updated) return c.json({ error: "job state changed during re-finalization" }, 409);
   let settlement = "already_settled_or_refunded";
   if (job.billedMc == null && job.userId != null) {
-    const { settleExtractJob: settleExtractJob3, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-6GX72U4N.js");
+    const { settleExtractJob: settleExtractJob3, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-B42SIGAZ.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId2);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -36192,6 +36829,9 @@ app.route("/schedule", scheduleApp);
 app.route("/resend", resendInboundApp);
 app.route("/workshops", workshopRegistrationApp);
 app.route("/editorial-reading-room", editorialReadingRoomApp);
+app.route("/", scheduledResultApp);
+app.route("/public", publicScheduledResultApp);
+app.route("/api/internal/scheduled-artifacts", scheduledArtifactInternalApp);
 app.get("/console", (c) => c.html(renderConsoleHtml()));
 app.get("/console/auth/:id", async (c) => {
   const id = c.req.param("id");
@@ -36321,4 +36961,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-2JJPCZH4.js.map
+//# sourceMappingURL=server-MVCGZ4OK.js.map