@wix/agent-skills 1.36.0 → 1.36.1

package/skills/wix-vibe-headless/references/blog/app/rest/wix-blog.js

@@ -1,217 +0,0 @@
-import { wixApiRequest } from "./wix-client.js";
-
-/**
- * Wix Blog Post — key fields.
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/blog/posts-stats/post-object.md
- *
- *   id {string}, title {string}, slug {string},
- *   excerpt {string} — short summary ≤500 chars (use for cards),
- *   firstPublishedDate {string} — ISO date, default sort key DESC,
- *   pinned {boolean}, featured {boolean}, minutesToRead {number},
- *   categoryIds {string[]}, tagIds {string[]}, hashtags {string[]},
- *   media {object} — cover image at media.wixMedia.image { id, url, height, width, filename, altText? };
- *     media.wixMedia.image.url is a ready-to-use https URL (returned by default, incl. the list query).
- *     media.displayed / media.custom are booleans,
- *   contentText {string} — plain text body (CONTENT_TEXT fieldset; getPostBySlug requests it),
- *   richContent {object} — Ricos document (RICH_CONTENT fieldset; getPostBySlug requests it),
- *   url {object} — { base, path } live post URL (URL fieldset; build full link as base+path)
- * Available fieldsets: "URL" | "CONTENT_TEXT" | "RICH_CONTENT" | "METRICS" | "SEO"
- *
- * Category: { id, label, slug, description, postCount, displayPosition,
- *   coverImage: { id, url, height, width, altText }, url: { base, path } }
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/blog/category/category-object.md
- *
- * Tag: { id, label, slug, publishedPostCount, url: { base, path } }
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/blog/tags/tag-object.md
- */
-
-const POST_LIST_FIELDSETS = ["URL"];
-const POST_FULL_FIELDSETS = ["URL", "CONTENT_TEXT", "RICH_CONTENT"];
-
-/**
- * Query published posts (one page), newest first (pinned posts lead).
- * Pass `nextCursor` from a previous call back as `cursor` to load the next page.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/posts-stats/query-posts.md
- * @param {{ limit?: number, cursor?: string }} [options]
- * @returns {Promise<{ posts: object[], nextCursor: string|null }>}
- */
-export async function queryPosts({ limit = 100, cursor } = {}) {
-  const res = await wixApiRequest("/v3/posts/query", {
-    method: "POST",
-    body: {
-      fieldsets: POST_LIST_FIELDSETS,
-      query: {
-        cursorPaging: cursor ? { limit, cursor } : { limit },
-        sort: [{ fieldName: "firstPublishedDate", order: "DESC" }],
-      },
-    },
-  });
-  return {
-    posts: res?.posts ?? [],
-    nextCursor: res?.pagingMetadata?.cursors?.next ?? null,
-  };
-}
-
-/**
- * Fetch one post by its URL slug, with full content (contentText + richContent + url).
- * Returns null if no post matches the slug — show a not-found state, never invent a post.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/posts-stats/get-post-by-slug.md
- * @param {string} slug
- * @returns {Promise<object|null>}
- */
-export async function getPostBySlug(slug) {
-  try {
-    const res = await wixApiRequest(`/v3/posts/slugs/${encodeURIComponent(slug)}`, {
-      method: "GET",
-      query: { fieldsets: POST_FULL_FIELDSETS },
-    });
-    return res?.post ?? null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Query published posts in a given category (one page), newest first.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/posts-stats/query-posts.md
- * @param {string} categoryId  Category GUID (`category.id` from queryCategories / getCategoryBySlug).
- * @param {{ limit?: number, cursor?: string }} [options]
- * @returns {Promise<{ posts: object[], nextCursor: string|null }>}
- */
-export async function queryPostsByCategory(categoryId, { limit = 100, cursor } = {}) {
-  const res = await wixApiRequest("/v3/posts/query", {
-    method: "POST",
-    body: {
-      fieldsets: POST_LIST_FIELDSETS,
-      query: {
-        ...(cursor ? {} : { filter: { categoryIds: { $hasSome: [categoryId] } } }),
-        cursorPaging: cursor ? { limit, cursor } : { limit },
-        sort: [{ fieldName: "firstPublishedDate", order: "DESC" }],
-      },
-    },
-  });
-  return {
-    posts: res?.posts ?? [],
-    nextCursor: res?.pagingMetadata?.cursors?.next ?? null,
-  };
-}
-
-/**
- * Query published posts with a given tag (one page), newest first.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/posts-stats/query-posts.md
- * @param {string} tagId  Tag GUID (`tag.id` from queryTags / getTagBySlug).
- * @param {{ limit?: number, cursor?: string }} [options]
- * @returns {Promise<{ posts: object[], nextCursor: string|null }>}
- */
-export async function queryPostsByTag(tagId, { limit = 100, cursor } = {}) {
-  const res = await wixApiRequest("/v3/posts/query", {
-    method: "POST",
-    body: {
-      fieldsets: POST_LIST_FIELDSETS,
-      query: {
-        ...(cursor ? {} : { filter: { tagIds: { $hasSome: [tagId] } } }),
-        cursorPaging: cursor ? { limit, cursor } : { limit },
-        sort: [{ fieldName: "firstPublishedDate", order: "DESC" }],
-      },
-    },
-  });
-  return {
-    posts: res?.posts ?? [],
-    nextCursor: res?.pagingMetadata?.cursors?.next ?? null,
-  };
-}
-
-/**
- * Total number of published posts. Used for empty-state logic (0 → prompt the user to add
- * posts in their Wix dashboard). Never invent posts.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/posts-stats/get-total-posts.md
- * @returns {Promise<number>}
- */
-export async function getTotalPosts() {
-  const res = await wixApiRequest("/blog/v2/stats/posts/total", { method: "GET" });
-  return res?.total ?? 0;
-}
-
-/**
- * Query blog categories (one page), ordered by menu display position.
- * Categories use offset paging (max 100 per page); most blogs have well under 100.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/category/query-categories.md
- * @param {{ limit?: number, offset?: number }} [options]
- * @returns {Promise<{ categories: object[], total: number }>}
- */
-export async function queryCategories({ limit = 100, offset = 0 } = {}) {
-  const res = await wixApiRequest("/blog/v3/categories/query", {
-    method: "POST",
-    body: {
-      fieldsets: ["URL"],
-      query: {
-        paging: { limit, offset },
-        sort: [{ fieldName: "displayPosition", order: "ASC" }],
-      },
-    },
-  });
-  return {
-    categories: res?.categories ?? [],
-    total: res?.pagingMetadata?.total ?? (res?.categories?.length ?? 0),
-  };
-}
-
-/**
- * Get one category by its URL slug. Returns null if not found.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/category/get-category-by-slug.md
- * @param {string} slug
- * @returns {Promise<object|null>}
- */
-export async function getCategoryBySlug(slug) {
-  try {
-    const res = await wixApiRequest(`/blog/v3/categories/slugs/${encodeURIComponent(slug)}`, {
-      method: "GET",
-      query: { fieldsets: ["URL"] },
-    });
-    return res?.category ?? null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Query blog tags (one page), most-used first.
- * Tags use offset paging (max 100 per page).
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/tags/query-tags.md
- * @param {{ limit?: number, offset?: number }} [options]
- * @returns {Promise<{ tags: object[], total: number }>}
- */
-export async function queryTags({ limit = 100, offset = 0 } = {}) {
-  const res = await wixApiRequest("/v3/tags/query", {
-    method: "POST",
-    body: {
-      fieldsets: ["URL"],
-      query: {
-        paging: { limit, offset },
-        sort: [{ fieldName: "publishedPostCount", order: "DESC" }],
-      },
-    },
-  });
-  return {
-    tags: res?.tags ?? [],
-    total: res?.pagingMetadata?.total ?? (res?.tags?.length ?? 0),
-  };
-}
-
-/**
- * Get one tag by its URL slug. Returns null if not found.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/blog/tags/get-tag-by-slug.md
- * @param {string} slug
- * @returns {Promise<object|null>}
- */
-export async function getTagBySlug(slug) {
-  try {
-    const res = await wixApiRequest(`/v3/tags/slugs/${encodeURIComponent(slug)}`, {
-      method: "GET",
-      query: { fieldsets: ["URL"] },
-    });
-    return res?.tag ?? null;
-  } catch {
-    return null;
-  }
-}

package/skills/wix-vibe-headless/references/blog/seed/SEED.md

@@ -1,99 +0,0 @@
-# Blog — seeding
-
-Seed a Wix Blog (Blog V3) by **calling `seed-blog.cjs`** — don't hand-write the REST calls. It's
-a build-time module (run via `exec_tool`, not shipped in the app) that abstracts every Wix Blog
-seed operation. `require` it and call the functions with plain data.
-
-> **NOT yet live-verified — transcribed from `setup-blog.md`.** Endpoints/fields mirror the recipe
-> exactly; if a call returns an unexpected shape, use the documentation skill available in your environment (never guess).
-
-**DEFAULT — one call.** `setupBlog(ctx, plan)` runs the whole flow (memberId → categories/tags →
-posts → covers), keeping every id in memory. Pass category/tag **names** and it resolves them to
-ids internally; a post's `coverImageUrl` is a plain image url that the module imports into Wix Media
-for you (Blog binds the cover by the Wix Media file id, not a url).
-
-```js
-// build-time exec_tool
-const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix");
-const seed = require(require("path").resolve(".agents/skills/wix-vibe-headless/references/blog/seed/seed-blog.cjs"));
-const ctx = { token: accessToken, siteId: WIX_METASITE_ID };
-
-const result = await seed.setupBlog(ctx, {
-  categories: ["Recipes", "Brewing"],   // optional — names, resolved to ids internally
-  posts: [
-    { title: "How We Roast Our Beans", category: "Recipes", tags: ["coffee"],
-      content: [
-        { type: "heading", text: "From farm to cup", level: 2 },
-        { type: "paragraph", text: "Every batch starts with beans from a single estate." },
-        { type: "quote", text: "Great coffee is grown, not made." },
-      ],
-      // cover is optional and attached IN this one call. Pass a plain url — the module imports it to
-      // Wix Media for you (Blog binds the cover by file id). Use the FINAL https://media.base44.com/...
-      // url from the COMPLETED generate_image (it runs in the background while you build — wait for
-      // it), never a still-generating /__generating__/<id>.png placeholder.
-      coverImageUrl: "https://media.base44.com/…",
-    },
-  ],
-});
-// → { posts:[{id,index,success}], categories:[{id,name}], tags:[{id,name}], coversAttached }
-// check each posts[].success (bulk returns 200 even on partial failure).
-```
-
-**Seeding is additive — never delete or overwrite existing content.** Don't clean up, don't remove
-"sample" data, don't reset. Just add.
-
-## Escape hatch — individual functions
-Reach for the functions below only when the one-call `setupBlog` doesn't fit (custom ordering,
-reusing existing ids). `setupBlog` is built from them, in this order:
-
-```js
-const memberId = await seed.getAuthorMemberId(ctx);   // STEP 1 — required for every post create
-
-// STEP 3 (optional): only if the request groups posts (e.g. "Recipes and Brewing sections")
-const cats = await seed.createCategories(ctx, ["Recipes", "Brewing"]);
-
-// STEP 2: bulk for postCount >= 2, single endpoint for 1 — handled inside. content = plain blocks.
-const posts = await seed.createPosts(ctx, [
-  { title: "How We Roast Our Beans", categoryIds: [cats[0].id], content: [
-    { type: "heading", text: "From farm to cup", level: 2 },
-    { type: "paragraph", text: "Every batch starts with beans from a single estate." },
-    { type: "quote", text: "Great coffee is grown, not made." },
-  ] },
-]);   // → [{ id, index, success }] — check each .success (bulk returns 200 even on partial failure)
-
-// optional — import each url to Wix Media (blog binds by file id), then attach covers (PATCH + re-publish)
-const files = await Promise.all(imageUrls.map((u) => seed.importImage(ctx, u)));   // → [{ id, url }]
-await seed.attachPostCovers(ctx, posts.map((p, i) => ({ postId: p.id, fileId: files[i].id })));
-```
-
-## Functions
-| fn | does |
-|---|---|
-| `setupBlog(ctx, plan)` | **DEFAULT** — one call: memberId → categories/tags → posts → covers; names resolved to ids internally → `{posts,categories,tags,coversAttached}` |
-| `getAuthorMemberId(ctx)` | STEP 1 — fetch a real member id for author attribution (throws if none) |
-| `createPosts(ctx, posts, { memberId })` | STEP 2 — auto single-vs-bulk create, published → `[{id,index,success}]` |
-| `createCategories(ctx, names)` | STEP 3 — sequential creates → `[{id,name}]` (feed into `post.categoryIds`) |
-| `createTags(ctx, names)` | STEP 3 — sequential creates → `[{id,name}]` (feed into `post.tagIds`) |
-| `importImage(ctx, url)` | import an external url into Wix Media → `{id,url}` (file id + wixstatic url); blog binds the cover by this file id |
-| `attachPostCovers(ctx, [{postId,fileId}])` | optional — PATCH cover (`displayed+custom+wixMedia.image.id`) + re-publish; `fileId` MUST be a Wix Media file id from `importImage` |
-
-`content` blocks: `{type:"heading",text,level?}` · `{type:"paragraph",text}` · `{type:"quote",text}` ·
-`{type:"bulleted"|"ordered",items:[…]}`. For node types the recipe doesn't cover (code, images),
-pass a pre-built Ricos `richContent` on the post instead. `setupBlog` **installs the Wix Blog app
-first** (`installBlogApp`, idempotent), so seeding works even if the site doesn't have it yet.
-
-## Reference
-If a call returns a shape you didn't expect, or you need an operation this module doesn't cover,
-use the documentation skill available in your environment to search + read the live Wix Blog API reference — never guess. The
-authoritative source recipe is `wix-headless/references/inline-recipes/setup-blog.md`.
-
-Read a method's page before writing its call: it carries the exact body shape, the required
-permission scope, and the response envelope.
-- Install a Wix app onto the site: https://dev.wix.com/docs/api-reference/business-management/app-installation/app-installation/install-app.md
-- Import an image into Wix Media: https://dev.wix.com/docs/api-reference/assets/media/media-manager/files/import-file.md
-- Bulk Create Draft Posts: https://dev.wix.com/docs/api-reference/business-solutions/blog/draft-posts/bulk-create-draft-posts.md
-- Create Draft Post: https://dev.wix.com/docs/api-reference/business-solutions/blog/draft-posts/create-draft-post.md
-- Publish Draft Post: https://dev.wix.com/docs/api-reference/business-solutions/blog/draft-posts/publish-draft-post.md
-- Create Category: https://dev.wix.com/docs/api-reference/business-solutions/blog/category/create-category.md
-- Create Tag: https://dev.wix.com/docs/api-reference/business-solutions/blog/tags/create-tag.md
-- Create Member (post authors): https://dev.wix.com/docs/api-reference/crm/members-contacts/members/member-management/members/create-member.md

package/skills/wix-vibe-headless/references/blog/seed/seed-blog.cjs

@@ -1,269 +0,0 @@
-// Blog seed helpers — run at BUILD TIME via exec_tool (NOT shipped in the app).
-// The agent requires this and calls the functions with plain data; all Wix Blog V3
-// request/response mechanics (the required author memberId, single-vs-bulk endpoint switch,
-// the flat-per-item bulk shape, Ricos richContent nesting, sequential category/tag creates,
-// the cover-image PATCH + re-publish) live here, once.
-//
-// Usage (build-time exec_tool):
-//   const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix");  // Base44
-//   const seed = require("/app/.agents/skills/wix-vibe-headless/references/blog/seed/seed-blog.cjs");
-//   const ctx = { token: accessToken, siteId: WIX_METASITE_ID };
-//   const memberId = await seed.getAuthorMemberId(ctx);                    // STEP 1 — required for every post
-//   const cats = await seed.createCategories(ctx, ["Recipes", "Brewing"]); // STEP 3 — only if the brief groups posts
-//   const posts = await seed.createPosts(ctx, [
-//     { title: "How We Roast Our Beans", categoryIds: [cats[0].id], content: [
-//       { type: "heading", text: "From farm to cup", level: 2 },
-//       { type: "paragraph", text: "Every batch starts with beans from a single estate." },
-//       { type: "quote", text: "Great coffee is grown, not made." },
-//     ] },
-//   ], { memberId });
-//   // optional — import each image url to Wix Media (blog binds by file id), then attach covers + re-publish
-//   const files = await Promise.all(imageUrls.map((u) => seed.importImage(ctx, u)));   // → [{ id, url }]
-//   await seed.attachPostCovers(ctx, posts.map((p, i) => ({ postId: p.id, fileId: files[i].id })));
-//
-// Live-verified end-to-end (members author, categories, posts single+bulk, tags, covers, idempotent
-// re-runs). If any call ever fails with a shape the caller didn't expect, fall back to the documentation skill available in your environment (search + read the live Wix Blog API reference) — never guess. Source recipe:
-// wix-headless/references/inline-recipes/setup-blog.md.
-
-const API = "https://www.wixapis.com";
-const BLOG_APP_ID = "14bcded7-0066-7c35-14d7-466cb3f09103"; // installBlogApp installs this before seeding
-
-async function req(ctx, path, { method = "POST", body } = {}) {
-  const res = await fetch(API + path, {
-    method,
-    headers: {
-      Authorization: `Bearer ${ctx.token}`,
-      "wix-site-id": ctx.siteId,
-      "Content-Type": "application/json",
-    },
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  const json = await res.json().catch(() => ({}));
-  if (!res.ok) throw new Error(`${method} ${path} -> ${res.status}: ${JSON.stringify(json).slice(0, 400)}`);
-  return json;
-}
-
-// ---- Ricos richContent builder (per recipe § "CRITICAL RICOS NESTING") ----
-// A post's `content` is a list of plain block descriptors; this builds the Ricos node tree.
-// Rules baked in: TEXT is always a leaf inside a container; BLOCKQUOTE / LIST_ITEM wrap a
-// PARAGRAPH; BULLETED_LIST / ORDERED_LIST wrap LIST_ITEM -> PARAGRAPH -> TEXT; every container
-// node gets a unique id, TEXT leaves use id "". Supported block types: heading, paragraph,
-// quote, bulleted, ordered. For node types the recipe doesn't spell out (CODE_BLOCK, IMAGE, …)
-// pass a pre-built `richContent` on the post instead and it's used verbatim (see fall-back below).
-const mkText = (text) => ({ type: "TEXT", id: "", nodes: [], textData: { text: text || "", decorations: [] } });
-const mkParagraph = (id, text) => ({ type: "PARAGRAPH", id, nodes: [mkText(text)], paragraphData: {} });
-
-function mkRichContent(blocks = [], postIdx = 0) {
-  let n = 0;
-  const id = () => `p${postIdx}-n${n++}`;
-  const nodes = [];
-  for (const b of blocks) {
-    switch (b.type) {
-      case "heading":
-        nodes.push({ type: "HEADING", id: id(), nodes: [mkText(b.text)], headingData: { level: b.level ?? 2 } });
-        break;
-      case "quote":
-        // BLOCKQUOTE wraps a PARAGRAPH, per recipe
-        nodes.push({ type: "BLOCKQUOTE", id: id(), nodes: [mkParagraph(id(), b.text)], blockquoteData: { indentation: 1 } });
-        break;
-      case "bulleted":
-      case "ordered": {
-        // LIST -> LIST_ITEM -> PARAGRAPH -> TEXT, per recipe
-        const listType = b.type === "bulleted" ? "BULLETED_LIST" : "ORDERED_LIST";
-        nodes.push({
-          type: listType, id: id(),
-          nodes: (b.items ?? []).map((item) => ({ type: "LIST_ITEM", id: id(), nodes: [mkParagraph(id(), item)] })),
-        });
-        break;
-      }
-      case "paragraph":
-      default:
-        nodes.push(mkParagraph(id(), b.text));
-    }
-  }
-  return { nodes };
-}
-
-// One post's plain data -> a flat Blog V3 draft-post object.
-// `content` (block list) is turned into Ricos richContent unless a pre-built `richContent` is given.
-// media is omitted here — covers are a separate pass (attachPostCovers), optional (a separate covers pass). Per recipe.
-function buildPost(p, i, memberId) {
-  return {
-    title: p.title,
-    memberId,
-    richContent: p.richContent ?? mkRichContent(p.content, i),
-    ...(p.categoryIds ? { categoryIds: p.categoryIds } : {}),
-    ...(p.tagIds ? { tagIds: p.tagIds } : {}),
-  };
-}
-
-// ---- exported operations ----
-
-// STEP 1: fetch a real author memberId (required — every post create needs it; a fabricated id
-// fails with "memberIds ... do not exist"). Returns members[0].id; throws loudly if none exist.
-async function getAuthorMemberId(ctx) {
-  const r = await req(ctx, "/members/v1/members?fieldsets=PUBLIC&paging.limit=1", { method: "GET" });
-  const id = r.members?.[0]?.id;
-  if (!id) throw new Error(`No site member found for author attribution: ${JSON.stringify(r).slice(0, 400)}`);
-  return id;
-}
-
-/**
- * STEP 2: create posts, published (publish:true so they go live immediately).
- * Auto-selects the endpoint per recipe: single-post endpoint for exactly one post (nested
- * `{ draftPost }` envelope), the bulk endpoint for >= 2 (flat per-item objects, NOT wrapped).
- * @param posts [{ title, content: [blocks] | richContent?, categoryIds?, tagIds? }]
- *   content blocks: { type:"heading", text, level? } | { type:"paragraph", text }
- *     | { type:"quote", text } | { type:"bulleted"|"ordered", items:[text,...] }.
- *   Pass a pre-built Ricos `richContent` instead of `content` for node types not covered here.
- * @param opts { memberId }  memberId from getAuthorMemberId — required; publish defaults to true.
- * @returns [{ id, index, success }]  (id is the draftPostId; feeds attachPostCovers)
- */
-async function createPosts(ctx, posts, { memberId, publish = true } = {}) {
-  if (!memberId) throw new Error("createPosts requires opts.memberId (see getAuthorMemberId)");
-  if (posts.length === 1) {
-    // single-post endpoint uses the nested { draftPost } envelope
-    const r = await req(ctx, "/blog/v3/draft-posts", { body: { draftPost: buildPost(posts[0], 0, memberId), publish } });
-    return [{ id: r.draftPost?.id, index: 0, success: !!r.draftPost?.id }];
-  }
-  // bulk endpoint: `bulk` is a path segment BETWEEN v3 and draft-posts; each item is FLAT (no draftPost wrapper)
-  const r = await req(ctx, "/blog/v3/bulk/draft-posts/create", {
-    body: { draftPosts: posts.map((p, i) => buildPost(p, i, memberId)), publish },
-  });
-  // Bulk returns 200 even on partial failure — read per-item results[].itemMetadata.success.
-  return (r.results ?? []).map((x) => ({
-    id: x.itemMetadata?.id, index: x.itemMetadata?.originalIndex, success: !!x.itemMetadata?.success,
-  }));
-}
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-// Existing label -> id, straight from the query (the source of truth for what actually persisted).
-async function labelIdMap(ctx, kind) {
-  const path = kind === "categories" ? "/blog/v3/categories/query" : "/v3/tags/query";
-  const r = await req(ctx, path, { body: { query: { paging: { limit: 100 } } } });
-  return new Map((r[kind] ?? []).map((x) => [x.label, x.id]));
-}
-
-// Create category/tag labels resiliently. TWO hazards this absorbs:
-//  1. Fresh-install provisioning window — for a few seconds after the Blog app is installed, per-item
-//     category/tag creates return 200 with an id but DON'T persist (last-write-wins; the id is a lie).
-//     Posts (bulk) are unaffected. So we never trust the create response — we re-query and treat what
-//     the query returns as truth, re-creating anything still missing until it sticks (store warms in ~s).
-//  2. Idempotency — an already-present label (e.g. a partial-failure re-run) is skipped, not re-created.
-// Category bodies are NESTED (`{ category: { label } }`); tag bodies are FLAT (`{ label }`) — a
-// `{ tag: { label } }` body sends an empty top-level label and 400s. Returns [{ id, name }].
-async function ensureLabels(ctx, kind, createPath, mkBody, names) {
-  let map = await labelIdMap(ctx, kind);
-  for (let attempt = 0; attempt < 8; attempt++) {
-    const missing = names.filter((n) => !map.has(n));
-    if (!missing.length) break;
-    if (attempt) await sleep(1500); // backoff only between retries — happy path pays nothing
-    for (const name of missing) {
-      try { await req(ctx, createPath, { body: mkBody(name) }); }
-      catch (e) { if (!String(e.message).includes("-> 409")) throw e; } // 409 = raced, already there
-    }
-    map = await labelIdMap(ctx, kind);
-  }
-  return names.map((name) => ({ id: map.get(name), name }));
-}
-
-// STEP 3 (optional — only if the request groups posts): create categories. No bulk endpoint.
-async function createCategories(ctx, names) {
-  return ensureLabels(ctx, "categories", "/blog/v3/categories", (name) => ({ category: { label: name } }), names);
-}
-
-// STEP 3 (optional): create tags. Feed the returned ids into post.tagIds.
-async function createTags(ctx, names) {
-  return ensureLabels(ctx, "tags", "/blog/v3/tags", (name) => ({ label: name }), names);
-}
-
-// Import an external image URL into Wix Media → { id, url }. Blog binds the cover by the Wix Media
-// file **id**, NOT a url — an external url (e.g. a base44 generate_image result) MUST be imported
-// first; the raw url renders nothing. id = wixstatic file id, url = the permanent wixstatic url.
-async function importImage(ctx, url, displayName = "image.png") {
-  const r = await req(ctx, "/site-media/v1/files/import", { body: { url, mimeType: "image/png", displayName } });
-  const f = r.file || r;
-  if (!f?.id) throw new Error(`import-file returned no file id: ${JSON.stringify(r).slice(0, 200)}`);
-  return { id: f.id, url: f.url };
-}
-
-// Attach images step (optional). covers: [{ postId, fileId }] where fileId is the WixMedia
-// file.id from importImage (Blog binds the cover by id, not url). Per post:
-//   PATCH /blog/v3/draft-posts/{id}  (NOT POST …/{id}/update — that 404s for a single post),
-// setting media.displayed:true + media.custom:true + wixMedia.image.id (id ALONE is a silent no-op),
-// then re-publish (the PATCH sets hasUnpublishedChanges, so the live post stays cover-less until republish).
-// Image failures never block the run — skip a failed cover, leave the post text-only.
-async function attachPostCovers(ctx, covers) {
-  for (const { postId, fileId } of covers) {
-    try {
-      await req(ctx, `/blog/v3/draft-posts/${postId}`, {
-        method: "PATCH",
-        body: { draftPost: { media: { displayed: true, custom: true, wixMedia: { image: { id: fileId } } } } },
-      });
-      await req(ctx, `/blog/v3/draft-posts/${postId}/publish`, { method: "POST" });
-    } catch (e) {
-      console.warn(`cover attach skipped for post ${postId}: ${e.message}`);
-    }
-  }
-}
-
-/**
- * DEFAULT one-call path — seed a whole blog in ONE exec call. Resolves the author memberId and
- * category/tag names → ids internally and keeps every id in memory, so nothing is hand-threaded
- * across exec calls. Order: memberId → categories/tags → posts (with resolved ids) → covers.
- * @param plan {
- *   posts: [{ title, content?|richContent?, category?|categories?(name|names), tags?(names), coverImageUrl? }],
- *   categories?: [name],  // pre-create categories even if no post references them
- *   tags?: [name],
- * }
- *   category/categories/tags are display NAMES (resolved to ids here); coverImageUrl is a plain image
- *   url — imported to Wix Media here — and a cover is attached only for posts that provide one.
- * @returns { posts:[{id,index,success}], categories:[{id,name}], tags:[{id,name}], coversAttached }
- */
-// Install the Wix Blog app before seeding — base44 sites aren't guaranteed to have it (no separate
-// Setup step here, unlike the wix-headless recipe). Idempotent: re-installing returns 200.
-async function installBlogApp(ctx) {
-  return req(ctx, "/apps-installer-service/v1/app-instance/install", { body: {
-    tenant: { tenantType: "SITE", id: ctx.siteId },
-    appInstance: { appDefId: BLOG_APP_ID, enabled: true },
-  } });
-}
-
-async function setupBlog(ctx, { posts = [], categories = [], tags = [] } = {}) {
-  await installBlogApp(ctx);
-  await sleep(3000); // let a fresh Blog install settle so the first category/tag writes stick (see ensureLabels);
-                     // correctness is still guaranteed by ensureLabels' verify-retry — this just cuts the retries.
-  const memberId = await getAuthorMemberId(ctx);
-  const catNames = [...new Set([...categories, ...posts.flatMap((p) => [].concat(p.category ?? [], p.categories ?? []))])];
-  const tagNames = [...new Set([...tags, ...posts.flatMap((p) => [].concat(p.tags ?? []))])];
-  const cats = catNames.length ? await createCategories(ctx, catNames) : [];
-  const tgs = tagNames.length ? await createTags(ctx, tagNames) : [];
-  const catId = new Map(cats.map((c) => [c.name, c.id]));
-  const tagId = new Map(tgs.map((t) => [t.name, t.id]));
-  const created = await createPosts(ctx, posts.map((p) => {
-    const cn = [].concat(p.category ?? [], p.categories ?? []);
-    const tn = [].concat(p.tags ?? []);
-    return {
-      ...p,
-      ...(cn.length ? { categoryIds: cn.map((n) => catId.get(n)).filter(Boolean) } : {}),
-      ...(tn.length ? { tagIds: tn.map((n) => tagId.get(n)).filter(Boolean) } : {}),
-    };
-  }), { memberId });
-  const covers = [];
-  for (let i = 0; i < created.length; i++) {
-    const url = posts[i]?.coverImageUrl;
-    if (!created[i]?.id || !url) continue;
-    try {
-      const file = await importImage(ctx, url, `post-${i}.png`);   // → Wix Media file id
-      covers.push({ postId: created[i].id, fileId: file.id });
-    } catch { /* never block on image failure — leave the post cover-less */ }
-  }
-  if (covers.length) await attachPostCovers(ctx, covers);
-  return { posts: created, categories: cats, tags: tgs, coversAttached: covers.length };
-}
-
-module.exports = {
-  setupBlog, installBlogApp,
-  getAuthorMemberId, createPosts, createCategories, createTags, importImage, attachPostCovers,
-};