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

package/dist/sandbox-entry.js

@@ -0,0 +1,905 @@
+// src/sandbox-entry.ts
+import { z } from "astro/zod";
+
+// src/recipe-content.ts
+function listBlocks(items, prefix, listItem) {
+  return items.map((text, index) => ({
+    _type: "block",
+    _key: `${prefix}${index}`,
+    style: "normal",
+    listItem,
+    level: 1,
+    children: [
+      {
+        _type: "span",
+        _key: `${prefix}${index}s`,
+        text
+      }
+    ]
+  }));
+}
+function recipeToPortableTextFields(recipe) {
+  const ingredients = listBlocks(recipe.ingredients, "ing", "bullet");
+  const recipe_instructions = [
+    {
+      _type: "block",
+      _key: "ri-heading",
+      style: "h3",
+      children: [
+        {
+          _type: "span",
+          _key: "ri-heading-s",
+          text: "Instructions"
+        }
+      ]
+    },
+    ...listBlocks(recipe.instructions, "ri", "number")
+  ];
+  return { ingredients, recipe_instructions };
+}
+function recipeToPostWriteData(recipe, featuredMedia) {
+  const { ingredients, recipe_instructions } = recipeToPortableTextFields(recipe);
+  const data = {
+    title: recipe.title,
+    excerpt: recipe.excerpt,
+    ingredients,
+    recipe_instructions,
+    difficulty: "easy"
+  };
+  if (featuredMedia) {
+    data.featured_image = {
+      ...featuredMedia,
+      alt: recipe.featured_image?.alt ?? featuredMedia.alt,
+      filename: recipe.featured_image?.filename ?? featuredMedia.filename
+    };
+  }
+  return data;
+}
+function previewLines(recipe) {
+  const lines = [
+    `Title: ${recipe.title}`,
+    `Suggested slug: ${recipe.suggested_slug}`,
+    `Ingredients: ${recipe.ingredients.length}`,
+    `Steps: ${recipe.instructions.length}`,
+    `Source: ${recipe.source.instagram_url}`
+  ];
+  if (recipe.featured_image) {
+    lines.push("Featured image: yes");
+  }
+  return lines;
+}
+
+// src/admin-blocks.ts
+function importFormBlocks(initialUrl = "") {
+  return [
+    {
+      type: "header",
+      text: "Import from Instagram"
+    },
+    {
+      type: "context",
+      text: "Paste a public Instagram post URL. The caption is parsed into recipe ingredients and steps, and the post image becomes the featured image."
+    },
+    {
+      type: "form",
+      block_id: "import-form",
+      fields: [
+        {
+          type: "text_input",
+          action_id: "instagram_url",
+          label: "Instagram post URL",
+          placeholder: "https://www.instagram.com/p/SHORTCODE/",
+          initial_value: initialUrl
+        }
+      ],
+      submit: { label: "Convert to recipe", action_id: "convert" }
+    }
+  ];
+}
+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");
+  const blocks = [
+    ...importFormBlocks(recipe.source.instagram_url),
+    { type: "divider" },
+    {
+      type: "banner",
+      title: "Recipe parsed",
+      description: previewLines(recipe).join(" \xB7 "),
+      variant: "default"
+    },
+    {
+      type: "fields",
+      fields: [
+        { label: "Title", value: recipe.title },
+        { label: "Suggested slug", value: recipe.suggested_slug }
+      ]
+    },
+    {
+      type: "section",
+      text: `Excerpt: ${recipe.excerpt}`
+    },
+    {
+      type: "section",
+      text: `Ingredients (${recipe.ingredients.length}): ${ingredientPreview || "None parsed"}${recipe.ingredients.length > 8 ? " \u2026" : ""}`
+    },
+    {
+      type: "section",
+      text: `Instructions (${recipe.instructions.length}): ${instructionPreview || "None parsed"}${recipe.instructions.length > 4 ? " \u2026" : ""}`
+    }
+  ];
+  if (recipe.featured_image?.url) {
+    blocks.push({
+      type: "image",
+      url: recipe.featured_image.url,
+      alt: recipe.featured_image.alt,
+      title: "Featured image preview"
+    });
+  }
+  if (recipe.image_notice) {
+    blocks.push({
+      type: "banner",
+      title: "No featured image",
+      description: recipe.image_notice,
+      variant: "alert"
+    });
+  }
+  if (recipe.featured_image?.upload_failed) {
+    blocks.push({
+      type: "banner",
+      title: "Featured image not saved to Media",
+      description: "The preview loads from Instagram in your browser, but the server could not download it for the media library. You can upload an image manually on the recipe after creating the draft.",
+      variant: "alert"
+    });
+  } else if (recipe.featured_image?.emdash_media) {
+    blocks.push({
+      type: "banner",
+      title: "Featured image ready",
+      description: "The post image is already in your media library and will be attached when you create the draft.",
+      variant: "default"
+    });
+  }
+  if (options?.existingContentId) {
+    blocks.push({
+      type: "banner",
+      title: "Already imported",
+      description: `This post was previously imported (content id: ${options.existingContentId}). Creating again will add another draft.`,
+      variant: "alert"
+    });
+  }
+  blocks.push({
+    type: "actions",
+    block_id: "preview-actions",
+    elements: [
+      {
+        type: "button",
+        action_id: "create_draft",
+        label: "Create draft post",
+        style: "primary",
+        value: recipe.source.shortcode
+      }
+    ]
+  });
+  return blocks;
+}
+function errorBlocks(message, initialUrl = "") {
+  return [
+    ...importFormBlocks(initialUrl),
+    {
+      type: "banner",
+      title: "Could not import post",
+      description: message,
+      variant: "error"
+    }
+  ];
+}
+
+// src/instagram-recipes.ts
+function titleCase(s) {
+  return s.split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function slugifyRecipeTitle(title) {
+  const s = title.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return s.slice(0, 80) || "instagram-recipe";
+}
+function stripHashtagsAndMentions(text) {
+  return text.replace(/@[\w.]+/g, "").replace(/#\w+/g, "").replace(/\s+/g, " ").trim();
+}
+function isLikelyNonRecipeCaption(caption) {
+  const lower = caption.toLowerCase();
+  return /grocery\s+(shopping|haul)/.test(lower) || /#wieiad\b/.test(lower) || /\bwieiad\b/.test(lower) || /#cookingfail\b/.test(lower) || /#tastetest\b/.test(lower) || /#foodfail\b/.test(lower) || /espresso at home/.test(lower) || /#espresso\b/.test(lower) || /#coffeetiktok\b/.test(lower);
+}
+function isLikelyRecipeCaption(caption) {
+  if (!caption.trim() || isLikelyNonRecipeCaption(caption)) return false;
+  if (/what you['']ll need|ingredients\s*:/i.test(caption)) return true;
+  const hasSteps = /(?:^|\n)\s*\d+\.\s+\S/.test(caption);
+  const hasFoodMeasures = /(\d+\/\d+|\d+)\s*(cup|cups|tbsp|tsp|lb|lbs|oz|clove|cloves|pkg|package)/i.test(
+    caption
+  ) || /\b(tablespoon|teaspoon|pound|ounce|minute|minutes|simmer|bake|roast|air fryer|broil)\b/i.test(
+    caption
+  );
+  return hasSteps && hasFoodMeasures;
+}
+function extractTitleFromCaption(caption) {
+  const ingredientsSplit = caption.split(
+    /what you['']ll need:?|ingredients\s*:/i
+  )[0];
+  const intro = stripHashtagsAndMentions(ingredientsSplit ?? caption);
+  const firstSentence = intro.split(/[.!?]/)[0]?.trim() ?? intro;
+  const withoutThe = firstSentence.replace(/^the\s+/i, "");
+  const beforeVerb = withoutThe.split(/\s+(?:is|are|have|has|was|will|makes)\s+/i)[0]?.trim() ?? withoutThe;
+  if (beforeVerb.length >= 8 && beforeVerb.length <= 72) {
+    return titleCase(beforeVerb);
+  }
+  if (firstSentence.length <= 72) {
+    return titleCase(firstSentence);
+  }
+  return titleCase(firstSentence.slice(0, 68).trim());
+}
+function parseIngredientsFromCaption(caption) {
+  const match = caption.match(/what you['']ll need:?|ingredients\s*:/i);
+  if (!match || match.index == null) return [];
+  const afterHeader = caption.slice(match.index + match[0].length);
+  const stepsMatch = afterHeader.match(/(?:^|\n)\s*\d+\.\s+/);
+  const ingredientsBlock = stepsMatch?.index ? afterHeader.slice(0, stepsMatch.index) : afterHeader;
+  const lines = ingredientsBlock.split(/\n/);
+  const ingredients = [];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (/^\[[^\]]+\]$/.test(line)) continue;
+    if (/^recipe below/i.test(line)) continue;
+    ingredients.push(line);
+  }
+  return ingredients;
+}
+function parseInstructionsFromCaption(caption) {
+  const matches = [...caption.matchAll(/(?:^|\n)\s*(\d+)\.\s*([^\n]+)/g)];
+  return matches.map((m) => m[2]?.trim()).filter((s) => Boolean(s && s.length > 3));
+}
+function parseRecipeCaption(caption) {
+  if (!isLikelyRecipeCaption(caption)) return null;
+  const ingredients = parseIngredientsFromCaption(caption);
+  const instructions = parseInstructionsFromCaption(caption);
+  const title = extractTitleFromCaption(caption);
+  if (ingredients.length === 0 && instructions.length === 0) return null;
+  const intro = caption.split(/what you['']ll need:?|ingredients\s*:/i)[0]?.trim();
+  const excerptSource = stripHashtagsAndMentions(intro ?? caption).split(/[.!?]/)[0]?.trim();
+  const excerpt = excerptSource && excerptSource.length > 20 ? excerptSource.slice(0, 220) : `${title} \u2014 from Instagram.`;
+  return { title, excerpt, ingredients, instructions };
+}
+function imageFilenameForSlug(slug) {
+  return `${slug}.jpg`;
+}
+function buildParsedRecipeFromPost(post) {
+  const parsed = parseRecipeCaption(post.caption);
+  if (!parsed) return null;
+  const slug = slugifyRecipeTitle(parsed.title);
+  const alt = post.accessibilityCaption?.trim() || `${parsed.title} \u2014 photo from Instagram`;
+  const recipe = {
+    source: {
+      instagram_url: post.postUrl,
+      shortcode: post.shortcode,
+      likes: post.likes,
+      is_video: post.isVideo
+    },
+    suggested_slug: slug,
+    title: parsed.title,
+    excerpt: parsed.excerpt,
+    caption_raw: post.caption,
+    ingredients: parsed.ingredients,
+    instructions: parsed.instructions
+  };
+  if (post.displayUrl) {
+    recipe.featured_image = {
+      url: post.displayUrl,
+      alt,
+      filename: imageFilenameForSlug(slug)
+    };
+  }
+  return recipe;
+}
+function buildParsedRecipeFromPostLenient(post) {
+  const strict = buildParsedRecipeFromPost(post);
+  if (strict) return strict;
+  const ingredients = parseIngredientsFromCaption(post.caption);
+  const instructions = parseInstructionsFromCaption(post.caption);
+  if (ingredients.length === 0 && instructions.length === 0) return null;
+  const title = extractTitleFromCaption(post.caption);
+  const slug = slugifyRecipeTitle(title);
+  const alt = post.accessibilityCaption?.trim() || `${title} \u2014 photo from Instagram`;
+  const recipe = {
+    source: {
+      instagram_url: post.postUrl,
+      shortcode: post.shortcode,
+      likes: post.likes,
+      is_video: post.isVideo
+    },
+    suggested_slug: slug,
+    title,
+    excerpt: `${title} \u2014 imported from Instagram.`,
+    caption_raw: post.caption,
+    ingredients,
+    instructions
+  };
+  if (post.displayUrl) {
+    recipe.featured_image = {
+      url: post.displayUrl,
+      alt,
+      filename: imageFilenameForSlug(slug)
+    };
+  }
+  return recipe;
+}
+
+// src/instagram-profile-image.ts
+var IG_APP_ID = "936619743392459";
+var BROWSER_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+function normalizeInstagramHandle(raw) {
+  let s = raw.trim();
+  const urlMatch = /instagram\.com\/([A-Za-z0-9._]+)/i.exec(s);
+  if (urlMatch) s = urlMatch[1];
+  if (s.startsWith("@")) s = s.slice(1);
+  s = s.replace(/\/+$/, "").trim();
+  if (!/^[A-Za-z0-9._]{1,30}$/.test(s)) {
+    throw new Error("Invalid Instagram handle.");
+  }
+  return s.toLowerCase();
+}
+function extractOwnerUsername(html) {
+  const ownerMatch = /"owner":\{[^}]*"username":"([A-Za-z0-9._]+)"/.exec(html);
+  if (ownerMatch?.[1]) return ownerMatch[1].toLowerCase();
+  const userMatch = /"user":\{[^}]*"username":"([A-Za-z0-9._]+)"/.exec(html);
+  if (userMatch?.[1]) return userMatch[1].toLowerCase();
+  return void 0;
+}
+function displayUrlFromProfileUser(user, shortcode) {
+  const edges = user?.edge_owner_to_timeline_media?.edges ?? [];
+  for (const edge of edges) {
+    const node = edge.node;
+    if (node?.shortcode === shortcode && node.display_url) {
+      return node.display_url;
+    }
+  }
+  return void 0;
+}
+function profileApiHeaders(handle) {
+  const profileUrl = `https://www.instagram.com/${handle}/`;
+  return {
+    Accept: "*/*",
+    "Accept-Language": "en-US,en;q=0.9",
+    "User-Agent": BROWSER_UA,
+    "X-IG-App-ID": IG_APP_ID,
+    "X-Requested-With": "XMLHttpRequest",
+    Referer: profileUrl,
+    Origin: "https://www.instagram.com"
+  };
+}
+var PROFILE_FETCH_RETRIES = 2;
+var PROFILE_RETRY_DELAY_MS = 2500;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchProfileUserOnce(fetchFn, handle) {
+  const username = normalizeInstagramHandle(handle);
+  const apiUrl = `https://www.instagram.com/api/v1/users/web_profile_info/?username=${encodeURIComponent(username)}`;
+  const res = await fetchFn(apiUrl, {
+    method: "GET",
+    redirect: "follow",
+    headers: profileApiHeaders(username)
+  });
+  const httpStatus = res.status;
+  if (!res.ok) {
+    return {
+      ok: false,
+      httpStatus,
+      retryable: httpStatus === 429 || httpStatus === 503
+    };
+  }
+  let payload;
+  try {
+    payload = await res.json();
+  } catch {
+    return { ok: false, httpStatus };
+  }
+  const user = payload?.data?.user;
+  if (!user) {
+    return { ok: false, httpStatus };
+  }
+  return { ok: true, user, httpStatus };
+}
+async function fetchProfileDisplayUrl(fetchFn, handle, shortcode) {
+  const username = normalizeInstagramHandle(handle);
+  let lastHttpStatus;
+  let rateLimited = false;
+  for (let attempt = 0; attempt <= PROFILE_FETCH_RETRIES; attempt++) {
+    if (attempt > 0) {
+      await sleep(PROFILE_RETRY_DELAY_MS * attempt);
+    }
+    const result = await fetchProfileUserOnce(fetchFn, username);
+    if (result.ok) {
+      const url = displayUrlFromProfileUser(result.user, shortcode);
+      if (url) {
+        return { url, httpStatus: result.httpStatus };
+      }
+      return { httpStatus: result.httpStatus, shortcodeMissing: true };
+    }
+    lastHttpStatus = result.httpStatus;
+    if (result.httpStatus === 429 || result.httpStatus === 503) {
+      rateLimited = true;
+    }
+    if (!result.retryable) break;
+  }
+  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) {
+          const url = displayUrlFromProfileUser(curlResult.user, shortcode);
+          if (url) {
+            return { url, httpStatus: curlResult.httpStatus };
+          }
+          return {
+            httpStatus: curlResult.httpStatus,
+            shortcodeMissing: true
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    httpStatus: lastHttpStatus,
+    rateLimited,
+    shortcodeMissing: false
+  };
+}
+
+// src/parse-instagram-post.ts
+var INSTAGRAM_POST_RE = /(?:https?:\/\/)?(?:www\.)?instagram\.com\/(?:p|reel|tv)\/([A-Za-z0-9_-]+)/i;
+var BROWSER_UA2 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+var HTML_ENTITIES = {
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#x2019;": "'",
+  "&#x2018;": "'",
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&#10;": "\n",
+  "&#13;": "\r"
+};
+function parseInstagramPostUrl(raw) {
+  const trimmed = raw.trim();
+  const match = INSTAGRAM_POST_RE.exec(trimmed);
+  if (!match?.[1]) {
+    throw new Error(
+      "Paste a valid Instagram post URL (e.g. https://www.instagram.com/p/SHORTCODE/)."
+    );
+  }
+  const shortcode = match[1];
+  return {
+    shortcode,
+    postUrl: `https://www.instagram.com/p/${shortcode}/`
+  };
+}
+function decodeHtmlEntities(text) {
+  let out = text;
+  for (const [entity, char] of Object.entries(HTML_ENTITIES)) {
+    out = out.split(entity).join(char);
+  }
+  out = out.replace(
+    /&#(\d+);/g,
+    (_, code) => String.fromCharCode(Number(code))
+  );
+  out = out.replace(
+    /&#x([0-9a-f]+);/gi,
+    (_, hex) => String.fromCharCode(parseInt(hex, 16))
+  );
+  return out;
+}
+function extractMetaContent(html, property) {
+  const escaped = property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const patterns = [
+    new RegExp(`property="${escaped}"\\s+content="([^"]*)"`, "i"),
+    new RegExp(`content="([^"]*)"\\s+property="${escaped}"`, "i")
+  ];
+  for (const re of patterns) {
+    const match = re.exec(html);
+    if (match?.[1]) return match[1];
+  }
+  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",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Cache-Control": "no-cache",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": referer ? "same-origin" : "none",
+    "Upgrade-Insecure-Requests": "1",
+    "User-Agent": BROWSER_UA2,
+    ...referer ? { Referer: referer } : {}
+  };
+}
+function instagramImageFetchHeaders(referer) {
+  return {
+    Accept: "image/avif,image/webp,image/apng,image/*,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Cache-Control": "no-cache",
+    Referer: referer,
+    "Sec-Fetch-Dest": "image",
+    "Sec-Fetch-Mode": "no-cors",
+    "Sec-Fetch-Site": "cross-site",
+    "User-Agent": BROWSER_UA2
+  };
+}
+function cookieHeaderFromResponse(res) {
+  const headers = res.headers;
+  const getSetCookie = headers.getSetCookie?.bind(headers);
+  const cookies = getSetCookie?.();
+  if (cookies?.length) {
+    return cookies.map((c) => c.split(";")[0]).join("; ");
+  }
+  const single = headers.get("set-cookie");
+  return single ? single.split(";")[0] : void 0;
+}
+async function downloadPostImage(fetchFn, imageUrl, postUrl, cookieHeader) {
+  const headers = {
+    ...instagramImageFetchHeaders(postUrl)
+  };
+  if (cookieHeader) {
+    headers.Cookie = cookieHeader;
+  }
+  const res = await fetchFn(imageUrl, { method: "GET", headers });
+  if (!res.ok) {
+    return void 0;
+  }
+  const contentType = res.headers.get("content-type") ?? "image/jpeg";
+  if (!contentType.startsWith("image/")) {
+    return void 0;
+  }
+  return { bytes: await res.arrayBuffer(), contentType };
+}
+function extractCaptionFromOgDescription(description) {
+  const decoded = decodeHtmlEntities(description).trim();
+  const quoted = decoded.match(/:\s*["“]([\s\S]+?)["”]\.\s*$/);
+  if (quoted?.[1]) return quoted[1].trim();
+  const inline = decoded.match(/:\s*["“]([\s\S]+?)["”]/);
+  if (inline?.[1]) return inline[1].trim();
+  return decoded;
+}
+async function fetchInstagramPost(postUrl, fetchFn, options = {}) {
+  const { shortcode } = parseInstagramPostUrl(postUrl);
+  const canonicalUrl = `https://www.instagram.com/p/${shortcode}/`;
+  await primeInstagramSession(fetchFn);
+  const res = await fetchFn(canonicalUrl, {
+    method: "GET",
+    redirect: "follow",
+    headers: instagramFetchHeaders("https://www.instagram.com/")
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Instagram returned HTTP ${res.status}. Try again in a few minutes if rate-limited.`
+    );
+  }
+  const html = await res.text();
+  const ogDescription = extractMetaContent(html, "og:description");
+  if (!ogDescription) {
+    throw new Error(
+      "Could not read caption from the Instagram page. The post may be private or unavailable."
+    );
+  }
+  const caption = extractCaptionFromOgDescription(ogDescription);
+  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(
+      fetchFn,
+      ownerHandle,
+      shortcode
+    );
+    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.";
+      }
+    }
+  }
+  let imageBytes;
+  let imageContentType;
+  if (displayUrl) {
+    const downloaded = await downloadPostImage(
+      fetchFn,
+      displayUrl,
+      canonicalUrl,
+      cookieHeader
+    );
+    imageBytes = downloaded?.bytes;
+    imageContentType = downloaded?.contentType;
+  }
+  return {
+    shortcode,
+    postUrl: canonicalUrl,
+    caption,
+    displayUrl,
+    isVideo,
+    imageNotice,
+    imageBytes,
+    imageContentType
+  };
+}
+var instagramBrowserUserAgent = BROWSER_UA2;
+
+// src/sandbox-entry.ts
+var DEFAULT_COLLECTION = "posts";
+var PARSE_CACHE_PREFIX = "parse:";
+var IMPORT_MAP_PREFIX = "imported:";
+async function collectionSlug(ctx) {
+  return await ctx.kv.get("config:collection") ?? DEFAULT_COLLECTION;
+}
+function parseCacheKey(shortcode) {
+  return `${PARSE_CACHE_PREFIX}${shortcode}`;
+}
+function importMapKey(shortcode) {
+  return `${IMPORT_MAP_PREFIX}${shortcode}`;
+}
+async function httpFetch(ctx, url, init) {
+  if (!ctx.http) {
+    throw new Error("Network access is not available for this plugin.");
+  }
+  return ctx.http.fetch(url, init);
+}
+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
+  });
+  const recipe = buildParsedRecipeFromPost({
+    shortcode: post.shortcode,
+    caption: post.caption,
+    displayUrl: post.displayUrl,
+    likes: 0,
+    isVideo: post.isVideo,
+    postUrl: post.postUrl
+  }) ?? buildParsedRecipeFromPostLenient({
+    shortcode: post.shortcode,
+    caption: post.caption,
+    displayUrl: post.displayUrl,
+    likes: 0,
+    isVideo: post.isVideo,
+    postUrl: post.postUrl
+  });
+  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."
+    );
+  }
+  if (post.imageNotice) {
+    recipe.image_notice = post.imageNotice;
+  }
+  if (recipe.featured_image) {
+    const uploaded = await uploadFeaturedImageForRecipe(
+      ctx,
+      recipe,
+      post.imageBytes,
+      post.imageContentType
+    );
+    if (uploaded) {
+      recipe.featured_image.emdash_media = uploaded;
+    } else if (recipe.featured_image.url) {
+      recipe.featured_image.upload_failed = true;
+    }
+  }
+  await ctx.kv.set(parseCacheKey(post.shortcode), recipe);
+  const existingContentId = await ctx.kv.get(importMapKey(post.shortcode)) ?? void 0;
+  return { recipe, existingContentId };
+}
+async function uploadFeaturedImageBytes(ctx, recipe, bytes, contentType) {
+  if (!ctx.media?.upload || !recipe.featured_image) {
+    return void 0;
+  }
+  const filename = recipe.featured_image.filename || `${recipe.suggested_slug}.jpg`;
+  const uploaded = await ctx.media.upload(filename, contentType, bytes);
+  return {
+    provider: "local",
+    id: uploaded.mediaId,
+    src: uploaded.url,
+    mimeType: contentType,
+    meta: { storageKey: uploaded.storageKey }
+  };
+}
+async function uploadFeaturedImageForRecipe(ctx, recipe, imageBytes, imageContentType) {
+  if (!recipe.featured_image || !ctx.media?.upload) {
+    return void 0;
+  }
+  if (imageBytes && imageContentType) {
+    return uploadFeaturedImageBytes(
+      ctx,
+      recipe,
+      imageBytes,
+      imageContentType
+    );
+  }
+  if (!recipe.featured_image.url) {
+    return void 0;
+  }
+  const res = await httpFetch(ctx, recipe.featured_image.url, {
+    headers: {
+      "User-Agent": instagramBrowserUserAgent,
+      Referer: recipe.source.instagram_url,
+      Accept: "image/*,*/*;q=0.8"
+    }
+  });
+  if (!res.ok) {
+    ctx.log.warn(`Featured image download failed: HTTP ${res.status}`);
+    return void 0;
+  }
+  const contentType = res.headers.get("content-type") ?? "image/jpeg";
+  if (!contentType.startsWith("image/")) {
+    ctx.log.warn(
+      `Featured image download returned non-image content-type: ${contentType}`
+    );
+    return void 0;
+  }
+  return uploadFeaturedImageBytes(
+    ctx,
+    recipe,
+    await res.arrayBuffer(),
+    contentType
+  );
+}
+async function createDraftFromRecipe(ctx, shortcode) {
+  if (!ctx.content?.create) {
+    throw new Error("This plugin does not have permission to create content.");
+  }
+  const recipe = await ctx.kv.get(parseCacheKey(shortcode));
+  if (!recipe) {
+    throw new Error(
+      "Parsed recipe expired. Convert the Instagram URL again before creating a draft."
+    );
+  }
+  const collection = await collectionSlug(ctx);
+  let featuredImage = recipe.featured_image?.emdash_media;
+  if (!featuredImage && recipe.featured_image?.url) {
+    featuredImage = await uploadFeaturedImageForRecipe(ctx, recipe);
+  }
+  const data = recipeToPostWriteData(recipe, featuredImage);
+  const item = await ctx.content.create(collection, data);
+  await ctx.kv.set(importMapKey(shortcode), item.id);
+  return {
+    contentId: item.id,
+    title: recipe.title,
+    collection
+  };
+}
+var sandbox_entry_default = {
+  hooks: {
+    "plugin:install": {
+      handler: async (_event, ctx) => {
+        ctx.log.info("Instagram to Recipe plugin installed");
+        const existing = await ctx.kv.get("config:collection");
+        if (!existing) {
+          await ctx.kv.set("config:collection", DEFAULT_COLLECTION);
+        }
+      }
+    }
+  },
+  routes: {
+    parse: {
+      input: z.object({
+        url: z.string().min(1)
+      }),
+      handler: async (routeCtx, ctx) => {
+        const { recipe, existingContentId } = await convertInstagramUrl(
+          ctx,
+          routeCtx.input.url
+        );
+        return { ok: true, recipe, existingContentId };
+      }
+    },
+    "create-draft": {
+      input: z.object({
+        shortcode: z.string().min(1)
+      }),
+      handler: async (routeCtx, ctx) => {
+        const result = await createDraftFromRecipe(ctx, routeCtx.input.shortcode);
+        return { ok: true, ...result };
+      }
+    },
+    admin: {
+      handler: async (routeCtx, ctx) => {
+        const interaction = routeCtx.input ?? { type: "page_load" };
+        if (interaction.type === "page_load") {
+          return { blocks: importFormBlocks() };
+        }
+        const instagramUrl = String(
+          interaction.values?.instagram_url ?? ""
+        ).trim();
+        if (interaction.type === "form_submit" && interaction.action_id === "convert") {
+          try {
+            if (!instagramUrl) {
+              return {
+                blocks: errorBlocks("Paste an Instagram post URL."),
+                toast: { message: "URL required", type: "error" }
+              };
+            }
+            parseInstagramPostUrl(instagramUrl);
+            const { recipe, existingContentId } = await convertInstagramUrl(
+              ctx,
+              instagramUrl
+            );
+            return {
+              blocks: previewBlocks(recipe, { existingContentId }),
+              toast: { message: "Recipe parsed", type: "success" }
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              blocks: errorBlocks(message, instagramUrl),
+              toast: { message, type: "error" }
+            };
+          }
+        }
+        if ((interaction.type === "block_action" || interaction.type === "button_click") && interaction.action_id === "create_draft") {
+          const shortcode = String(interaction.value ?? "").trim();
+          if (!shortcode) {
+            return {
+              blocks: errorBlocks(
+                "Missing post reference. Convert the URL again.",
+                instagramUrl
+              ),
+              toast: { message: "Try converting again", type: "error" }
+            };
+          }
+          try {
+            const { contentId, title, collection } = await createDraftFromRecipe(ctx, shortcode);
+            const recipe = await ctx.kv.get(parseCacheKey(shortcode));
+            return {
+              blocks: recipe ? [
+                ...previewBlocks(recipe, { existingContentId: contentId }),
+                {
+                  type: "banner",
+                  title: "Draft created",
+                  description: `\u201C${title}\u201D was saved to ${collection}. Open Posts in the admin to review and publish.`,
+                  variant: "default"
+                }
+              ] : importFormBlocks(),
+              toast: {
+                message: `Draft created: ${title}`,
+                type: "success"
+              }
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              blocks: errorBlocks(message, instagramUrl),
+              toast: { message, type: "error" }
+            };
+          }
+        }
+        return { blocks: importFormBlocks(instagramUrl) };
+      }
+    }
+  }
+};
+export {
+  sandbox_entry_default as default
+};