@peristyle/emdash-plugin-instagram-to-recipe 0.1.0 → 0.1.2

package/dist/sandbox-entry.js

@@ -96,6 +96,9 @@ function importFormBlocks(initialUrl = "") {
     }
   ];
 }
+function pageBlocks() {
+  return [...importFormBlocks(), { type: "divider" }, ...bulkFormBlocks()];
+}
 function previewBlocks(recipe, options) {
   const ingredientPreview = recipe.ingredients.slice(0, 8).join("\n");
   const instructionPreview = recipe.instructions.slice(0, 4).map((step, i) => `${i + 1}. ${step}`).join("\n");
@@ -182,6 +185,116 @@ function previewBlocks(recipe, options) {
   });
   return blocks;
 }
+function bulkFormBlocks(initialHandle = "") {
+  return [
+    {
+      type: "header",
+      text: "Bulk import from a profile"
+    },
+    {
+      type: "context",
+      text: "Enter a public Instagram handle. Its latest posts are scanned in a single request, and only captions that parse as recipes are listed for import \u2014 pick the ones to create."
+    },
+    {
+      type: "form",
+      block_id: "bulk-form",
+      fields: [
+        {
+          type: "text_input",
+          action_id: "instagram_handle",
+          label: "Instagram handle",
+          placeholder: "@cookingwithashhhh",
+          initial_value: initialHandle
+        }
+      ],
+      submit: { label: "Scan profile", action_id: "bulk_scan" }
+    }
+  ];
+}
+function bulkPreviewBlocks(handle, candidates, meta = {
+  scanned: 0
+}) {
+  const blocks = [...bulkFormBlocks(handle), { type: "divider" }];
+  if (meta.rateLimited) {
+    blocks.push({
+      type: "banner",
+      title: "Instagram rate-limited the profile API",
+      description: "Showing whatever could be recovered (possibly from cache). Try again in a few minutes for a full scan.",
+      variant: "alert"
+    });
+  }
+  if (candidates.length === 0) {
+    blocks.push({
+      type: "banner",
+      title: "No recipes found",
+      description: `Scanned ${meta.scanned} recent post(s) for @${handle} but none had a parseable recipe caption (ingredients + numbered steps). Use the single-post import above for an individual post.`,
+      variant: "default"
+    });
+    return blocks;
+  }
+  blocks.push({
+    type: "banner",
+    title: `${candidates.length} recipe${candidates.length === 1 ? "" : "s"} found`,
+    description: `Scanned ${meta.scanned} recent post(s) for @${handle}${meta.fromCache ? " (from cache)" : ""}. Already-imported posts are unchecked by default.`,
+    variant: "default"
+  });
+  const options = candidates.map((c) => ({
+    label: `${c.recipe.title} \u2014 ${c.recipe.source.likes} likes${c.alreadyImported ? " (already imported)" : ""}`,
+    value: c.recipe.source.shortcode
+  }));
+  const initialSelected = candidates.filter((c) => !c.alreadyImported).map((c) => c.recipe.source.shortcode);
+  blocks.push({
+    type: "form",
+    block_id: "bulk-select-form",
+    fields: [
+      {
+        type: "checkbox",
+        action_id: "bulk_select",
+        label: "Recipes to import",
+        options,
+        initial_value: initialSelected
+      }
+    ],
+    submit: { label: "Create selected drafts", action_id: "bulk_create" }
+  });
+  for (const c of candidates) {
+    if (c.recipe.featured_image?.url) {
+      blocks.push({
+        type: "image",
+        url: c.recipe.featured_image.url,
+        alt: c.recipe.featured_image.alt,
+        title: c.recipe.title
+      });
+    }
+  }
+  return blocks;
+}
+function bulkResultBlocks(handle, result) {
+  const blocks = [...bulkFormBlocks(handle), { type: "divider" }];
+  blocks.push({
+    type: "banner",
+    title: `Created ${result.created.length} draft${result.created.length === 1 ? "" : "s"}`,
+    description: result.created.length ? `Saved: ${result.created.map((c) => c.title).join(", ")}. Open Posts in the admin to review and publish.` : "No new drafts were created.",
+    variant: "default"
+  });
+  if (result.skipped.length > 0) {
+    blocks.push({
+      type: "banner",
+      title: `Skipped ${result.skipped.length} already imported`,
+      description: `Already in your library: ${result.skipped.map((s) => s.title).join(", ")}.`,
+      variant: "default"
+    });
+  }
+  if (result.failed.length > 0) {
+    blocks.push({
+      type: "banner",
+      title: `${result.failed.length} failed`,
+      description: result.failed.map((f) => `${f.shortcode}: ${f.message}`).join(" \xB7 "),
+      variant: "alert"
+    });
+  }
+  return blocks;
+}
 function errorBlocks(message, initialUrl = "") {
   return [
     ...importFormBlocks(initialUrl),
@@ -299,6 +412,27 @@ function buildParsedRecipeFromPost(post) {
   }
   return recipe;
 }
+function buildBulkRecipesFromPosts(posts) {
+  const recipes = [];
+  const usedSlugs = /* @__PURE__ */ new Set();
+  for (const post of posts) {
+    const recipe = buildParsedRecipeFromPost(post);
+    if (!recipe) continue;
+    let slug = recipe.suggested_slug;
+    let n = 2;
+    while (usedSlugs.has(slug)) {
+      slug = `${recipe.suggested_slug}-${n}`;
+      n++;
+    }
+    usedSlugs.add(slug);
+    recipe.suggested_slug = slug;
+    if (recipe.featured_image) {
+      recipe.featured_image.filename = imageFilenameForSlug(slug);
+    }
+    recipes.push(recipe);
+  }
+  return recipes;
+}
 function buildParsedRecipeFromPostLenient(post) {
   const strict = buildParsedRecipeFromPost(post);
   if (strict) return strict;
@@ -353,15 +487,31 @@ function extractOwnerUsername(html) {
   if (userMatch?.[1]) return userMatch[1].toLowerCase();
   return void 0;
 }
-function displayUrlFromProfileUser(user, shortcode) {
+var PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function isProfileCacheFresh(entry) {
+  const age = Date.now() - Date.parse(entry.fetchedAt);
+  return Number.isFinite(age) && age >= 0 && age <= PROFILE_CACHE_TTL_MS;
+}
+function postsFromProfileUser(user) {
   const edges = user?.edge_owner_to_timeline_media?.edges ?? [];
+  const posts = [];
   for (const edge of edges) {
     const node = edge.node;
-    if (node?.shortcode === shortcode && node.display_url) {
-      return node.display_url;
-    }
+    if (!node?.shortcode) continue;
+    const capEdges = node.edge_media_to_caption?.edges ?? [];
+    posts.push({
+      shortcode: node.shortcode,
+      caption: capEdges[0]?.node?.text?.trim() ?? "",
+      displayUrl: node.display_url,
+      accessibilityCaption: node.accessibility_caption,
+      likes: node.edge_liked_by?.count ?? 0,
+      isVideo: Boolean(node.is_video)
+    });
   }
-  return void 0;
+  return posts;
+}
+function postNodeFromProfileUser(user, shortcode) {
+  return postsFromProfileUser(user).find((p) => p.shortcode === shortcode);
 }
 function profileApiHeaders(handle) {
   const profileUrl = `https://www.instagram.com/${handle}/`;
@@ -375,8 +525,11 @@ function profileApiHeaders(handle) {
     Origin: "https://www.instagram.com"
   };
 }
-var PROFILE_FETCH_RETRIES = 2;
-var PROFILE_RETRY_DELAY_MS = 2500;
+var PROFILE_FETCH_RETRIES = 3;
+var PROFILE_RETRY_BASE_DELAY_MS = 2500;
+function retryDelayMs(attempt) {
+  return PROFILE_RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -408,19 +561,45 @@ async function fetchProfileUserOnce(fetchFn, handle) {
   }
   return { ok: true, user, httpStatus };
 }
-async function fetchProfileDisplayUrl(fetchFn, handle, shortcode) {
+async function cacheGet(cache, handle) {
+  try {
+    return await cache?.get(handle);
+  } catch {
+    return void 0;
+  }
+}
+async function cacheSet(cache, handle, user, httpStatus) {
+  try {
+    await cache?.set(handle, {
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      handle,
+      httpStatus,
+      user
+    });
+  } catch {
+  }
+}
+async function fetchProfilePostNode(fetchFn, handle, shortcode, cache) {
   const username = normalizeInstagramHandle(handle);
+  const cached = await cacheGet(cache, username);
+  if (cached && isProfileCacheFresh(cached)) {
+    const node = postNodeFromProfileUser(cached.user, shortcode);
+    if (node) {
+      return { node, httpStatus: cached.httpStatus, fromCache: true };
+    }
+  }
   let lastHttpStatus;
   let rateLimited = false;
   for (let attempt = 0; attempt <= PROFILE_FETCH_RETRIES; attempt++) {
     if (attempt > 0) {
-      await sleep(PROFILE_RETRY_DELAY_MS * attempt);
+      await sleep(retryDelayMs(attempt - 1));
     }
     const result = await fetchProfileUserOnce(fetchFn, username);
     if (result.ok) {
-      const url = displayUrlFromProfileUser(result.user, shortcode);
-      if (url) {
-        return { url, httpStatus: result.httpStatus };
+      await cacheSet(cache, username, result.user, result.httpStatus);
+      const node = postNodeFromProfileUser(result.user, shortcode);
+      if (node) {
+        return { node, httpStatus: result.httpStatus };
       }
       return { httpStatus: result.httpStatus, shortcodeMissing: true };
     }
@@ -430,15 +609,26 @@ async function fetchProfileDisplayUrl(fetchFn, handle, shortcode) {
     }
     if (!result.retryable) break;
   }
+  if (cached) {
+    const node = postNodeFromProfileUser(cached.user, shortcode);
+    if (node) {
+      return { node, httpStatus: cached.httpStatus, fromCache: true };
+    }
+  }
   if (typeof process !== "undefined" && process.versions?.node) {
     try {
-      const { shouldTryInstagramCurlFallback, curlAvailable, fetchInstagramProfileViaCurl } = await import("./instagram-curl-profile-H4ND6RCQ.js");
+      const {
+        shouldTryInstagramCurlFallback,
+        curlAvailable,
+        fetchInstagramProfileViaCurl
+      } = await import("./instagram-curl-profile-H4ND6RCQ.js");
       if (shouldTryInstagramCurlFallback() && await curlAvailable()) {
         const curlResult = await fetchInstagramProfileViaCurl(username);
         if (curlResult.ok) {
-          const url = displayUrlFromProfileUser(curlResult.user, shortcode);
-          if (url) {
-            return { url, httpStatus: curlResult.httpStatus };
+          await cacheSet(cache, username, curlResult.user, curlResult.httpStatus);
+          const node = postNodeFromProfileUser(curlResult.user, shortcode);
+          if (node) {
+            return { node, httpStatus: curlResult.httpStatus };
           }
           return {
             httpStatus: curlResult.httpStatus,
@@ -455,6 +645,79 @@ async function fetchProfileDisplayUrl(fetchFn, handle, shortcode) {
     shortcodeMissing: false
   };
 }
+async function fetchProfileGrid(fetchFn, handle, cache) {
+  const username = normalizeInstagramHandle(handle);
+  const cached = await cacheGet(cache, username);
+  if (cached && isProfileCacheFresh(cached)) {
+    return {
+      handle: username,
+      posts: postsFromProfileUser(cached.user),
+      httpStatus: cached.httpStatus,
+      fromCache: true
+    };
+  }
+  let lastHttpStatus;
+  let rateLimited = false;
+  for (let attempt = 0; attempt <= PROFILE_FETCH_RETRIES; attempt++) {
+    if (attempt > 0) {
+      await sleep(retryDelayMs(attempt - 1));
+    }
+    const result = await fetchProfileUserOnce(fetchFn, username);
+    if (result.ok) {
+      await cacheSet(cache, username, result.user, result.httpStatus);
+      return {
+        handle: username,
+        posts: postsFromProfileUser(result.user),
+        httpStatus: result.httpStatus
+      };
+    }
+    lastHttpStatus = result.httpStatus;
+    if (result.httpStatus === 429 || result.httpStatus === 503) {
+      rateLimited = true;
+    }
+    if (!result.retryable) break;
+  }
+  if (cached) {
+    return {
+      handle: username,
+      posts: postsFromProfileUser(cached.user),
+      httpStatus: cached.httpStatus,
+      fromCache: true
+    };
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    try {
+      const {
+        shouldTryInstagramCurlFallback,
+        curlAvailable,
+        fetchInstagramProfileViaCurl
+      } = await import("./instagram-curl-profile-H4ND6RCQ.js");
+      if (shouldTryInstagramCurlFallback() && await curlAvailable()) {
+        const curlResult = await fetchInstagramProfileViaCurl(username);
+        if (curlResult.ok) {
+          await cacheSet(
+            cache,
+            username,
+            curlResult.user,
+            curlResult.httpStatus
+          );
+          return {
+            handle: username,
+            posts: postsFromProfileUser(curlResult.user),
+            httpStatus: curlResult.httpStatus
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    handle: username,
+    posts: [],
+    httpStatus: lastHttpStatus,
+    rateLimited
+  };
+}
 
 // src/parse-instagram-post.ts
 var INSTAGRAM_POST_RE = /(?:https?:\/\/)?(?:www\.)?instagram\.com\/(?:p|reel|tv)\/([A-Za-z0-9_-]+)/i;
@@ -512,13 +775,6 @@ function extractMetaContent(html, property) {
   }
   return void 0;
 }
-async function primeInstagramSession(fetchFn) {
-  await fetchFn("https://www.instagram.com/", {
-    method: "GET",
-    redirect: "follow",
-    headers: instagramFetchHeaders()
-  });
-}
 function instagramFetchHeaders(referer) {
   return {
     Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
@@ -579,10 +835,56 @@ function extractCaptionFromOgDescription(description) {
   if (inline?.[1]) return inline[1].trim();
   return decoded;
 }
+function imageNoticeFromProfileResult(result) {
+  if (result.node?.displayUrl) return void 0;
+  if (result.rateLimited) {
+    return "Instagram rate-limited the profile API (HTTP 429). The recipe was parsed without a featured image \u2014 upload one manually, or try Convert again in a few minutes.";
+  }
+  if (result.shortcodeMissing) {
+    return "This post was not found in the latest profile grid (Instagram only returns ~12 posts). Import without a featured image and upload one manually.";
+  }
+  return void 0;
+}
+async function postFromProfileNode(fetchFn, node, canonicalUrl) {
+  let imageBytes;
+  let imageContentType;
+  if (node.displayUrl) {
+    const downloaded = await downloadPostImage(
+      fetchFn,
+      node.displayUrl,
+      canonicalUrl
+    );
+    imageBytes = downloaded?.bytes;
+    imageContentType = downloaded?.contentType;
+  }
+  return {
+    shortcode: node.shortcode,
+    postUrl: canonicalUrl,
+    caption: node.caption,
+    displayUrl: node.displayUrl,
+    accessibilityCaption: node.accessibilityCaption,
+    likes: node.likes,
+    isVideo: node.isVideo,
+    imageBytes,
+    imageContentType
+  };
+}
 async function fetchInstagramPost(postUrl, fetchFn, options = {}) {
   const { shortcode } = parseInstagramPostUrl(postUrl);
   const canonicalUrl = `https://www.instagram.com/p/${shortcode}/`;
-  await primeInstagramSession(fetchFn);
+  const configuredHandle = options.instagramHandle ? normalizeInstagramHandle(options.instagramHandle) : void 0;
+  let profileResult;
+  if (configuredHandle) {
+    profileResult = await fetchProfilePostNode(
+      fetchFn,
+      configuredHandle,
+      shortcode,
+      options.profileCache
+    );
+    if (profileResult.node?.caption.trim()) {
+      return postFromProfileNode(fetchFn, profileResult.node, canonicalUrl);
+    }
+  }
   const res = await fetchFn(canonicalUrl, {
     method: "GET",
     redirect: "follow",
@@ -604,24 +906,18 @@ async function fetchInstagramPost(postUrl, fetchFn, options = {}) {
   const ogVideo = extractMetaContent(html, "og:video");
   const isVideo = Boolean(ogVideo) || /"is_video":true/i.test(html) || /"__typename":"GraphVideo"/i.test(html) || /"media_type":2[,}]/i.test(html);
   const cookieHeader = cookieHeaderFromResponse(res);
-  const ownerHandle = options.instagramHandle ?? extractOwnerUsername(html);
-  let displayUrl;
-  let imageNotice;
-  if (ownerHandle) {
-    const profile = await fetchProfileDisplayUrl(
+  const ownerHandle = extractOwnerUsername(html);
+  if (ownerHandle && ownerHandle !== configuredHandle) {
+    profileResult = await fetchProfilePostNode(
       fetchFn,
       ownerHandle,
-      shortcode
+      shortcode,
+      options.profileCache
     );
-    displayUrl = profile.url;
-    if (!displayUrl) {
-      if (profile.rateLimited) {
-        imageNotice = "Instagram rate-limited the profile API (HTTP 429). The recipe was parsed without a featured image \u2014 upload one manually, or try Convert again in a few minutes.";
-      } else if (profile.shortcodeMissing) {
-        imageNotice = "This post was not found in the latest profile grid (Instagram only returns ~12 posts). Import without a featured image and upload one manually.";
-      }
-    }
   }
+  const node = profileResult?.node;
+  const displayUrl = node?.displayUrl;
+  const imageNotice = profileResult ? imageNoticeFromProfileResult(profileResult) : void 0;
   let imageBytes;
   let imageContentType;
   if (displayUrl) {
@@ -637,8 +933,10 @@ async function fetchInstagramPost(postUrl, fetchFn, options = {}) {
   return {
     shortcode,
     postUrl: canonicalUrl,
-    caption,
+    caption: caption || node?.caption || "",
     displayUrl,
+    accessibilityCaption: node?.accessibilityCaption,
+    likes: node?.likes ?? 0,
     isVideo,
     imageNotice,
     imageBytes,
@@ -651,6 +949,11 @@ var instagramBrowserUserAgent = BROWSER_UA2;
 var DEFAULT_COLLECTION = "posts";
 var PARSE_CACHE_PREFIX = "parse:";
 var IMPORT_MAP_PREFIX = "imported:";
+var PROFILE_CACHE_PREFIX = "igprofile:";
+var BULK_CREATE_DELAY_MS = 600;
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function collectionSlug(ctx) {
   return await ctx.kv.get("config:collection") ?? DEFAULT_COLLECTION;
 }
@@ -666,27 +969,35 @@ async function httpFetch(ctx, url, init) {
   }
   return ctx.http.fetch(url, init);
 }
+function profileCacheForCtx(ctx) {
+  return {
+    async get(handle) {
+      return await ctx.kv.get(
+        `${PROFILE_CACHE_PREFIX}${handle}`
+      ) ?? void 0;
+    },
+    async set(handle, entry) {
+      await ctx.kv.set(`${PROFILE_CACHE_PREFIX}${handle}`, entry);
+    }
+  };
+}
 async function convertInstagramUrl(ctx, instagramUrl) {
   const fetchFn = (input, init) => httpFetch(ctx, input, init);
   const instagramHandle = await ctx.kv.get("config:instagram_handle");
   const post = await fetchInstagramPost(instagramUrl, fetchFn, {
-    instagramHandle: instagramHandle ?? void 0
+    instagramHandle: instagramHandle ?? void 0,
+    profileCache: profileCacheForCtx(ctx)
   });
-  const recipe = buildParsedRecipeFromPost({
+  const postForRecipe = {
     shortcode: post.shortcode,
     caption: post.caption,
     displayUrl: post.displayUrl,
-    likes: 0,
+    accessibilityCaption: post.accessibilityCaption,
+    likes: post.likes,
     isVideo: post.isVideo,
     postUrl: post.postUrl
-  }) ?? buildParsedRecipeFromPostLenient({
-    shortcode: post.shortcode,
-    caption: post.caption,
-    displayUrl: post.displayUrl,
-    likes: 0,
-    isVideo: post.isVideo,
-    postUrl: post.postUrl
-  });
+  };
+  const recipe = buildParsedRecipeFromPost(postForRecipe) ?? buildParsedRecipeFromPostLenient(postForRecipe);
   if (!recipe) {
     throw new Error(
       "Caption does not look like a recipe (needs ingredients and numbered steps). Try a post with a \u201CWhat you'll need\u201D section and numbered instructions."
@@ -790,6 +1101,72 @@ async function createDraftFromRecipe(ctx, shortcode) {
     collection
   };
 }
+function nodeToPostForRecipes(node) {
+  return {
+    shortcode: node.shortcode,
+    caption: node.caption,
+    displayUrl: node.displayUrl,
+    accessibilityCaption: node.accessibilityCaption,
+    likes: node.likes,
+    isVideo: node.isVideo,
+    postUrl: `https://www.instagram.com/p/${node.shortcode}/`
+  };
+}
+async function scanProfileRecipes(ctx, handleInput) {
+  const fallbackHandle = await ctx.kv.get("config:instagram_handle") ?? "";
+  const handle = normalizeInstagramHandle(handleInput || fallbackHandle);
+  const fetchFn = (input, init) => httpFetch(ctx, input, init);
+  const grid = await fetchProfileGrid(fetchFn, handle, profileCacheForCtx(ctx));
+  const posts = [...grid.posts].sort((a, b) => b.likes - a.likes).map(nodeToPostForRecipes);
+  const recipes = buildBulkRecipesFromPosts(posts);
+  const candidates = [];
+  for (const recipe of recipes) {
+    await ctx.kv.set(parseCacheKey(recipe.source.shortcode), recipe);
+    const existing = await ctx.kv.get(
+      importMapKey(recipe.source.shortcode)
+    );
+    candidates.push({ recipe, alreadyImported: Boolean(existing) });
+  }
+  return {
+    handle: grid.handle,
+    candidates,
+    scanned: grid.posts.length,
+    rateLimited: grid.rateLimited,
+    fromCache: grid.fromCache
+  };
+}
+async function createDraftsForShortcodes(ctx, shortcodes, options = {}) {
+  const created = [];
+  const skipped = [];
+  const failed = [];
+  for (const shortcode of shortcodes) {
+    if (!options.force) {
+      const existing = await ctx.kv.get(importMapKey(shortcode));
+      if (existing) {
+        const recipe = await ctx.kv.get(parseCacheKey(shortcode));
+        skipped.push({
+          shortcode,
+          contentId: existing,
+          title: recipe?.title ?? shortcode
+        });
+        continue;
+      }
+    }
+    if (created.length + failed.length > 0) {
+      await sleep2(BULK_CREATE_DELAY_MS);
+    }
+    try {
+      const { contentId, title } = await createDraftFromRecipe(ctx, shortcode);
+      created.push({ shortcode, contentId, title });
+    } catch (error) {
+      failed.push({
+        shortcode,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { created, skipped, failed };
+}
 var sandbox_entry_default = {
   hooks: {
     "plugin:install": {
@@ -824,11 +1201,95 @@ var sandbox_entry_default = {
         return { ok: true, ...result };
       }
     },
+    "bulk-scan": {
+      input: z.object({
+        handle: z.string().min(1)
+      }),
+      handler: async (routeCtx, ctx) => {
+        const result = await scanProfileRecipes(ctx, routeCtx.input.handle);
+        return { ok: true, ...result };
+      }
+    },
+    "bulk-create": {
+      input: z.object({
+        shortcodes: z.array(z.string().min(1)).min(1)
+      }),
+      handler: async (routeCtx, ctx) => {
+        const result = await createDraftsForShortcodes(
+          ctx,
+          routeCtx.input.shortcodes
+        );
+        return { ok: true, ...result };
+      }
+    },
     admin: {
       handler: async (routeCtx, ctx) => {
         const interaction = routeCtx.input ?? { type: "page_load" };
         if (interaction.type === "page_load") {
-          return { blocks: importFormBlocks() };
+          return { blocks: pageBlocks() };
+        }
+        const instagramHandle = String(
+          interaction.values?.instagram_handle ?? ""
+        ).trim();
+        if (interaction.type === "form_submit" && interaction.action_id === "bulk_scan") {
+          try {
+            const { handle, candidates, scanned, rateLimited, fromCache } = await scanProfileRecipes(ctx, instagramHandle);
+            return {
+              blocks: bulkPreviewBlocks(handle, candidates, {
+                scanned,
+                rateLimited,
+                fromCache
+              }),
+              toast: {
+                message: candidates.length ? `Found ${candidates.length} recipe(s)` : "No recipes found",
+                type: candidates.length ? "success" : "error"
+              }
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              blocks: [
+                ...pageBlocks(),
+                {
+                  type: "banner",
+                  title: "Could not scan profile",
+                  description: message,
+                  variant: "error"
+                }
+              ],
+              toast: { message, type: "error" }
+            };
+          }
+        }
+        if (interaction.type === "form_submit" && interaction.action_id === "bulk_create") {
+          const raw = interaction.values?.bulk_select;
+          const shortcodes = Array.isArray(raw) ? raw.map((s) => String(s).trim()).filter(Boolean) : [];
+          if (shortcodes.length === 0) {
+            return {
+              blocks: pageBlocks(),
+              toast: { message: "Select at least one recipe", type: "error" }
+            };
+          }
+          try {
+            const result = await createDraftsForShortcodes(ctx, shortcodes);
+            const notes = [
+              result.skipped.length ? `${result.skipped.length} skipped` : "",
+              result.failed.length ? `${result.failed.length} failed` : ""
+            ].filter(Boolean);
+            return {
+              blocks: bulkResultBlocks(instagramHandle, result),
+              toast: {
+                message: `Created ${result.created.length} draft(s)${notes.length ? `, ${notes.join(", ")}` : ""}`,
+                type: result.failed.length && !result.created.length ? "error" : "success"
+              }
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              blocks: pageBlocks(),
+              toast: { message, type: "error" }
+            };
+          }
         }
         const instagramUrl = String(
           interaction.values?.instagram_url ?? ""