@artinstack/migrator 0.1.1 → 0.1.3

package/dist/chunk-QEXTXHFG.js

@@ -0,0 +1,2444 @@
+import {
+  SquarespaceCollectionClient,
+  enumerateSquarespaceEntities,
+  linkToPath,
+  sanitizeSlug,
+  summarizeSquarespaceExport,
+  validateSquarespaceExportFile
+} from "./chunk-HH7666MQ.js";
+import {
+  discoverContentAssetUrls,
+  normalizeAssetUrl
+} from "./chunk-2PNSVE5Y.js";
+
+// src/lib/origin-url-rewrite.ts
+function rewriteOriginUrlsInText(text, config) {
+  if (!text || config.rules.length === 0) return text;
+  let result = text;
+  for (const rule of config.rules) {
+    if (typeof rule.match === "string") {
+      if (!rule.match) continue;
+      result = result.split(rule.match).join(rule.replace);
+      continue;
+    }
+    result = result.replace(rule.match, rule.replace);
+  }
+  return result;
+}
+function createWpContentGatewayRewrite(gatewayBase, publicOrigin) {
+  const normalizedGateway = gatewayBase.replace(/\/$/, "");
+  const normalizedPublic = publicOrigin.replace(/\/$/, "");
+  return {
+    rules: [
+      {
+        match: `${normalizedGateway}/wp-content/`,
+        replace: `${normalizedPublic}/wp-content/`
+      }
+    ]
+  };
+}
+
+// src/parsers/wordpress/parse-wxr.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+import { XMLParser } from "fast-xml-parser";
+
+// src/parsers/wordpress/builders/registry.ts
+var WORDPRESS_BUILDER_REGISTRY = [
+  {
+    id: "tatsu",
+    detect: /\[(?:\/)?tatsu_/i,
+    contentRules: [
+      { shortcodePrefix: "tatsu_image", urlParams: ["image", "url", "src"], tag: "img" },
+      { shortcodePrefix: "tatsu_video", urlParams: ["video", "src", "url"], tag: "video" }
+    ],
+    scaffoldingPrefix: "tatsu_"
+  },
+  {
+    id: "divi",
+    detect: /\[(?:\/)?et_pb_/i,
+    contentRules: [{ shortcodePrefix: "et_pb_image", urlParams: ["src", "url"], tag: "img" }],
+    scaffoldingPrefix: "et_pb_"
+  },
+  {
+    id: "elementor",
+    detect: /\[(?:\/)?elementor[-_]/i,
+    contentRules: [
+      { shortcodePrefix: "elementor-widget", urlParams: ["url", "src", "image"], tag: "img" }
+    ],
+    scaffoldingPrefix: "elementor_"
+  }
+];
+
+// src/parsers/wordpress/builders/flatten.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractShortcodeParam(params, names) {
+  for (const name of names) {
+    const pattern = new RegExp(`\\b${escapeRegExp(name)}\\s*=\\s*["']([^"']+)["']`, "i");
+    const match = params.match(pattern);
+    if (match?.[1]?.trim()) return match[1].trim();
+  }
+  return void 0;
+}
+function emitHtmlTag(tag, url) {
+  const normalized = normalizeAssetUrl(url) ?? url;
+  const escaped = normalized.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+  switch (tag) {
+    case "img":
+      return `<img src="${escaped}" alt="" />`;
+    case "video":
+      return `<video src="${escaped}" controls></video>`;
+    case "iframe":
+      return `<iframe src="${escaped}" loading="lazy"></iframe>`;
+  }
+}
+function convertContentBlocker(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}([^\\]]*)\\]\\s*(?:\\[\\/${prefix}[^\\]]*\\])?`,
+    "gi"
+  );
+  return content.replace(pattern, (block, params) => {
+    const url = extractShortcodeParam(params, rule.urlParams);
+    if (!url) return block;
+    return emitHtmlTag(rule.tag, url);
+  });
+}
+function stripScaffolding(content, prefix) {
+  const escaped = escapeRegExp(prefix);
+  const opener = new RegExp(`\\[${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  const closer = new RegExp(`\\[\\/${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  return content.replace(opener, "").replace(closer, "");
+}
+function detectThemes(content, registry) {
+  return registry.filter((theme) => theme.detect.test(content));
+}
+function flattenWordPressBuilders(content, options = {}) {
+  if (!content.trim()) {
+    return { html: content, detectedThemes: [] };
+  }
+  const registry = options.registry ?? WORDPRESS_BUILDER_REGISTRY;
+  const themes = detectThemes(content, registry);
+  if (themes.length === 0) {
+    return { html: content, detectedThemes: [] };
+  }
+  let html = content;
+  for (const theme of themes) {
+    for (const rule of theme.contentRules) {
+      html = convertContentBlocker(html, rule);
+    }
+    html = stripScaffolding(html, theme.scaffoldingPrefix);
+  }
+  html = html.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    html,
+    detectedThemes: themes.map((theme) => theme.id)
+  };
+}
+
+// src/parsers/wordpress/parse-wxr.ts
+var PLATFORM = "wordpress";
+function asArray(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function textValue(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  if (typeof value === "object" && value !== null && "#text" in value) {
+    return String(value["#text"] ?? "");
+  }
+  return String(value);
+}
+function mapPublishStatus(wpStatus) {
+  switch ((wpStatus ?? "").toLowerCase()) {
+    case "publish":
+      return "published";
+    case "draft":
+    case "pending":
+      return "draft";
+    default:
+      return "archived";
+  }
+}
+function getContentEncoded(item) {
+  const content = item.content;
+  if (content !== void 0) {
+    if (typeof content === "string") return content;
+    return textValue(content.encoded);
+  }
+  return textValue(item.encoded);
+}
+function sourceMeta(id, link, exportedAt) {
+  return {
+    platform: PLATFORM,
+    id,
+    url: link || void 0,
+    path: linkToPath(link),
+    exportedAt
+  };
+}
+function getExcerpt(item) {
+  const excerpt = item.excerpt;
+  if (!excerpt) return "";
+  if (typeof excerpt === "string") return excerpt;
+  return textValue(excerpt.encoded);
+}
+function getPostMeta(item, key) {
+  for (const meta of asArray(item.postmeta)) {
+    if (textValue(meta.meta_key) === key) {
+      return textValue(meta.meta_value);
+    }
+  }
+  return void 0;
+}
+function parseItems(xml) {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    trimValues: false,
+    parseTagValue: false
+  });
+  const doc = parser.parse(xml);
+  return asArray(doc.rss?.channel?.item);
+}
+function buildAttachmentIndex(items, originUrlRewrite) {
+  const index = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (textValue(item.post_type) !== "attachment") continue;
+    const id = textValue(item.post_id);
+    let url = textValue(item.attachment_url) || textValue(item.link);
+    if (!id || !url) continue;
+    if (originUrlRewrite) {
+      url = rewriteOriginUrlsInText(url, originUrlRewrite);
+    }
+    const filename = basename(new URL(url, "http://local.invalid").pathname) || `attachment-${id}`;
+    index.set(id, {
+      sourceUrl: url,
+      filename,
+      mimeType: getPostMeta(item, "_wp_attached_file") ? void 0 : guessMime(filename),
+      title: textValue(item.title)
+    });
+  }
+  return index;
+}
+function guessMime(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const map = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    pdf: "application/pdf"
+  };
+  return ext ? map[ext] : void 0;
+}
+function collectTaxonomies(items) {
+  const categories = /* @__PURE__ */ new Map();
+  const tags = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const postType = textValue(item.post_type);
+    if (postType !== "post" && postType !== "page") continue;
+    for (const cat of asArray(item.category)) {
+      const domain = cat["@_domain"] ?? "";
+      const nicename = sanitizeSlug(cat["@_nicename"] ?? textValue(cat["#text"]));
+      const name = textValue(cat["#text"]) || nicename;
+      if (!nicename) continue;
+      if (domain === "category") {
+        if (!categories.has(nicename)) {
+          categories.set(nicename, {
+            type: "category",
+            source: sourceMeta(`cat:${nicename}`),
+            sourceId: `cat:${nicename}`,
+            name,
+            slug: nicename
+          });
+        }
+      } else if (domain === "post_tag") {
+        if (!tags.has(nicename)) {
+          tags.set(nicename, {
+            type: "tag",
+            source: sourceMeta(`tag:${nicename}`),
+            sourceId: `tag:${nicename}`,
+            name,
+            slug: nicename
+          });
+        }
+      }
+    }
+  }
+  return { categories, tags };
+}
+function collectInlineAssets(html, attachmentIndex, seenUrls, exportedAt) {
+  const assets = [];
+  for (const src of discoverContentAssetUrls(html)) {
+    if (seenUrls.has(src)) continue;
+    seenUrls.add(src);
+    let filename;
+    try {
+      filename = basename(new URL(src, "http://local.invalid").pathname) || "inline-asset";
+    } catch {
+      filename = "inline-asset";
+    }
+    assets.push({
+      type: "asset",
+      source: sourceMeta(`url:${src}`, src, exportedAt),
+      sourceId: `url:${src}`,
+      sourceUrl: src,
+      filename,
+      mimeType: guessMime(filename)
+    });
+  }
+  for (const [id, entry] of attachmentIndex) {
+    if (seenUrls.has(entry.sourceUrl)) continue;
+    void id;
+  }
+  return assets;
+}
+function preprocessContent(rawHtml, options) {
+  let html = rawHtml;
+  if (options.originUrlRewrite) {
+    html = rewriteOriginUrlsInText(html, options.originUrlRewrite);
+  }
+  if (options.flattenBuilders !== false) {
+    html = flattenWordPressBuilders(html).html;
+  }
+  return html;
+}
+function resolveFeaturedAssetSourceId(thumbnailId, attachmentIndex, contentHtml) {
+  if (thumbnailId && attachmentIndex.has(thumbnailId)) {
+    return thumbnailId;
+  }
+  const firstInline = discoverContentAssetUrls(contentHtml)[0];
+  return firstInline ? `url:${firstInline}` : void 0;
+}
+async function* enumerateWxrEntities(options) {
+  const xml = await readFile(options.filePath, "utf8");
+  const items = parseItems(xml);
+  const attachmentIndex = buildAttachmentIndex(items, options.originUrlRewrite);
+  const { categories, tags } = collectTaxonomies(items);
+  const seenAssetUrls = /* @__PURE__ */ new Set();
+  const emittedAttachmentIds = /* @__PURE__ */ new Set();
+  for (const category of categories.values()) {
+    yield category;
+  }
+  for (const tag of tags.values()) {
+    yield tag;
+  }
+  for (const [id, entry] of attachmentIndex) {
+    emittedAttachmentIds.add(id);
+    seenAssetUrls.add(entry.sourceUrl);
+    yield {
+      type: "asset",
+      source: sourceMeta(id, entry.sourceUrl, options.exportedAt),
+      sourceId: id,
+      sourceUrl: entry.sourceUrl,
+      filename: entry.filename,
+      mimeType: entry.mimeType,
+      caption: entry.title
+    };
+  }
+  for (const item of items) {
+    const postType = textValue(item.post_type);
+    if (postType !== "post" && postType !== "page") continue;
+    const id = textValue(item.post_id);
+    const link = textValue(item.link);
+    const slug = sanitizeSlug(textValue(item.post_name) || textValue(item.title) || id);
+    const contentHtml = preprocessContent(getContentEncoded(item), options);
+    for (const asset of collectInlineAssets(
+      contentHtml,
+      attachmentIndex,
+      seenAssetUrls,
+      options.exportedAt
+    )) {
+      yield asset;
+    }
+    const categorySlugs = [];
+    const tagSlugs = [];
+    for (const cat of asArray(item.category)) {
+      const domain = cat["@_domain"] ?? "";
+      const nicename = sanitizeSlug(cat["@_nicename"] ?? textValue(cat["#text"]));
+      if (!nicename) continue;
+      if (domain === "category") categorySlugs.push(nicename);
+      if (domain === "post_tag") tagSlugs.push(nicename);
+    }
+    if (postType === "post") {
+      const thumbnailId = getPostMeta(item, "_thumbnail_id");
+      const featuredAssetSourceId = resolveFeaturedAssetSourceId(
+        thumbnailId,
+        attachmentIndex,
+        contentHtml
+      );
+      const post = {
+        type: "post",
+        source: sourceMeta(id, link, options.exportedAt),
+        sourceId: id,
+        title: textValue(item.title) || slug,
+        slug,
+        excerpt: getExcerpt(item) || void 0,
+        contentHtml,
+        publishedAt: textValue(item.post_date) || void 0,
+        status: mapPublishStatus(textValue(item.status)),
+        categorySlugs: categorySlugs.length ? categorySlugs : void 0,
+        tagSlugs: tagSlugs.length ? tagSlugs : void 0,
+        sourceFeaturedMediaId: thumbnailId,
+        featuredAssetSourceId
+      };
+      yield post;
+    } else {
+      const isHomePage = getPostMeta(item, "_wp_show_on_front") === "1" || getPostMeta(item, "page_on_front") === "1";
+      const page = {
+        type: "page",
+        source: sourceMeta(id, link, options.exportedAt),
+        sourceId: id,
+        title: textValue(item.title) || slug,
+        slug,
+        contentHtml,
+        isHomePage: isHomePage || void 0,
+        status: mapPublishStatus(textValue(item.status))
+      };
+      yield page;
+    }
+  }
+}
+async function validateWxrFile(filePath) {
+  const issues = [];
+  let xml;
+  try {
+    xml = await readFile(filePath, "utf8");
+  } catch {
+    return {
+      ok: false,
+      issues: [{ code: "file_not_found", message: `Cannot read file: ${filePath}` }],
+      summary: {}
+    };
+  }
+  const looksLikeWxr = xml.includes("<rss") && (xml.includes("wp:wxr_version") || xml.includes("xmlns:wp=") || xml.includes("WordPress eXtended RSS"));
+  if (!looksLikeWxr) {
+    issues.push({ code: "invalid_wxr", message: "File does not appear to be WordPress WXR" });
+  }
+  const items = parseItems(xml);
+  const summary = {
+    posts: items.filter((i) => textValue(i.post_type) === "post").length,
+    pages: items.filter((i) => textValue(i.post_type) === "page").length,
+    assets: items.filter((i) => textValue(i.post_type) === "attachment").length,
+    portfolios: 0,
+    categories: 0,
+    tags: 0
+  };
+  const { categories, tags } = collectTaxonomies(items);
+  summary.categories = categories.size;
+  summary.tags = tags.size;
+  return { ok: issues.length === 0, issues, summary };
+}
+
+// src/parsers/wordpress/index.ts
+function resolveWxrOptions(input) {
+  if (typeof input === "string") {
+    return { filePath: input };
+  }
+  if (input && typeof input === "object" && "path" in input) {
+    const obj = input;
+    return {
+      filePath: String(obj.path),
+      originUrlRewrite: obj.originUrlRewrite,
+      flattenBuilders: obj.flattenBuilders
+    };
+  }
+  throw new Error("WordPress adapter requires input path (string or { path, originUrlRewrite?, flattenBuilders? })");
+}
+var wordpressAdapter = {
+  platform: "wordpress",
+  async validateInput(input) {
+    const { filePath } = resolveWxrOptions(input);
+    const result = await validateWxrFile(filePath);
+    return {
+      ok: result.ok,
+      issues: result.issues,
+      summary: result.summary
+    };
+  },
+  enumerateEntities(ctx) {
+    return enumerateWxrEntities(resolveWxrOptions(ctx.input));
+  }
+};
+
+// src/parsers/smugmug/api.ts
+import { createHmac, randomBytes } from "crypto";
+import { z } from "zod";
+var SMUGMUG_API_HOST = "api.smugmug.com";
+var SMUGMUG_API_BASE = `https://${SMUGMUG_API_HOST}/api/v2`;
+var SMUGMUG_OAUTH_ENDPOINTS = {
+  requestToken: "https://api.smugmug.com/services/oauth/1.0a/getRequestToken",
+  authorize: "https://api.smugmug.com/services/oauth/1.0a/authorize",
+  accessToken: "https://api.smugmug.com/services/oauth/1.0a/getAccessToken"
+};
+var smugMugCredentialsSchema = z.object({
+  consumerKey: z.string().min(1),
+  consumerSecret: z.string().min(1),
+  accessToken: z.string().min(1),
+  accessTokenSecret: z.string().min(1)
+});
+var smugMugClientOptionsSchema = z.object({
+  credentials: smugMugCredentialsSchema,
+  pageSize: z.number().int().min(1).max(500).default(100),
+  maxRetries: z.number().int().min(0).max(10).default(3),
+  retryBaseDelayMs: z.number().int().min(0).default(500),
+  maxRetryDelayMs: z.number().int().min(0).default(8e3),
+  requestIntervalMs: z.number().int().min(0).default(200),
+  fetchImpl: z.custom().optional()
+});
+var ALBUM_IMAGES_CONFIG = {
+  expand: {
+    AlbumImage: {
+      expand: {
+        Image: {
+          filter: ["FileName", "Caption", "KeywordsArray"],
+          filteruri: ["ImageMetadata", "ImageSizeDetails"],
+          expand: {
+            ImageMetadata: {
+              filter: ["ISO", "Aperture", "ApertureValue", "ShutterSpeed", "ExposureTime", "FocalLength"]
+            },
+            ImageSizeDetails: {
+              filter: ["OriginalImageUrl"]
+            }
+          }
+        }
+      }
+    }
+  }
+};
+function oauthPercentEncode(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+function normalizeRequestUrl(url) {
+  const protocol = url.protocol.replace(/:$/, "").toLowerCase();
+  const host = url.hostname.toLowerCase();
+  const defaultPort = protocol === "http" ? "80" : "443";
+  const port = url.port && url.port !== defaultPort ? `:${url.port}` : "";
+  return `${protocol}://${host}${port}${url.pathname}`;
+}
+function sortedParameterString(params) {
+  return Object.keys(params).sort((a, b) => a === b ? 0 : a < b ? -1 : 1).map((key) => `${oauthPercentEncode(key)}=${oauthPercentEncode(params[key])}`).join("&");
+}
+function collectSignatureParams(url, oauthParams, bodyParams) {
+  const params = { ...oauthParams };
+  url.searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  if (bodyParams) {
+    for (const [key, value] of Object.entries(bodyParams)) {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+function signSmugMugOAuthRequest(input) {
+  const url = new URL(input.url);
+  const parameterString = sortedParameterString(
+    collectSignatureParams(url, input.oauthParams, input.bodyParams)
+  );
+  const signatureBase = [
+    input.method.toUpperCase(),
+    oauthPercentEncode(normalizeRequestUrl(url)),
+    oauthPercentEncode(parameterString)
+  ].join("&");
+  const signingKey = `${oauthPercentEncode(input.credentials.consumerSecret)}&${oauthPercentEncode(input.credentials.accessTokenSecret)}`;
+  return createHmac("sha1", signingKey).update(signatureBase).digest("base64");
+}
+function buildOAuthParams(credentials, nonce, timestamp) {
+  return {
+    oauth_consumer_key: credentials.consumerKey,
+    oauth_token: credentials.accessToken,
+    oauth_signature_method: "HMAC-SHA1",
+    oauth_timestamp: timestamp,
+    oauth_nonce: nonce,
+    oauth_version: "1.0"
+  };
+}
+function buildSmugMugAuthorizationHeader(input) {
+  const nonce = input.nonce ?? randomBytes(16).toString("hex");
+  const timestamp = input.timestamp ?? String(Math.floor(Date.now() / 1e3));
+  const oauthParams = buildOAuthParams(input.credentials, nonce, timestamp);
+  const signature = signSmugMugOAuthRequest({
+    method: input.method,
+    url: input.url,
+    credentials: input.credentials,
+    oauthParams,
+    bodyParams: input.bodyParams
+  });
+  const headerParams = { ...oauthParams, oauth_signature: signature };
+  const headerValue = Object.keys(headerParams).sort().map((key) => `${oauthPercentEncode(key)}="${oauthPercentEncode(headerParams[key])}"`).join(", ");
+  return `OAuth ${headerValue}`;
+}
+function readSmugMugCredentialsFromEnv(env = process.env) {
+  return smugMugCredentialsSchema.parse({
+    consumerKey: env.SMUGMUG_CONSUMER_KEY,
+    consumerSecret: env.SMUGMUG_CONSUMER_SECRET,
+    accessToken: env.SMUGMUG_ACCESS_TOKEN,
+    accessTokenSecret: env.SMUGMUG_ACCESS_TOKEN_SECRET
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function albumKeyFromUri(uri) {
+  const match = uri.match(/\/album\/([^/?!]+)/i);
+  if (!match?.[1]) {
+    throw new Error(`Unable to parse album key from URI: ${uri}`);
+  }
+  return match[1];
+}
+function mapAlbumImage(albumImage, portfolioSourceId, sort) {
+  const image = albumImage.Image;
+  const metadata = image?.ImageMetadata ?? albumImage.ImageMetadata;
+  const originalUrl = image?.ImageSizeDetails?.OriginalImageUrl ?? albumImage.LargestImage?.Url ?? albumImage.WebUri;
+  const fileName = image?.FileName ?? albumImage.FileName;
+  return {
+    sourceId: albumImage.ImageKey,
+    portfolioSourceId,
+    sort,
+    fileName,
+    originalUrl,
+    caption: albumImage.Caption ?? image?.Caption,
+    keywords: image?.KeywordsArray?.length ? image.KeywordsArray : void 0,
+    exif: metadata ? {
+      iso: metadata.ISO,
+      aperture: metadata.Aperture ?? metadata.ApertureValue,
+      shutter: metadata.ShutterSpeed ?? metadata.ExposureTime,
+      focalLength: metadata.FocalLength
+    } : void 0
+  };
+}
+var SmugMugApiClient = class {
+  credentials;
+  pageSize;
+  maxRetries;
+  retryBaseDelayMs;
+  maxRetryDelayMs;
+  requestIntervalMs;
+  fetchImpl;
+  lastRequestAt = 0;
+  constructor(options) {
+    const parsed = smugMugClientOptionsSchema.parse(options);
+    this.credentials = parsed.credentials;
+    this.pageSize = parsed.pageSize;
+    this.maxRetries = parsed.maxRetries;
+    this.retryBaseDelayMs = parsed.retryBaseDelayMs;
+    this.maxRetryDelayMs = parsed.maxRetryDelayMs;
+    this.requestIntervalMs = parsed.requestIntervalMs;
+    this.fetchImpl = parsed.fetchImpl ?? fetch;
+  }
+  /** Validate credentials against `GET /user/!authuser`. */
+  async validateCredentials() {
+    const user = await this.getAuthUser();
+    return { nick: user.NickName, rootNodeUri: user.Uris.Node };
+  }
+  /** Crawl the authenticated user's node tree into flat export tables for `parse-node.ts`. */
+  async crawlExport() {
+    const user = await this.getAuthUser();
+    const folders = [];
+    const albums = [];
+    const images = [];
+    await this.walkNode(user.Uris.Node, void 0, folders, albums, images);
+    return {
+      exportVersion: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      Folders: folders,
+      Albums: albums,
+      Images: images
+    };
+  }
+  async getAuthUser() {
+    const envelope = await this.requestJson(`${SMUGMUG_API_BASE}/user/!authuser`);
+    return envelope.Response;
+  }
+  async walkNode(nodeUri, parentFolderId, folders, albums, images) {
+    const childrenPath = `${nodeUri}!children`;
+    for await (const child of this.paginateNodes(childrenPath)) {
+      if (child.Type === "Page") continue;
+      if (child.Type === "Folder") {
+        folders.push({
+          sourceId: child.NodeID,
+          name: child.Name,
+          parentSourceId: parentFolderId,
+          slug: child.UrlName,
+          description: child.Description
+        });
+        await this.walkNode(child.Uri, child.NodeID, folders, albums, images);
+        continue;
+      }
+      if (child.Type === "Album") {
+        albums.push({
+          sourceId: child.NodeID,
+          name: child.Name,
+          parentSourceId: parentFolderId,
+          slug: child.UrlName,
+          description: child.Description,
+          url: child.WebUri
+        });
+        const albumUri = child.Uris?.Album;
+        if (albumUri) {
+          await this.collectAlbumImages(albumUri, child.NodeID, images);
+        }
+      }
+    }
+  }
+  async collectAlbumImages(albumUri, portfolioSourceId, images) {
+    const albumKey = albumKeyFromUri(albumUri);
+    const configQuery = `_config=${encodeURIComponent(JSON.stringify(ALBUM_IMAGES_CONFIG))}`;
+    const initialPath = `${SMUGMUG_API_BASE}/album/${albumKey}!images?${configQuery}`;
+    let sort = 0;
+    for await (const albumImage of this.paginateAlbumImages(initialPath)) {
+      images.push(mapAlbumImage(albumImage, portfolioSourceId, sort));
+      sort += 1;
+    }
+  }
+  async *paginateNodes(path) {
+    for await (const page of this.paginate(path)) {
+      for (const node of page.Node ?? []) {
+        yield node;
+      }
+    }
+  }
+  async *paginateAlbumImages(path) {
+    for await (const page of this.paginate(path)) {
+      for (const albumImage of page.AlbumImage ?? []) {
+        yield albumImage;
+      }
+    }
+  }
+  async *paginate(initialPath) {
+    let nextPath = appendPagination(initialPath, this.pageSize, 1);
+    while (nextPath) {
+      const envelope = await this.requestJson(nextPath);
+      yield envelope.Response;
+      nextPath = envelope.Response.Pages?.NextPage;
+    }
+  }
+  async requestJson(pathOrUrl) {
+    const url = toAbsoluteUrl(pathOrUrl);
+    const response = await this.requestWithRetry(url);
+    const body = await response.json();
+    if (body.Code !== 200) {
+      throw new Error(`SmugMug API error ${body.Code}: ${body.Message}`);
+    }
+    return body;
+  }
+  async requestWithRetry(url) {
+    let attempt = 0;
+    while (true) {
+      await this.throttle();
+      const authorization = buildSmugMugAuthorizationHeader({
+        method: "GET",
+        url: url.toString(),
+        credentials: this.credentials
+      });
+      const response = await this.fetchImpl(url, {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          Authorization: authorization
+        }
+      });
+      if (response.ok) {
+        return response;
+      }
+      const retryable = response.status === 429 || response.status >= 500;
+      if (!retryable || attempt >= this.maxRetries) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(
+          `SmugMug HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
+        );
+      }
+      const retryAfter = Number.parseInt(response.headers.get("retry-after") ?? "", 10);
+      const delay = Number.isFinite(retryAfter) ? retryAfter * 1e3 : Math.min(this.maxRetryDelayMs, this.retryBaseDelayMs * 2 ** attempt);
+      await sleep(delay);
+      attempt += 1;
+    }
+  }
+  async throttle() {
+    if (this.requestIntervalMs <= 0) return;
+    const elapsed = Date.now() - this.lastRequestAt;
+    if (elapsed < this.requestIntervalMs) {
+      await sleep(this.requestIntervalMs - elapsed);
+    }
+    this.lastRequestAt = Date.now();
+  }
+};
+function toAbsoluteUrl(pathOrUrl) {
+  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+    return new URL(pathOrUrl);
+  }
+  if (pathOrUrl.startsWith("/")) {
+    return new URL(`https://${SMUGMUG_API_HOST}${pathOrUrl}`);
+  }
+  return new URL(pathOrUrl);
+}
+function appendPagination(pathOrUrl, count, start) {
+  const url = toAbsoluteUrl(pathOrUrl);
+  url.searchParams.set("count", String(count));
+  url.searchParams.set("start", String(start));
+  return url.toString();
+}
+
+// src/parsers/smugmug/parse-node.ts
+import { readFile as readFile2 } from "fs/promises";
+var PLATFORM2 = "smugmug";
+var UNRESOLVED_URL_PREFIX = "unspecified://smugmug/";
+function sourceMeta2(id, url, exportedAt) {
+  return {
+    platform: PLATFORM2,
+    id,
+    url,
+    exportedAt
+  };
+}
+function guessMime2(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const map = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    tif: "image/tiff",
+    tiff: "image/tiff"
+  };
+  return ext ? map[ext] : void 0;
+}
+function parseExifNumber(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  const parsed = Number.parseFloat(String(value).replace(/[^0-9.]/g, ""));
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeExif(exif) {
+  if (!exif || Object.keys(exif).length === 0) return void 0;
+  const normalized = {
+    iso: parseExifNumber(exif.iso),
+    aperture: parseExifNumber(exif.aperture),
+    shutter: exif.shutter,
+    focalLength: parseExifNumber(exif.focalLength)
+  };
+  if (normalized.iso === void 0 && normalized.aperture === void 0 && !normalized.shutter && normalized.focalLength === void 0) {
+    return void 0;
+  }
+  return normalized;
+}
+function isSmugMugFlatExport(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  const version = record.exportVersion;
+  return (version === 1 || version === "1") && Array.isArray(record.Folders) && Array.isArray(record.Albums) && Array.isArray(record.Images);
+}
+function isSmugMugNestedExport(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  const version = record.exportVersion;
+  return (version === 1 || version === "1") && Array.isArray(record.folders);
+}
+async function loadSmugMugExport(options) {
+  if (options.data) return options.data;
+  if (!options.filePath) {
+    throw new Error("SmugMug parser requires filePath or data");
+  }
+  const raw = JSON.parse(await readFile2(options.filePath, "utf8"));
+  if (isSmugMugFlatExport(raw) || isSmugMugNestedExport(raw)) {
+    return raw;
+  }
+  throw new Error(
+    "Invalid SmugMug export: expected exportVersion 1 with folders[] (nested) or Folders/Albums/Images (flat)"
+  );
+}
+function resolveAssetUrl(image) {
+  if (image.originalUrl) return image.originalUrl;
+  return `${UNRESOLVED_URL_PREFIX}${image.sourceId}`;
+}
+function resolveFilename(image) {
+  if (image.fileName) return image.fileName;
+  return `${image.sourceId}.jpg`;
+}
+function* emitNestedFolderPortfolio(folder, exportedAt) {
+  yield {
+    type: "portfolio",
+    source: sourceMeta2(folder.id, void 0, exportedAt),
+    sourceId: folder.id,
+    title: folder.name,
+    slug: sanitizeSlug(folder.slug ?? folder.name),
+    description: folder.description
+  };
+}
+function* emitNestedAlbumPortfolio(folder, album, exportedAt) {
+  yield {
+    type: "portfolio",
+    source: sourceMeta2(album.id, album.url, exportedAt),
+    sourceId: album.id,
+    title: album.name,
+    slug: sanitizeSlug(album.slug ?? album.name),
+    description: album.description,
+    parentSourceId: folder.id
+  };
+}
+function* emitNestedAlbumAssets(album, exportedAt) {
+  for (let index = 0; index < album.images.length; index++) {
+    const image = album.images[index];
+    yield {
+      type: "asset",
+      source: sourceMeta2(image.id, image.originalUrl, exportedAt),
+      sourceId: image.id,
+      sourceUrl: image.originalUrl,
+      filename: image.fileName,
+      mimeType: guessMime2(image.fileName),
+      caption: image.caption,
+      keywords: image.keywords?.length ? image.keywords : void 0,
+      exif: normalizeExif(image.exif),
+      portfolioSourceId: album.id,
+      sort: index
+    };
+  }
+}
+async function* enumerateNestedExport(doc) {
+  const exportedAt = doc.exportedAt;
+  for (const folder of doc.folders) {
+    yield* emitNestedFolderPortfolio(folder, exportedAt);
+    for (const album of folder.albums) {
+      yield* emitNestedAlbumPortfolio(folder, album, exportedAt);
+      yield* emitNestedAlbumAssets(album, exportedAt);
+    }
+  }
+}
+async function* enumerateFlatExport(doc) {
+  const exportedAt = doc.exportedAt;
+  for (const folder of doc.Folders) {
+    yield {
+      type: "portfolio",
+      source: sourceMeta2(folder.sourceId, void 0, exportedAt),
+      sourceId: folder.sourceId,
+      title: folder.name,
+      slug: sanitizeSlug(folder.slug ?? folder.name),
+      description: folder.description,
+      parentSourceId: folder.parentSourceId
+    };
+  }
+  for (const album of doc.Albums) {
+    yield {
+      type: "portfolio",
+      source: sourceMeta2(album.sourceId, album.url, exportedAt),
+      sourceId: album.sourceId,
+      title: album.name,
+      slug: sanitizeSlug(album.slug ?? album.name),
+      description: album.description,
+      parentSourceId: album.parentSourceId
+    };
+  }
+  for (const image of doc.Images) {
+    const filename = resolveFilename(image);
+    yield {
+      type: "asset",
+      source: sourceMeta2(image.sourceId, image.originalUrl, exportedAt),
+      sourceId: image.sourceId,
+      sourceUrl: resolveAssetUrl(image),
+      filename,
+      mimeType: guessMime2(filename),
+      caption: image.caption,
+      keywords: image.keywords?.length ? image.keywords : void 0,
+      exif: normalizeExif(image.exif),
+      portfolioSourceId: image.portfolioSourceId,
+      sort: image.sort ?? 0
+    };
+  }
+}
+async function resolveSmugMugDocument(options) {
+  if (options.data) return options.data;
+  if (options.client) return options.client.crawlExport();
+  if (options.credentials) {
+    const client = new SmugMugApiClient({ credentials: options.credentials, ...options.clientOptions });
+    return client.crawlExport();
+  }
+  return loadSmugMugExport(options);
+}
+async function* enumerateSmugMugEntities(options) {
+  const doc = await resolveSmugMugDocument(options);
+  if (isSmugMugFlatExport(doc)) {
+    yield* enumerateFlatExport(doc);
+    return;
+  }
+  yield* enumerateNestedExport(doc);
+}
+function summarizeSmugMugExport(doc) {
+  if (isSmugMugFlatExport(doc)) {
+    return {
+      folders: doc.Folders.length,
+      albums: doc.Albums.length,
+      assets: doc.Images.length,
+      portfolios: doc.Folders.length + doc.Albums.length
+    };
+  }
+  const folders = doc.folders.length;
+  let albums = 0;
+  let assets = 0;
+  for (const folder of doc.folders) {
+    albums += folder.albums.length;
+    for (const album of folder.albums) {
+      assets += album.images.length;
+    }
+  }
+  return {
+    folders,
+    albums,
+    assets,
+    portfolios: folders + albums
+  };
+}
+async function validateSmugMugExportFile(filePath) {
+  const issues = [];
+  let doc;
+  try {
+    doc = await loadSmugMugExport({ filePath });
+  } catch (error) {
+    return {
+      ok: false,
+      issues: [
+        {
+          code: "invalid_export",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ],
+      summary: {}
+    };
+  }
+  if (isSmugMugFlatExport(doc)) {
+    if (doc.Folders.length === 0 && doc.Albums.length === 0) {
+      issues.push({ code: "empty_export", message: "No folders or albums in export" });
+    }
+  } else if (doc.folders.length === 0) {
+    issues.push({ code: "empty_export", message: "No folders in export" });
+  }
+  const summary = summarizeSmugMugExport(doc);
+  return {
+    ok: issues.length === 0,
+    issues,
+    summary: {
+      portfolios: summary.portfolios,
+      assets: summary.assets,
+      categories: summary.folders,
+      posts: 0,
+      pages: 0,
+      tags: 0
+    }
+  };
+}
+
+// src/parsers/smugmug/index.ts
+function resolveInput(input) {
+  if (typeof input === "string") return { path: input };
+  if (input && typeof input === "object") {
+    const record = input;
+    if (record.client || record.credentials || record.live) return record;
+    if (record.data) return { data: record.data };
+    if (record.path) return { path: record.path };
+  }
+  throw new Error(
+    "SmugMug adapter requires input path (string or { path }), { data }, { credentials }, { client }, or { live: true }"
+  );
+}
+function resolveLiveCredentials(input) {
+  if (input.credentials) return input.credentials;
+  if (input.live) return readSmugMugCredentialsFromEnv();
+  return void 0;
+}
+var smugmugAdapter = {
+  platform: "smugmug",
+  async validateInput(input) {
+    try {
+      const resolved = resolveInput(input);
+      const credentials = resolveLiveCredentials(resolved);
+      if (resolved.data) {
+        const summary = summarizeSmugMugExport(resolved.data);
+        return {
+          ok: true,
+          issues: [],
+          summary: {
+            portfolios: summary.portfolios,
+            assets: summary.assets,
+            categories: summary.folders,
+            posts: 0,
+            pages: 0,
+            tags: 0
+          }
+        };
+      }
+      if (resolved.client || credentials) {
+        const client = resolved.client ?? new SmugMugApiClient({ credentials, ...resolved.clientOptions });
+        await client.validateCredentials();
+        const doc = await client.crawlExport();
+        const summary = summarizeSmugMugExport(doc);
+        return {
+          ok: true,
+          issues: [],
+          summary: {
+            portfolios: summary.portfolios,
+            assets: summary.assets,
+            categories: summary.folders,
+            posts: 0,
+            pages: 0,
+            tags: 0
+          }
+        };
+      }
+      const result = await validateSmugMugExportFile(resolved.path);
+      return {
+        ok: result.ok,
+        issues: result.issues,
+        summary: result.summary
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        issues: [
+          {
+            code: "invalid_input",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        ]
+      };
+    }
+  },
+  enumerateEntities(ctx) {
+    const resolved = resolveInput(ctx.input);
+    const credentials = resolveLiveCredentials(resolved);
+    return enumerateSmugMugEntities({
+      filePath: resolved.path,
+      data: resolved.data,
+      client: resolved.client,
+      credentials,
+      clientOptions: resolved.clientOptions
+    });
+  }
+};
+
+// src/parsers/squarespace/index.ts
+function resolveInput2(input) {
+  if (typeof input === "string") return { path: input };
+  if (input && typeof input === "object") {
+    const record = input;
+    if (record.client || record.collectTargets) return record;
+    if (record.data) return { data: record.data };
+    if (record.path) return { path: record.path };
+  }
+  throw new Error(
+    "Squarespace adapter requires input path (string or { path }), { data }, { client, collectTargets }, or { collectTargets }"
+  );
+}
+var squarespaceAdapter = {
+  platform: "squarespace",
+  async validateInput(input) {
+    try {
+      const resolved = resolveInput2(input);
+      if (resolved.data) {
+        const summary = summarizeSquarespaceExport(resolved.data);
+        return {
+          ok: true,
+          issues: [],
+          summary: {
+            pages: summary.pages,
+            posts: summary.posts,
+            categories: summary.categories,
+            tags: summary.tags
+          }
+        };
+      }
+      if (resolved.client || resolved.collectTargets?.length) {
+        if (!resolved.collectTargets?.length) {
+          throw new Error("Squarespace live validation requires collectTargets");
+        }
+        const client = resolved.client ?? new SquarespaceCollectionClient(resolved.clientOptions);
+        const doc = await client.collectExport(resolved.collectTargets);
+        const summary = summarizeSquarespaceExport(doc);
+        return {
+          ok: true,
+          issues: [],
+          summary: {
+            pages: summary.pages,
+            posts: summary.posts,
+            categories: summary.categories,
+            tags: summary.tags
+          }
+        };
+      }
+      const result = await validateSquarespaceExportFile(resolved.path);
+      return {
+        ok: result.ok,
+        issues: result.issues,
+        summary: result.summary
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        issues: [
+          {
+            code: "invalid_input",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        ]
+      };
+    }
+  },
+  enumerateEntities(ctx) {
+    const resolved = resolveInput2(ctx.input);
+    return enumerateSquarespaceEntities({
+      filePath: resolved.path,
+      data: resolved.data,
+      client: resolved.client,
+      collectTargets: resolved.collectTargets,
+      clientOptions: resolved.clientOptions
+    });
+  }
+};
+
+// src/parsers/wix/api.ts
+import { z as z2 } from "zod";
+
+// src/parsers/wix/ricos-to-html.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderTextNode(node) {
+  const text = node.textData?.text ?? "";
+  let html = escapeHtml(text);
+  for (const decoration of node.textData?.decorations ?? []) {
+    switch (decoration.type) {
+      case "BOLD":
+        html = `<strong>${html}</strong>`;
+        break;
+      case "ITALIC":
+        html = `<em>${html}</em>`;
+        break;
+      case "UNDERLINE":
+        html = `<u>${html}</u>`;
+        break;
+      case "LINK": {
+        const href = decoration.linkData?.link?.url;
+        if (href) html = `<a href="${escapeHtml(href)}">${html}</a>`;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return html;
+}
+function renderChildren(nodes) {
+  return (nodes ?? []).map((node) => renderRicosNode(node)).join("");
+}
+function renderRicosNode(node) {
+  const type = (node.type ?? "").toUpperCase();
+  switch (type) {
+    case "TEXT":
+      return renderTextNode(node);
+    case "PARAGRAPH":
+      return `<p>${renderChildren(node.nodes)}</p>`;
+    case "HEADING": {
+      const level = Math.min(6, Math.max(1, node.headingData?.level ?? 2));
+      return `<h${level}>${renderChildren(node.nodes)}</h${level}>`;
+    }
+    case "BULLETED_LIST":
+      return `<ul>${renderChildren(node.nodes)}</ul>`;
+    case "ORDERED_LIST":
+      return `<ol>${renderChildren(node.nodes)}</ol>`;
+    case "LIST_ITEM":
+      return `<li>${renderChildren(node.nodes)}</li>`;
+    case "BLOCKQUOTE":
+      return `<blockquote>${renderChildren(node.nodes)}</blockquote>`;
+    case "HTML":
+      return node.htmlData?.html ?? "";
+    case "IMAGE": {
+      const src = node.imageData?.image?.src?.url;
+      if (!src) return "";
+      const alt = node.imageData?.image?.altText ? ` alt="${escapeHtml(node.imageData.image.altText)}"` : "";
+      return `<figure><img src="${escapeHtml(src)}"${alt} /></figure>`;
+    }
+    case "BUTTON": {
+      const label = escapeHtml(node.buttonData?.text ?? "Link");
+      const href = node.buttonData?.link?.url ?? node.linkData?.link?.url;
+      if (!href) return `<span>${label}</span>`;
+      return `<p><a href="${escapeHtml(href)}">${label}</a></p>`;
+    }
+    case "CODE_BLOCK":
+      return `<pre><code>${renderChildren(node.nodes)}</code></pre>`;
+    case "DIVIDER":
+      return "<hr />";
+    default:
+      return renderChildren(node.nodes);
+  }
+}
+function ricosToHtml(richContent) {
+  if (!richContent || typeof richContent !== "object") return "";
+  const nodes = richContent.nodes;
+  if (!Array.isArray(nodes) || nodes.length === 0) return "";
+  return renderChildren(nodes);
+}
+
+// src/parsers/wix/map-wire.ts
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function buildWixPageUrl(url) {
+  if (!url) return void 0;
+  const base = asString(url.base);
+  const path = asString(url.path);
+  if (base && path) {
+    return `${base.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  return base ?? path;
+}
+function seoField(seoData, prop) {
+  const tags = asRecord(seoData)?.tags;
+  if (!Array.isArray(tags)) return void 0;
+  for (const tag of tags) {
+    const record = asRecord(tag);
+    if (!record) continue;
+    const props = asRecord(record.props);
+    if (record.type === "title" && prop === "title") {
+      return asString(props?.children) ?? asString(record.children);
+    }
+    if (record.type === "meta" && prop === "description" && props?.name === "description") {
+      return asString(props.content);
+    }
+  }
+  return void 0;
+}
+function postContentHtml(post) {
+  const richHtml = ricosToHtml(post.richContent);
+  if (richHtml.trim()) return richHtml;
+  const plain = asString(post.contentText);
+  if (!plain) return "";
+  return `<p>${plain.replace(/\n\n+/g, "</p><p>").replace(/\n/g, "<br />")}</p>`;
+}
+function mapWireCategory(wire, exportedAt) {
+  const record = asRecord(wire);
+  if (!record) return void 0;
+  const id = asString(record.id);
+  const name = asString(record.label) ?? asString(record.title);
+  if (!id || !name) return void 0;
+  const slug = sanitizeSlug(asString(record.slug) ?? name);
+  if (!slug) return void 0;
+  void exportedAt;
+  return { id, name, slug };
+}
+function mapWireTag(wire) {
+  const record = asRecord(wire);
+  if (!record) return void 0;
+  const id = asString(record.id);
+  const name = asString(record.label) ?? asString(record.slug);
+  if (!id || !name) return void 0;
+  const slug = sanitizeSlug(asString(record.slug) ?? name);
+  if (!slug) return void 0;
+  return { id, name, slug };
+}
+function mapWirePost(wire, lookup) {
+  const record = asRecord(wire);
+  if (!record) return void 0;
+  const id = asString(record.id);
+  const title = asString(record.title) ?? "Untitled";
+  if (!id) return void 0;
+  const slug = sanitizeSlug(asString(record.slug) ?? title);
+  const url = buildWixPageUrl(asRecord(record.url));
+  const heroImage = asRecord(record.heroImage);
+  const featuredImageUrl = asString(heroImage?.url);
+  const categorySlugs = asStringArray(record.categoryIds).map((categoryId) => lookup.categorySlugsById.get(categoryId)).filter((slugValue) => !!slugValue);
+  const tagSlugs = asStringArray(record.tagIds).map((tagId) => lookup.tagSlugsById.get(tagId)).filter((slugValue) => !!slugValue);
+  for (const hashtag of asStringArray(record.hashtags)) {
+    const tagSlug = sanitizeSlug(hashtag);
+    if (tagSlug && !tagSlugs.includes(tagSlug)) tagSlugs.push(tagSlug);
+  }
+  return {
+    id,
+    title,
+    slug,
+    url,
+    excerpt: asString(record.excerpt),
+    contentHtml: postContentHtml(record),
+    publishedAt: asString(record.firstPublishedDate) ?? asString(record.lastPublishedDate),
+    status: "published",
+    categorySlugs,
+    tagSlugs,
+    featuredImageUrl,
+    seoTitle: seoField(record.seoData, "title"),
+    seoDescription: seoField(record.seoData, "description")
+  };
+}
+function mapWireListPostsResponse(wire, lookup) {
+  const posts = asRecord(wire)?.posts;
+  if (!Array.isArray(posts)) return [];
+  return posts.map((entry) => mapWirePost(entry, lookup)).filter((post) => !!post);
+}
+function mapWireListCategoriesResponse(wire) {
+  const categories = asRecord(wire)?.categories;
+  if (!Array.isArray(categories)) return [];
+  return categories.map((entry) => mapWireCategory(entry)).filter((category) => !!category);
+}
+function mapWireListTagsResponse(wire) {
+  const tags = asRecord(wire)?.tags;
+  if (!Array.isArray(tags)) return [];
+  return tags.map((entry) => mapWireTag(entry)).filter((tag) => !!tag);
+}
+
+// src/parsers/wix/api.ts
+var WIX_API_BASE = "https://www.wixapis.com";
+var wixAuthContextSchema = z2.object({
+  /** Full Authorization header value (API key or Bearer token). */
+  authorization: z2.string().min(1),
+  siteId: z2.string().min(1),
+  accountId: z2.string().optional(),
+  extraHeaders: z2.record(z2.string()).optional()
+});
+var wixClientOptionsSchema = z2.object({
+  auth: wixAuthContextSchema,
+  pageSize: z2.number().int().min(1).max(100).default(50),
+  maxRetries: z2.number().int().min(0).max(10).default(3),
+  retryBaseDelayMs: z2.number().int().min(0).default(500),
+  maxRetryDelayMs: z2.number().int().min(0).default(8e3),
+  requestIntervalMs: z2.number().int().min(0).default(200),
+  fetchImpl: z2.custom().optional(),
+  /** Include draft posts when the API key has permission. */
+  includeDrafts: z2.boolean().default(false)
+});
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function dedupeById(items) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const item of items) seen.set(item.id, item);
+  return [...seen.values()];
+}
+function dedupeBySlug(items) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const item of items) seen.set(item.slug, item);
+  return [...seen.values()];
+}
+function pagingComplete(items, paging, pageSize) {
+  if (!Array.isArray(items) || items.length === 0) return true;
+  if (items.length < pageSize) return true;
+  if (typeof paging?.total === "number" && typeof paging.offset === "number") {
+    return paging.offset + items.length >= paging.total;
+  }
+  return false;
+}
+var WixCollectionClient = class {
+  auth;
+  pageSize;
+  maxRetries;
+  retryBaseDelayMs;
+  maxRetryDelayMs;
+  requestIntervalMs;
+  fetchImpl;
+  includeDrafts;
+  lastRequestAt = 0;
+  constructor(options) {
+    const parsed = wixClientOptionsSchema.parse(options);
+    this.auth = parsed.auth;
+    this.pageSize = parsed.pageSize;
+    this.maxRetries = parsed.maxRetries;
+    this.retryBaseDelayMs = parsed.retryBaseDelayMs;
+    this.maxRetryDelayMs = parsed.maxRetryDelayMs;
+    this.requestIntervalMs = parsed.requestIntervalMs;
+    this.fetchImpl = parsed.fetchImpl ?? fetch;
+    this.includeDrafts = parsed.includeDrafts;
+  }
+  buildUrl(path, query) {
+    const url = new URL(path.startsWith("http") ? path : `${WIX_API_BASE}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0) continue;
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  async fetchJson(path, query) {
+    const response = await this.requestWithRetry(this.buildUrl(path, query));
+    return response.json();
+  }
+  async listAllCategories() {
+    const categories = [];
+    let offset = 0;
+    while (true) {
+      const wire = await this.fetchJson("/blog/v3/categories", {
+        "paging.limit": this.pageSize,
+        "paging.offset": offset,
+        fieldsets: "URL"
+      });
+      const batch = mapWireListCategoriesResponse(wire);
+      categories.push(...batch);
+      const paging = wire.pagingMetadata;
+      if (pagingComplete(batch, paging, this.pageSize)) break;
+      offset += batch.length;
+      if (batch.length === 0) break;
+    }
+    return dedupeBySlug(categories);
+  }
+  async listAllTags() {
+    const tags = [];
+    let offset = 0;
+    while (true) {
+      const wire = await this.fetchJson("/blog/v3/tags", {
+        "paging.limit": this.pageSize,
+        "paging.offset": offset
+      });
+      const batch = mapWireListTagsResponse(wire);
+      tags.push(...batch);
+      const paging = wire.pagingMetadata;
+      if (pagingComplete(batch, paging, this.pageSize)) break;
+      offset += batch.length;
+      if (batch.length === 0) break;
+    }
+    return dedupeBySlug(tags);
+  }
+  async listAllPosts(lookup) {
+    const posts = [];
+    let offset = 0;
+    while (true) {
+      const wire = await this.fetchJson("/blog/v3/posts", {
+        "paging.limit": this.pageSize,
+        "paging.offset": offset,
+        fieldsets: "URL,RICH_CONTENT,SEO",
+        sort: "PUBLISHED_DATE_DESC"
+      });
+      const batch = mapWireListPostsResponse(wire, lookup);
+      posts.push(...batch);
+      const paging = wire.pagingMetadata;
+      if (pagingComplete(batch, paging, this.pageSize)) break;
+      offset += batch.length;
+      if (batch.length === 0) break;
+    }
+    if (this.includeDrafts) {
+      posts.push(...await this.listDraftPosts(lookup));
+    }
+    return dedupeById(posts);
+  }
+  async listDraftPosts(lookup) {
+    const posts = [];
+    let offset = 0;
+    while (true) {
+      const wire = await this.fetchJson("/blog/v3/draft-posts", {
+        "paging.limit": this.pageSize,
+        "paging.offset": offset,
+        fieldsets: "URL,RICH_CONTENT,SEO"
+      });
+      const batch = mapWireListPostsResponse(
+        { posts: wire.draftPosts ?? [] },
+        lookup
+      ).map((post) => ({ ...post, status: "draft" }));
+      posts.push(...batch);
+      const paging = wire.pagingMetadata;
+      if (pagingComplete(batch, paging, this.pageSize)) break;
+      offset += batch.length;
+      if (batch.length === 0) break;
+    }
+    return posts;
+  }
+  async collectExport() {
+    const categories = await this.listAllCategories();
+    const tags = await this.listAllTags();
+    const categorySlugsById = new Map(categories.map((category) => [category.id, category.slug]));
+    const tagSlugsById = new Map(tags.map((tag) => [tag.id, tag.slug]));
+    const posts = await this.listAllPosts({ categorySlugsById, tagSlugsById });
+    return {
+      exportVersion: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      site: { siteId: this.auth.siteId },
+      posts,
+      pages: [],
+      categories,
+      tags
+    };
+  }
+  buildHeaders() {
+    const headers = {
+      Accept: "application/json",
+      Authorization: this.auth.authorization,
+      "wix-site-id": this.auth.siteId,
+      ...this.auth.extraHeaders ?? {}
+    };
+    if (this.auth.accountId) {
+      headers["wix-account-id"] = this.auth.accountId;
+    }
+    return headers;
+  }
+  async requestWithRetry(url) {
+    let attempt = 0;
+    while (true) {
+      await this.throttle();
+      const response = await this.fetchImpl(url, {
+        method: "GET",
+        headers: this.buildHeaders()
+      });
+      if (response.ok) return response;
+      const retryable = response.status === 429 || response.status >= 500;
+      if (!retryable || attempt >= this.maxRetries) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(
+          `Wix HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
+        );
+      }
+      const retryAfter = Number.parseInt(response.headers.get("retry-after") ?? "", 10);
+      const delay = Number.isFinite(retryAfter) ? retryAfter * 1e3 : Math.min(this.maxRetryDelayMs, this.retryBaseDelayMs * 2 ** attempt);
+      await sleep2(delay);
+      attempt += 1;
+    }
+  }
+  async throttle() {
+    if (this.requestIntervalMs <= 0) return;
+    const elapsed = Date.now() - this.lastRequestAt;
+    if (elapsed < this.requestIntervalMs) {
+      await sleep2(this.requestIntervalMs - elapsed);
+    }
+    this.lastRequestAt = Date.now();
+  }
+};
+function isWixExport(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return record.exportVersion === 1 && (Array.isArray(record.posts) || Array.isArray(record.pages));
+}
+function assertWixExport(value) {
+  if (!isWixExport(value)) {
+    throw new Error("Invalid Wix export: expected exportVersion 1 with posts[] and/or pages[]");
+  }
+  if ((value.posts?.length ?? 0) === 0 && (value.pages?.length ?? 0) === 0) {
+    throw new Error("Invalid Wix export: no posts or pages");
+  }
+  for (const post of value.posts ?? []) {
+    if (!post.slug) post.slug = sanitizeSlug(post.title);
+  }
+  for (const page of value.pages ?? []) {
+    if (!page.slug) page.slug = sanitizeSlug(page.title);
+  }
+  return value;
+}
+
+// src/parsers/wix/snapshot.ts
+import * as cheerio from "cheerio";
+import { readFile as readFile3 } from "fs/promises";
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+import { z as z3 } from "zod";
+var MAIN_CONTENT_SELECTORS = [
+  "main",
+  "article",
+  '[role="main"]',
+  "#SITE_PAGES main",
+  "#site-root main",
+  "#PAGES_CONTAINER",
+  "body"
+];
+var wixSnapshotClientOptionsSchema = z3.object({
+  fetchImpl: z3.custom().optional(),
+  maxRetries: z3.number().int().min(0).max(5).default(2),
+  retryBaseDelayMs: z3.number().int().min(0).default(300),
+  requestIntervalMs: z3.number().int().min(0).default(150)
+});
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function slugFromUrl(url, fallback) {
+  try {
+    const segments = new URL(url).pathname.split("/").filter(Boolean);
+    const last = segments.at(-1);
+    if (last) return sanitizeSlug(last);
+  } catch {
+  }
+  return sanitizeSlug(fallback);
+}
+function looksLikeLoginWall($, html) {
+  const lower = html.toLowerCase();
+  if (lower.includes("members-login") || lower.includes("login-bar")) return true;
+  if ($('input[type="password"]').length > 0 && $('form[action*="login"]').length > 0) return true;
+  if ($('[data-testid="sign-in"]').length > 0) return true;
+  return false;
+}
+function pickMainRoot($) {
+  for (const selector of MAIN_CONTENT_SELECTORS) {
+    const match = $(selector).first();
+    if (match.length > 0) return match;
+  }
+  return $("body");
+}
+function extractMainContentHtml(html) {
+  const $ = cheerio.load(html, { xml: false });
+  const loginWall = looksLikeLoginWall($, html);
+  const title = $("title").first().text().trim() || $('meta[property="og:title"]').attr("content")?.trim() || $("h1").first().text().trim() || void 0;
+  const root = pickMainRoot($);
+  root.find("script, style, noscript, nav, header, footer, iframe").remove();
+  const contentHtml = root.html()?.trim() ?? "";
+  const textOnly = root.text().replace(/\s+/g, " ").trim();
+  const empty = textOnly.length < 20;
+  return { contentHtml, title, empty, loginWall };
+}
+function parseUrlList(raw) {
+  return raw.split(/[\n,]+/).map((entry) => entry.trim()).filter((entry) => entry.length > 0 && /^https?:\/\//i.test(entry));
+}
+function parseSitemapUrls(xml) {
+  const parser = new XMLParser2({ ignoreAttributes: true, removeNSPrefix: true });
+  const doc = parser.parse(xml);
+  const urls = [];
+  const urlEntries = doc.urlset?.url;
+  if (urlEntries) {
+    const list = Array.isArray(urlEntries) ? urlEntries : [urlEntries];
+    for (const entry of list) {
+      if (entry.loc) urls.push(entry.loc.trim());
+    }
+  }
+  const sitemapEntries = doc.sitemapindex?.sitemap;
+  if (sitemapEntries) {
+    const list = Array.isArray(sitemapEntries) ? sitemapEntries : [sitemapEntries];
+    for (const entry of list) {
+      if (entry.loc) urls.push(entry.loc.trim());
+    }
+  }
+  return [...new Set(urls.filter((url) => /^https?:\/\//i.test(url)))];
+}
+async function loadUrlListFile(filePath) {
+  const raw = await readFile3(filePath, "utf8");
+  if (raw.trim().startsWith("<")) return parseSitemapUrls(raw);
+  return parseUrlList(raw);
+}
+var WixPageSnapshotCollector = class {
+  fetchImpl;
+  maxRetries;
+  retryBaseDelayMs;
+  requestIntervalMs;
+  lastRequestAt = 0;
+  constructor(options = {}) {
+    const parsed = wixSnapshotClientOptionsSchema.parse(options);
+    this.fetchImpl = parsed.fetchImpl ?? fetch;
+    this.maxRetries = parsed.maxRetries;
+    this.retryBaseDelayMs = parsed.retryBaseDelayMs;
+    this.requestIntervalMs = parsed.requestIntervalMs;
+  }
+  async collectPages(targets) {
+    const pages = [];
+    const gaps = [];
+    for (const target of targets) {
+      let html;
+      try {
+        html = target.html ?? await this.fetchHtml(target.url);
+      } catch (error) {
+        gaps.push({
+          url: target.url,
+          code: "fetch_failed",
+          message: error instanceof Error ? error.message : String(error)
+        });
+        continue;
+      }
+      const extracted = extractMainContentHtml(html);
+      if (extracted.loginWall) {
+        gaps.push({
+          url: target.url,
+          code: "login_wall",
+          message: "Page appears to require authentication"
+        });
+        continue;
+      }
+      if (extracted.empty) {
+        gaps.push({
+          url: target.url,
+          code: "empty_extract",
+          message: "No meaningful content found in main/article containers"
+        });
+        continue;
+      }
+      const title = target.title ?? extracted.title ?? "Untitled";
+      const slug = target.slug ?? slugFromUrl(target.url, title);
+      pages.push({
+        id: `page:${slug}`,
+        title,
+        slug,
+        url: target.url,
+        contentHtml: extracted.contentHtml,
+        isHomePage: target.isHomePage,
+        status: "published"
+      });
+    }
+    return { pages, gaps };
+  }
+  async collectFromUrlList(urls) {
+    return this.collectPages(
+      urls.map((url, index) => ({
+        url,
+        isHomePage: index === 0 && new URL(url).pathname === "/"
+      }))
+    );
+  }
+  async fetchHtml(url) {
+    let attempt = 0;
+    while (true) {
+      await this.throttle();
+      const response = await this.fetchImpl(url, {
+        method: "GET",
+        headers: { Accept: "text/html,application/xhtml+xml" }
+      });
+      if (response.ok) {
+        return response.text();
+      }
+      const retryable = response.status === 429 || response.status >= 500;
+      if (!retryable || attempt >= this.maxRetries) {
+        throw new Error(`Snapshot fetch HTTP ${response.status} for ${url}`);
+      }
+      await sleep3(this.retryBaseDelayMs * 2 ** attempt);
+      attempt += 1;
+    }
+  }
+  async throttle() {
+    if (this.requestIntervalMs <= 0) return;
+    const elapsed = Date.now() - this.lastRequestAt;
+    if (elapsed < this.requestIntervalMs) {
+      await sleep3(this.requestIntervalMs - elapsed);
+    }
+    this.lastRequestAt = Date.now();
+  }
+};
+
+// src/parsers/wix/parse-export.ts
+import { readFile as readFile4 } from "fs/promises";
+import { basename as basename2, extname } from "path";
+import { XMLParser as XMLParser3 } from "fast-xml-parser";
+var PLATFORM3 = "wix";
+function asArray2(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function textValue2(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  if (typeof value === "object" && value !== null && "#text" in value) {
+    return String(value["#text"] ?? "");
+  }
+  return String(value);
+}
+function sourceMeta3(id, url, exportedAt) {
+  return {
+    platform: PLATFORM3,
+    id,
+    url: url || void 0,
+    path: linkToPath(url),
+    exportedAt
+  };
+}
+function guessMime3(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const map = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif"
+  };
+  return ext ? map[ext] : void 0;
+}
+function parseXmlDocument(xml) {
+  const parser = new XMLParser3({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    trimValues: false,
+    parseTagValue: false
+  });
+  return parser.parse(xml);
+}
+function detectWixFeedFormat(xml) {
+  const trimmed = xml.trim();
+  if (trimmed.includes("<feed") || trimmed.startsWith("<feed")) return "atom";
+  return "rss";
+}
+function getItemContentHtml(item) {
+  const content = item.content ?? item.content;
+  if (content !== void 0) {
+    if (typeof content === "string") return content;
+    const block = content;
+    if (block["#text"] !== void 0) return textValue2(block["#text"]);
+    if (block.encoded !== void 0) return textValue2(block.encoded);
+  }
+  const rssItem = item;
+  if (rssItem.encoded !== void 0) return textValue2(rssItem.encoded);
+  return textValue2(rssItem.description ?? item.summary);
+}
+function slugFromLink(link, title, fallbackId) {
+  try {
+    const pathname = new URL(link).pathname;
+    const segments = pathname.split("/").filter(Boolean);
+    const last = segments.at(-1);
+    if (last) return sanitizeSlug(last);
+  } catch {
+  }
+  return sanitizeSlug(title || fallbackId);
+}
+function itemLink(item) {
+  const rssLink = textValue2(item.link);
+  if (rssLink) return rssLink;
+  for (const link of asArray2(item.link)) {
+    if (typeof link === "string" && link) return link;
+    if (typeof link === "object" && link !== null) {
+      const rel = link["@_rel"];
+      const href = link["@_href"];
+      if (href && (!rel || rel === "alternate")) return href;
+    }
+  }
+  return "";
+}
+function itemSourceId(item, link, slug) {
+  const guid = textValue2(item.guid);
+  if (guid) return guid;
+  const atomId = textValue2(item.id);
+  if (atomId) return atomId;
+  if (link) return link;
+  return slug;
+}
+function itemPublishedAt(item) {
+  const pubDate = textValue2(item.pubDate) || textValue2(item.published) || textValue2(item.updated) || textValue2(item.published);
+  return pubDate || void 0;
+}
+function normalizeCategoryLabel(category) {
+  if (typeof category === "string") {
+    return { label: category.trim() };
+  }
+  return {
+    domain: category["@_domain"]?.toLowerCase(),
+    label: textValue2(category["#text"] ?? category["@_term"]).trim()
+  };
+}
+function collectTaxonomiesFromItems(items) {
+  const categories = /* @__PURE__ */ new Map();
+  const tags = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    for (const rawCategory of asArray2(item.category)) {
+      const { domain, label } = normalizeCategoryLabel(rawCategory);
+      if (!label) continue;
+      const slug = sanitizeSlug(label);
+      if (!slug) continue;
+      if (domain === "tag" || domain === "post_tag") {
+        if (tags.has(slug)) continue;
+        tags.set(slug, {
+          type: "tag",
+          source: sourceMeta3(`tag:${slug}`),
+          sourceId: `tag:${slug}`,
+          name: label,
+          slug
+        });
+        continue;
+      }
+      if (categories.has(slug)) continue;
+      categories.set(slug, {
+        type: "category",
+        source: sourceMeta3(`cat:${slug}`),
+        sourceId: `cat:${slug}`,
+        name: label,
+        slug
+      });
+    }
+  }
+  return { categories, tags };
+}
+function collectCategorySlugs(item) {
+  const slugs = [];
+  for (const rawCategory of asArray2(item.category)) {
+    const { domain, label } = normalizeCategoryLabel(rawCategory);
+    if (!label || domain === "tag" || domain === "post_tag") continue;
+    const slug = sanitizeSlug(label);
+    if (slug) slugs.push(slug);
+  }
+  return slugs;
+}
+function collectTagSlugs(item) {
+  const slugs = [];
+  for (const rawCategory of asArray2(item.category)) {
+    const { domain, label } = normalizeCategoryLabel(rawCategory);
+    if (!label || domain !== "tag" && domain !== "post_tag") continue;
+    const slug = sanitizeSlug(label);
+    if (slug) slugs.push(slug);
+  }
+  return slugs;
+}
+function* collectInlineAssets2(html, seenUrls, exportedAt) {
+  for (const src of discoverContentAssetUrls(html)) {
+    if (seenUrls.has(src)) continue;
+    seenUrls.add(src);
+    let filename;
+    try {
+      filename = basename2(new URL(src, "http://local.invalid").pathname) || "inline-asset";
+    } catch {
+      filename = "inline-asset";
+    }
+    yield {
+      type: "asset",
+      source: sourceMeta3(`url:${src}`, src, exportedAt),
+      sourceId: `url:${src}`,
+      sourceUrl: src,
+      filename,
+      mimeType: guessMime3(filename)
+    };
+  }
+}
+function mapPublishStatus2(status) {
+  switch ((status ?? "published").toLowerCase()) {
+    case "published":
+      return "published";
+    case "draft":
+      return "draft";
+    default:
+      return "archived";
+  }
+}
+function* emitExportPost(post, exportedAt, seenAssetUrls) {
+  yield* collectInlineAssets2(post.contentHtml, seenAssetUrls, exportedAt);
+  let featuredAssetSourceId;
+  if (post.featuredImageUrl) {
+    featuredAssetSourceId = `featured:${post.id}`;
+    if (!seenAssetUrls.has(post.featuredImageUrl)) {
+      seenAssetUrls.add(post.featuredImageUrl);
+      const filename = basename2(new URL(post.featuredImageUrl).pathname) || `${post.id}-featured.jpg`;
+      yield {
+        type: "asset",
+        source: sourceMeta3(featuredAssetSourceId, post.featuredImageUrl, exportedAt),
+        sourceId: featuredAssetSourceId,
+        sourceUrl: post.featuredImageUrl,
+        filename,
+        mimeType: guessMime3(filename)
+      };
+    }
+  }
+  yield {
+    type: "post",
+    source: sourceMeta3(post.id, post.url, exportedAt),
+    sourceId: post.id,
+    title: post.title,
+    slug: sanitizeSlug(post.slug),
+    excerpt: post.excerpt,
+    contentHtml: post.contentHtml,
+    publishedAt: post.publishedAt,
+    status: mapPublishStatus2(post.status),
+    categorySlugs: post.categorySlugs,
+    tagSlugs: post.tagSlugs,
+    featuredAssetSourceId,
+    seoTitle: post.seoTitle,
+    seoDescription: post.seoDescription
+  };
+}
+function* emitExportPage(page, exportedAt, seenAssetUrls) {
+  yield* collectInlineAssets2(page.contentHtml, seenAssetUrls, exportedAt);
+  yield {
+    type: "page",
+    source: sourceMeta3(page.id, page.url, exportedAt),
+    sourceId: page.id,
+    title: page.title,
+    slug: sanitizeSlug(page.slug),
+    contentHtml: page.contentHtml,
+    isHomePage: page.isHomePage,
+    status: mapPublishStatus2(page.status),
+    seoTitle: page.seoTitle,
+    seoDescription: page.seoDescription
+  };
+}
+async function* enumerateWixExportEntities(doc, snapshotGaps) {
+  const exportedAt = doc.exportedAt;
+  const seenAssetUrls = /* @__PURE__ */ new Set();
+  for (const category of doc.categories ?? []) {
+    yield {
+      type: "category",
+      source: sourceMeta3(category.id, void 0, exportedAt),
+      sourceId: category.id,
+      name: category.name,
+      slug: sanitizeSlug(category.slug)
+    };
+  }
+  for (const tag of doc.tags ?? []) {
+    yield {
+      type: "tag",
+      source: sourceMeta3(tag.id, void 0, exportedAt),
+      sourceId: tag.id,
+      name: tag.name,
+      slug: sanitizeSlug(tag.slug)
+    };
+  }
+  for (const page of doc.pages ?? []) {
+    yield* emitExportPage(page, exportedAt, seenAssetUrls);
+  }
+  for (const post of doc.posts ?? []) {
+    yield* emitExportPost(post, exportedAt, seenAssetUrls);
+  }
+  void snapshotGaps;
+}
+function summarizeWixExport(doc) {
+  const seenAssetUrls = /* @__PURE__ */ new Set();
+  let assets = 0;
+  const countHtml = (html, featured) => {
+    if (featured && !seenAssetUrls.has(featured)) {
+      seenAssetUrls.add(featured);
+      assets += 1;
+    }
+    for (const src of discoverContentAssetUrls(html)) {
+      if (seenAssetUrls.has(src)) continue;
+      seenAssetUrls.add(src);
+      assets += 1;
+    }
+  };
+  for (const post of doc.posts ?? []) {
+    countHtml(post.contentHtml, post.featuredImageUrl);
+  }
+  for (const page of doc.pages ?? []) {
+    countHtml(page.contentHtml);
+  }
+  return {
+    posts: doc.posts?.length ?? 0,
+    pages: doc.pages?.length ?? 0,
+    categories: doc.categories?.length ?? 0,
+    tags: doc.tags?.length ?? 0,
+    assets
+  };
+}
+function parseFeedItems(xml) {
+  const format = detectWixFeedFormat(xml);
+  const doc = parseXmlDocument(xml);
+  if (format === "atom") {
+    return { format, items: asArray2(doc.feed?.entry) };
+  }
+  return { format, items: asArray2(doc.rss?.channel?.item) };
+}
+async function loadWixFeed(filePath) {
+  const xml = await readFile4(filePath, "utf8");
+  const parsed = parseFeedItems(xml);
+  if (parsed.items.length === 0) {
+    throw new Error("Invalid Wix feed: no entries found in RSS or Atom document");
+  }
+  return parsed;
+}
+async function loadWixExport(options) {
+  if (options.data) return assertWixExport(options.data);
+  if (options.client) {
+    const doc = await options.client.collectExport();
+    return assertWixExport(doc);
+  }
+  if (options.clientOptions) {
+    const client = new WixCollectionClient(options.clientOptions);
+    const doc = await client.collectExport();
+    return assertWixExport(doc);
+  }
+  if (options.filePath) {
+    const ext = extname(options.filePath).toLowerCase();
+    if (ext === ".json") {
+      const raw = JSON.parse(await readFile4(options.filePath, "utf8"));
+      return assertWixExport(raw);
+    }
+  }
+  throw new Error("Wix parser requires filePath (.json), data, client, or clientOptions");
+}
+async function resolveSnapshotTargets(options) {
+  if (options.snapshotTargets?.length) return options.snapshotTargets;
+  const listPath = options.urlsFile ?? (options.filePath && extname(options.filePath).toLowerCase() === ".txt" ? options.filePath : void 0);
+  if (listPath) {
+    const urls = await loadUrlListFile(listPath);
+    return urls.map((url, index) => ({
+      url,
+      isHomePage: index === 0 && new URL(url).pathname === "/"
+    }));
+  }
+  return [];
+}
+async function attachSnapshotPages(doc, options) {
+  const targets = await resolveSnapshotTargets(options);
+  if (targets.length === 0) return { doc, gaps: [] };
+  const collector = new WixPageSnapshotCollector(options.snapshotOptions);
+  const { pages, gaps } = await collector.collectPages(targets);
+  return {
+    doc: {
+      ...doc,
+      pages: [...doc.pages ?? [], ...pages]
+    },
+    gaps
+  };
+}
+async function* enumerateWixEntities(options) {
+  if (options.filePath && [".xml", ".rss", ".atom"].includes(extname(options.filePath).toLowerCase())) {
+    yield* enumerateWixFeedEntities(options);
+    const snapshotTargets2 = await resolveSnapshotTargets(options);
+    if (snapshotTargets2.length > 0) {
+      const { doc: doc2, gaps: gaps2 } = await attachSnapshotPages(
+        { exportVersion: 1, pages: [], posts: [] },
+        { ...options, snapshotTargets: snapshotTargets2 }
+      );
+      yield* enumerateWixExportEntities(doc2, gaps2);
+    }
+    return;
+  }
+  if (options.filePath && extname(options.filePath).toLowerCase() === ".txt" && !options.data && !options.client) {
+    const { doc: doc2, gaps: gaps2 } = await attachSnapshotPages(
+      { exportVersion: 1, pages: [], posts: [] },
+      options
+    );
+    yield* enumerateWixExportEntities(doc2, gaps2);
+    return;
+  }
+  const snapshotTargets = await resolveSnapshotTargets(options);
+  if (snapshotTargets.length > 0 && !options.filePath && !options.data && !options.client && !options.clientOptions) {
+    const { doc: doc2, gaps: gaps2 } = await attachSnapshotPages(
+      { exportVersion: 1, pages: [], posts: [] },
+      { ...options, snapshotTargets }
+    );
+    yield* enumerateWixExportEntities(doc2, gaps2);
+    return;
+  }
+  const doc = await loadWixExport(options);
+  const { doc: withSnapshots, gaps } = await attachSnapshotPages(doc, options);
+  yield* enumerateWixExportEntities(withSnapshots, gaps);
+}
+async function* enumerateWixFeedEntities(options) {
+  if (!options.filePath) {
+    throw new Error("Wix feed parser requires filePath");
+  }
+  const { format, items } = await loadWixFeed(options.filePath);
+  const { categories, tags } = collectTaxonomiesFromItems(items);
+  const seenAssetUrls = /* @__PURE__ */ new Set();
+  for (const category of categories.values()) {
+    yield category;
+  }
+  for (const tag of tags.values()) {
+    yield tag;
+  }
+  for (const item of items) {
+    const title = textValue2(item.title) || "Untitled";
+    const link = itemLink(item);
+    const sourceId = itemSourceId(item, link, sanitizeSlug(title));
+    const slug = slugFromLink(link, title, sourceId);
+    const contentHtml = getItemContentHtml(item);
+    for (const asset of collectInlineAssets2(contentHtml, seenAssetUrls, options.exportedAt)) {
+      yield asset;
+    }
+    const post = {
+      type: "post",
+      source: sourceMeta3(sourceId, link || void 0, options.exportedAt),
+      sourceId,
+      title,
+      slug,
+      excerpt: textValue2(item.description) || void 0,
+      contentHtml,
+      publishedAt: itemPublishedAt(item),
+      status: "published",
+      categorySlugs: collectCategorySlugs(item),
+      tagSlugs: collectTagSlugs(item)
+    };
+    yield post;
+  }
+  void format;
+}
+async function summarizeWixFeed(filePath) {
+  const { format, items } = await loadWixFeed(filePath);
+  let posts = 0;
+  let assets = 0;
+  const { categories, tags } = collectTaxonomiesFromItems(items);
+  const seenAssetUrls = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    posts += 1;
+    const contentHtml = getItemContentHtml(item);
+    for (const src of discoverContentAssetUrls(contentHtml)) {
+      if (seenAssetUrls.has(src)) continue;
+      seenAssetUrls.add(src);
+      assets += 1;
+    }
+  }
+  return {
+    format,
+    posts,
+    categories: categories.size,
+    tags: tags.size,
+    assets
+  };
+}
+async function validateWixExportFile(filePath) {
+  try {
+    const summary = await summarizeWixFeed(filePath);
+    return {
+      ok: true,
+      issues: [],
+      summary
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      issues: [
+        {
+          code: "invalid_wix_feed",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ],
+      summary: { posts: 0, categories: 0, tags: 0, assets: 0 }
+    };
+  }
+}
+
+// src/parsers/wix/index.ts
+function resolveInput3(input) {
+  if (typeof input === "string") return { path: input };
+  if (input && typeof input === "object") {
+    const record = input;
+    if (record.client || record.clientOptions || record.data || record.snapshotTargets?.length) {
+      return record;
+    }
+    if (record.path || record.urlsFile || record.urlsPath) {
+      return {
+        path: record.path,
+        urlsFile: record.urlsFile ?? record.urlsPath
+      };
+    }
+  }
+  throw new Error(
+    "Wix adapter requires input path (string or { path }), { data }, { client }, { clientOptions }, or snapshot targets"
+  );
+}
+function toParseOptions(input) {
+  return {
+    filePath: input.path,
+    urlsFile: input.urlsFile,
+    data: input.data,
+    client: input.client,
+    clientOptions: input.clientOptions,
+    snapshotTargets: input.snapshotTargets
+  };
+}
+var wixAdapter = {
+  platform: "wix",
+  async validateInput(input) {
+    try {
+      const resolved = resolveInput3(input);
+      const options = toParseOptions(resolved);
+      if (resolved.data) {
+        const summary = summarizeWixExport(resolved.data);
+        return {
+          ok: true,
+          issues: [],
+          summary: {
+            posts: summary.posts,
+            pages: summary.pages,
+            assets: summary.assets,
+            categories: summary.categories,
+            tags: summary.tags
+          }
+        };
+      }
+      if (resolved.client || resolved.clientOptions) {
+        const doc = await loadWixExport(options);
+        const summary = summarizeWixExport(doc);
+        return {
+          ok: true,
+          issues: [],
+          summary: {
+            posts: summary.posts,
+            pages: summary.pages,
+            assets: summary.assets,
+            categories: summary.categories,
+            tags: summary.tags
+          }
+        };
+      }
+      if (resolved.path?.endsWith(".json")) {
+        const doc = await loadWixExport(options);
+        const summary = summarizeWixExport(doc);
+        return {
+          ok: true,
+          issues: [],
+          summary: {
+            posts: summary.posts,
+            pages: summary.pages,
+            assets: summary.assets,
+            categories: summary.categories,
+            tags: summary.tags
+          }
+        };
+      }
+      if (resolved.path && !resolved.path.endsWith(".txt")) {
+        const result = await validateWixExportFile(resolved.path);
+        return {
+          ok: result.ok,
+          issues: result.issues,
+          summary: {
+            posts: result.summary.posts,
+            pages: 0,
+            assets: result.summary.assets,
+            categories: result.summary.categories,
+            tags: result.summary.tags
+          }
+        };
+      }
+      if (resolved.path?.endsWith(".txt") || resolved.urlsFile) {
+        return {
+          ok: true,
+          issues: [],
+          summary: { pages: 0, posts: 0, assets: 0, categories: 0, tags: 0 }
+        };
+      }
+      throw new Error("Wix validation requires export.xml, export.json, url list, or API client options");
+    } catch (error) {
+      return {
+        ok: false,
+        issues: [
+          {
+            code: "invalid_input",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        ]
+      };
+    }
+  },
+  enumerateEntities(ctx) {
+    return enumerateWixEntities(toParseOptions(resolveInput3(ctx.input)));
+  }
+};
+
+// src/parsers/index.ts
+var adapters = {
+  wordpress: wordpressAdapter,
+  smugmug: smugmugAdapter,
+  squarespace: squarespaceAdapter,
+  wix: wixAdapter
+};
+function getAdapter(platform) {
+  return adapters[platform];
+}
+
+export {
+  rewriteOriginUrlsInText,
+  createWpContentGatewayRewrite,
+  wordpressAdapter,
+  SMUGMUG_API_BASE,
+  SMUGMUG_OAUTH_ENDPOINTS,
+  smugMugCredentialsSchema,
+  signSmugMugOAuthRequest,
+  buildSmugMugAuthorizationHeader,
+  readSmugMugCredentialsFromEnv,
+  SmugMugApiClient,
+  smugmugAdapter,
+  squarespaceAdapter,
+  WixCollectionClient,
+  WixPageSnapshotCollector,
+  wixAdapter,
+  getAdapter
+};
+//# sourceMappingURL=chunk-QEXTXHFG.js.map