@artinstack/migrator 0.1.0

package/dist/chunk-LKNIQQJO.js

@@ -0,0 +1,1579 @@
+import {
+  buildPortfolioMediaLinks,
+  bundleCounts,
+  collectEntities,
+  emptyBundle,
+  entityKey,
+  shouldProcessEntity
+} from "./chunk-JKDRTL24.js";
+
+// src/sinks/types.ts
+var MIGRATION_WRITE_STAGES = [
+  "taxonomy",
+  "assets",
+  "portfolios",
+  "content",
+  "bindings",
+  "redirects"
+];
+
+// src/sinks/run-migration.ts
+import { Readable } from "stream";
+
+// src/lib/content-asset-urls.ts
+import * as cheerio from "cheerio";
+var ASSET_URL_PARAM_PATTERN = /\b(?:src|image|url)\s*=\s*["']([^"']+)["']/gi;
+var IMAGE_EXTENSION_PATTERN = /\.(?:jpe?g|png|gif|webp|avif|svg)(?:[?#]|$)/i;
+var WP_UPLOADS_PATTERN = /\/wp-content\/uploads\//i;
+function extractImgTagSrcs(content) {
+  if (!content.trim()) return [];
+  const $ = cheerio.load(content, { xml: false });
+  const srcs = [];
+  $("img[src]").each((_, el) => {
+    const src = $(el).attr("src")?.trim();
+    if (src) srcs.push(src);
+  });
+  return srcs;
+}
+function discoverRawImgSrcs(content) {
+  return extractImgTagSrcs(content).filter((src) => !src.startsWith("data:"));
+}
+function normalizeAssetUrl(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.startsWith("data:")) return void 0;
+  if (trimmed.startsWith("//")) return `https:${trimmed}`;
+  return trimmed;
+}
+function isLikelyImageUrl(url) {
+  if (!url || url.startsWith("data:")) return false;
+  if (url.startsWith("/")) {
+    return WP_UPLOADS_PATTERN.test(url) || IMAGE_EXTENSION_PATTERN.test(url);
+  }
+  if (!/^https?:\/\//i.test(url)) return false;
+  if (WP_UPLOADS_PATTERN.test(url)) return true;
+  try {
+    const pathname = new URL(url).pathname;
+    return IMAGE_EXTENSION_PATTERN.test(pathname);
+  } catch {
+    return IMAGE_EXTENSION_PATTERN.test(url);
+  }
+}
+function discoverContentAssetUrls(content) {
+  if (!content.trim()) return [];
+  const urls = /* @__PURE__ */ new Set();
+  for (const raw of extractImgTagSrcs(content)) {
+    const normalized = normalizeAssetUrl(raw);
+    if (normalized && isLikelyImageUrl(normalized)) {
+      urls.add(normalized);
+    }
+  }
+  for (const match of content.matchAll(ASSET_URL_PARAM_PATTERN)) {
+    const normalized = normalizeAssetUrl(match[1] ?? "");
+    if (normalized && isLikelyImageUrl(normalized)) {
+      urls.add(normalized);
+    }
+  }
+  return [...urls];
+}
+
+// src/transformers/rewrite-inline-images.ts
+import * as cheerio2 from "cheerio";
+function rewriteSrcset(srcset, options, uploadedBySourceId, referencedSources, unresolved) {
+  return srcset.split(",").map((entry) => {
+    const trimmed = entry.trim();
+    if (!trimmed) return entry;
+    const [urlPart, descriptor] = trimmed.split(/\s+/, 2);
+    const normalized = normalizeAssetUrl(urlPart ?? "");
+    if (!normalized) return entry;
+    referencedSources.add(normalized);
+    const ref = options.resolveAsset(normalized);
+    if (!ref?.sourceAssetId) {
+      unresolved.add(normalized);
+      return entry;
+    }
+    const uploaded = uploadedBySourceId.get(ref.sourceAssetId);
+    if (!uploaded) {
+      unresolved.add(normalized);
+      return entry;
+    }
+    const replaced = options.replaceWith(ref, uploaded);
+    return descriptor ? `${replaced} ${descriptor}` : replaced;
+  }).join(", ");
+}
+function rewriteInlineImages(html, options, uploadedBySourceId) {
+  if (!html.trim()) {
+    return { html, referencedSources: [], unresolved: [] };
+  }
+  const $ = cheerio2.load(html, { xml: false });
+  const referencedSources = /* @__PURE__ */ new Set();
+  const unresolved = /* @__PURE__ */ new Set();
+  $("img").each((_, element) => {
+    const img = $(element);
+    const src = img.attr("src")?.trim();
+    if (src && !src.startsWith("data:")) {
+      const normalized = normalizeAssetUrl(src);
+      if (normalized) {
+        referencedSources.add(normalized);
+        const ref = options.resolveAsset(normalized);
+        if (!ref?.sourceAssetId) {
+          unresolved.add(normalized);
+        } else {
+          const uploaded = uploadedBySourceId.get(ref.sourceAssetId);
+          if (!uploaded) {
+            unresolved.add(normalized);
+          } else {
+            img.attr("src", options.replaceWith(ref, uploaded));
+          }
+        }
+      }
+    }
+    const srcset = img.attr("srcset")?.trim();
+    if (srcset) {
+      img.attr("srcset", rewriteSrcset(srcset, options, uploadedBySourceId, referencedSources, unresolved));
+    }
+  });
+  return {
+    html: $.root().html() ?? html,
+    referencedSources: [...referencedSources],
+    unresolved: [...unresolved]
+  };
+}
+
+// src/sinks/conflicts.ts
+import * as cheerio4 from "cheerio";
+
+// src/parsers/squarespace/parse-export.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+
+// src/lib/utility.ts
+function sanitizeSlug(raw) {
+  return raw.trim().toLowerCase().replace(/&[^;]+;/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 200);
+}
+function linkToPath(link) {
+  if (!link) return void 0;
+  try {
+    const url = new URL(link);
+    const path = url.pathname;
+    if (!path || path === "/") return "/";
+    return path.endsWith("/") ? path : `${path}/`;
+  } catch {
+    if (link.startsWith("/")) {
+      return link.endsWith("/") ? link : `${link}/`;
+    }
+    return void 0;
+  }
+}
+
+// src/parsers/squarespace/collect.ts
+import * as cheerio3 from "cheerio";
+import { z } from "zod";
+var SQUARESPACE_JSON_FORMAT = "json-pretty";
+var squarespaceClientOptionsSchema = z.object({
+  format: z.enum(["json", "json-pretty"]).default("json-pretty"),
+  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()
+});
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildJsonPrettyUrl(pageUrl, format = SQUARESPACE_JSON_FORMAT) {
+  const url = new URL(pageUrl);
+  url.searchParams.set("format", format);
+  return url.toString();
+}
+function mapWorkflowState(state) {
+  if (state === 1 || state === "1") return "published";
+  if (state === 2 || state === "2") return "draft";
+  return "published";
+}
+function mapPublishOn(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  return new Date(value).toISOString();
+}
+function readSeo(seoData, field) {
+  const record = asRecord(seoData);
+  if (!record) return void 0;
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function inferBlockTypeFromClassName(className) {
+  const match = className.match(/\bsqs-block-([a-z0-9-]+)\b/i);
+  if (!match?.[1]) return "html";
+  const raw = match[1].toLowerCase();
+  if (raw === "horizontalrule") return "line";
+  return raw.replace(/-block$/g, "");
+}
+function extractBlocksFromBodyHtml(html) {
+  if (!html.trim()) return [];
+  const $ = cheerio3.load(html, { xml: false });
+  const blocks = [];
+  $(".sqs-block").each((_, element) => {
+    const el = $(element);
+    const className = el.attr("class") ?? "";
+    const type = inferBlockTypeFromClassName(className);
+    const id = el.attr("id")?.replace(/^block-/, "");
+    const content = el.find(".sqs-block-content").first();
+    const innerHtml = (content.length ? content.html() : el.html()) ?? "";
+    if (type === "image") {
+      const img = content.find("img").first();
+      const imageUrl = img.attr("data-src") ?? img.attr("src") ?? void 0;
+      blocks.push({
+        id,
+        type,
+        imageUrl,
+        altText: img.attr("alt") ?? void 0,
+        caption: content.find("figcaption").text() || void 0,
+        html: innerHtml || void 0
+      });
+      return;
+    }
+    if (type === "gallery") {
+      const items = [];
+      content.find("img").each((idx, imgEl) => {
+        const img = $(imgEl);
+        const imageUrl = img.attr("data-src") ?? img.attr("src");
+        if (!imageUrl) return;
+        items.push({
+          id: img.attr("data-image-id") ?? `gallery-${idx}`,
+          imageUrl,
+          altText: img.attr("alt") ?? void 0
+        });
+      });
+      blocks.push({ id, type, items, html: innerHtml || void 0 });
+      return;
+    }
+    if (type === "button") {
+      const anchor = content.find("a").first();
+      blocks.push({
+        id,
+        type,
+        url: anchor.attr("href") ?? void 0,
+        label: anchor.text() || void 0,
+        html: innerHtml || void 0
+      });
+      return;
+    }
+    if (type === "video" || type === "embed") {
+      const iframe = content.find("iframe").first();
+      blocks.push({
+        id,
+        type: type === "embed" ? "embed" : "video",
+        embedHtml: iframe.length ? $.html(iframe) : innerHtml || void 0,
+        html: innerHtml || void 0
+      });
+      return;
+    }
+    blocks.push({
+      id,
+      type,
+      html: innerHtml || void 0,
+      value: type === "markdown" || type === "quote" ? content.text() : void 0
+    });
+  });
+  return blocks;
+}
+function mapWireBlocks(value) {
+  if (!Array.isArray(value)) return void 0;
+  const blocks = [];
+  for (const entry of value) {
+    const record = asRecord(entry);
+    if (!record) continue;
+    const type = String(record.type ?? record.blockType ?? "html");
+    blocks.push({
+      id: record.id ? String(record.id) : void 0,
+      type,
+      html: typeof record.html === "string" ? record.html : void 0,
+      value: typeof record.value === "string" ? record.value : void 0,
+      imageUrl: typeof record.imageUrl === "string" ? record.imageUrl : typeof record.assetUrl === "string" ? record.assetUrl : void 0,
+      altText: typeof record.altText === "string" ? record.altText : void 0,
+      caption: typeof record.caption === "string" ? record.caption : void 0,
+      url: typeof record.url === "string" ? record.url : void 0,
+      label: typeof record.label === "string" ? record.label : void 0,
+      embedHtml: typeof record.embedHtml === "string" ? record.embedHtml : void 0,
+      items: Array.isArray(record.items) ? record.items.map((item) => asRecord(item)).filter((item) => !!item).map((item) => ({
+        id: item.id ? String(item.id) : void 0,
+        imageUrl: String(item.imageUrl ?? item.assetUrl ?? ""),
+        altText: typeof item.altText === "string" ? item.altText : void 0,
+        caption: typeof item.caption === "string" ? item.caption : void 0
+      })).filter((item) => item.imageUrl.length > 0) : void 0
+    });
+  }
+  return blocks.length > 0 ? blocks : void 0;
+}
+function mapStructuredBlocksFromItem(item) {
+  const direct = mapWireBlocks(item.blocks);
+  if (direct?.length) return direct;
+  const sections = item.sections;
+  if (!Array.isArray(sections)) return void 0;
+  const flattened = [];
+  for (const section of sections) {
+    const sectionRecord = asRecord(section);
+    if (!sectionRecord) continue;
+    const rows = sectionRecord.rows;
+    if (!Array.isArray(rows)) continue;
+    for (const row of rows) {
+      const rowRecord = asRecord(row);
+      if (!rowRecord) continue;
+      const columns = rowRecord.columns;
+      if (!Array.isArray(columns)) continue;
+      for (const column of columns) {
+        const columnRecord = asRecord(column);
+        if (!columnRecord) continue;
+        const blocks = mapWireBlocks(columnRecord.blocks);
+        if (blocks) flattened.push(...blocks);
+      }
+    }
+  }
+  return flattened.length > 0 ? flattened : void 0;
+}
+function mapWireItemContent(item) {
+  const structured = mapStructuredBlocksFromItem(item);
+  if (structured?.length) {
+    return { blocks: structured };
+  }
+  const body = typeof item.body === "string" ? item.body : void 0;
+  if (!body) return { contentHtml: "" };
+  const parsedBlocks = extractBlocksFromBodyHtml(body);
+  if (parsedBlocks.length > 0) {
+    return { blocks: parsedBlocks };
+  }
+  return { contentHtml: body };
+}
+function isBlogCollection(collection) {
+  if (!collection) return false;
+  const ordering = String(collection.ordering ?? "").toLowerCase();
+  if (ordering === "chronological" || ordering === "calendar") return true;
+  const typeName = String(collection.typeName ?? collection.typeLabel ?? "").toLowerCase();
+  return typeName.includes("blog");
+}
+function isStaticPageItem(item, collection) {
+  const recordTypeLabel = String(item.recordTypeLabel ?? "").toLowerCase();
+  if (recordTypeLabel.includes("page")) return true;
+  const collectionType = String(collection?.typeName ?? collection?.typeLabel ?? "").toLowerCase();
+  return collectionType === "page" || collectionType.includes("page-collection");
+}
+function mapWireItemToPost(item) {
+  const content = mapWireItemContent(item);
+  return {
+    id: String(item.id ?? item.systemDataId ?? item.urlId ?? ""),
+    title: String(item.title ?? "Untitled"),
+    slug: sanitizeSlug(String(item.urlId ?? item.title ?? item.id ?? "post")),
+    url: typeof item.fullUrl === "string" ? item.fullUrl : void 0,
+    excerpt: typeof item.excerpt === "string" ? item.excerpt : void 0,
+    publishedAt: mapPublishOn(item.publishOn ?? item.addedOn),
+    status: mapWorkflowState(item.workflowState),
+    categorySlugs: asStringArray(item.categories).map((slug) => sanitizeSlug(slug)),
+    tagSlugs: asStringArray(item.tags).map((slug) => sanitizeSlug(slug)),
+    featuredImageUrl: typeof item.assetUrl === "string" ? item.assetUrl : void 0,
+    seoTitle: readSeo(item.seoData, "title"),
+    seoDescription: readSeo(item.seoData, "description"),
+    ...content
+  };
+}
+function mapWireItemToPage(item, options) {
+  const content = mapWireItemContent(item);
+  return {
+    id: String(item.id ?? item.urlId ?? ""),
+    title: String(item.title ?? "Untitled"),
+    slug: sanitizeSlug(String(item.urlId ?? item.title ?? item.id ?? "page")),
+    url: typeof item.fullUrl === "string" ? item.fullUrl : options?.fallbackUrl,
+    status: mapWorkflowState(item.workflowState),
+    isHomePage: options?.isHomePage,
+    seoTitle: readSeo(item.seoData, "title"),
+    seoDescription: readSeo(item.seoData, "description"),
+    ...content
+  };
+}
+function mapWireCategories(collection) {
+  if (!collection) return [];
+  return asStringArray(collection.categories).map((name) => ({
+    id: `cat-${sanitizeSlug(name)}`,
+    name,
+    slug: sanitizeSlug(name)
+  }));
+}
+function mapWireTags(items) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    for (const tag of asStringArray(item.tags)) {
+      const slug = sanitizeSlug(tag);
+      if (!seen.has(slug)) {
+        seen.set(slug, { id: `tag-${slug}`, name: tag, slug });
+      }
+    }
+  }
+  return [...seen.values()];
+}
+function siteFromWire(wire) {
+  const website = asRecord(wire.website);
+  if (!website) return void 0;
+  const url = typeof website.authenticUrl === "string" ? website.authenticUrl : typeof website.baseUrl === "string" ? website.baseUrl : void 0;
+  const title = typeof website.siteTitle === "string" ? website.siteTitle : void 0;
+  if (!url && !title) return void 0;
+  return { url, title };
+}
+function mapJsonPrettyWire(wire, context) {
+  if (!isRecord(wire)) {
+    throw new Error("Invalid Squarespace json-pretty response");
+  }
+  const collection = asRecord(wire.collection);
+  const partial = {
+    site: siteFromWire(wire),
+    pages: [],
+    posts: [],
+    categories: mapWireCategories(collection),
+    tags: []
+  };
+  if (Array.isArray(wire.items)) {
+    const itemRecords = wire.items.map((entry) => asRecord(entry)).filter((entry) => !!entry);
+    partial.tags = mapWireTags(itemRecords);
+    for (const item2 of itemRecords) {
+      if (isStaticPageItem(item2, collection)) {
+        partial.pages.push(
+          mapWireItemToPage(item2, { fallbackUrl: context?.fetchedUrl, isHomePage: context?.isHomePage })
+        );
+      } else {
+        partial.posts.push(mapWireItemToPost(item2));
+      }
+    }
+    return partial;
+  }
+  const item = asRecord(wire.item);
+  if (item) {
+    if (isStaticPageItem(item, collection)) {
+      partial.pages.push(
+        mapWireItemToPage(item, { fallbackUrl: context?.fetchedUrl, isHomePage: context?.isHomePage })
+      );
+    } else {
+      partial.posts.push(mapWireItemToPost(item));
+      partial.tags = mapWireTags([item]);
+    }
+    return partial;
+  }
+  if (collection && isBlogCollection(collection) === false) {
+    partial.pages.push(
+      mapWireItemToPage(
+        {
+          id: collection.id ?? collection.urlId ?? collection.fullUrl,
+          title: collection.title ?? collection.navigationTitle,
+          urlId: collection.urlId,
+          fullUrl: collection.fullUrl ?? context?.fetchedUrl,
+          body: collection.description,
+          workflowState: collection.draft ? 2 : 1,
+          seoData: collection.seoData
+        },
+        { fallbackUrl: context?.fetchedUrl, isHomePage: context?.isHomePage }
+      )
+    );
+  }
+  return partial;
+}
+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 mergeSquarespaceExportPartials(partials) {
+  const merged = {
+    exportVersion: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pages: [],
+    posts: [],
+    categories: [],
+    tags: []
+  };
+  for (const partial of partials) {
+    if (partial.site) merged.site = { ...merged.site, ...partial.site };
+    merged.pages.push(...partial.pages ?? []);
+    merged.posts.push(...partial.posts ?? []);
+    merged.categories.push(...partial.categories ?? []);
+    merged.tags.push(...partial.tags ?? []);
+  }
+  merged.pages = dedupeById(merged.pages);
+  merged.posts = dedupeById(merged.posts ?? []);
+  merged.categories = dedupeBySlug(merged.categories ?? []);
+  merged.tags = dedupeBySlug(merged.tags ?? []);
+  return merged;
+}
+function paginationFromWire(wire) {
+  return asRecord(wire)?.pagination;
+}
+function inferTargetKind(target) {
+  if (target.kind && target.kind !== "auto") return target.kind;
+  try {
+    const pathname = new URL(target.url).pathname;
+    if (pathname === "/" || pathname.endsWith("/")) return "collection";
+  } catch {
+    return "page";
+  }
+  return "page";
+}
+var SquarespaceCollectionClient = class {
+  format;
+  maxRetries;
+  retryBaseDelayMs;
+  maxRetryDelayMs;
+  requestIntervalMs;
+  fetchImpl;
+  lastRequestAt = 0;
+  constructor(options = {}) {
+    const parsed = squarespaceClientOptionsSchema.parse(options);
+    this.format = parsed.format;
+    this.maxRetries = parsed.maxRetries;
+    this.retryBaseDelayMs = parsed.retryBaseDelayMs;
+    this.maxRetryDelayMs = parsed.maxRetryDelayMs;
+    this.requestIntervalMs = parsed.requestIntervalMs;
+    this.fetchImpl = parsed.fetchImpl ?? fetch;
+  }
+  buildJsonPrettyUrl(pageUrl) {
+    return buildJsonPrettyUrl(pageUrl, this.format);
+  }
+  async fetchWire(url) {
+    const response = await this.requestWithRetry(this.buildJsonPrettyUrl(url));
+    return response.json();
+  }
+  async collectExport(targets) {
+    if (targets.length === 0) {
+      throw new Error("Squarespace collector requires at least one target URL");
+    }
+    const partials = [];
+    for (const target of targets) {
+      const kind = inferTargetKind(target);
+      if (kind === "collection") {
+        partials.push(...await this.collectCollectionPages(target));
+      } else {
+        const wire = await this.fetchWire(target.url);
+        partials.push(
+          mapJsonPrettyWire(wire, { fetchedUrl: target.url, isHomePage: target.isHomePage })
+        );
+      }
+    }
+    return mergeSquarespaceExportPartials(partials);
+  }
+  async collectCollectionPages(target) {
+    const partials = [];
+    let nextUrl = target.url;
+    while (nextUrl) {
+      const wire = await this.fetchWire(nextUrl);
+      partials.push(
+        mapJsonPrettyWire(wire, { fetchedUrl: nextUrl, isHomePage: target.isHomePage })
+      );
+      const pagination = paginationFromWire(wire);
+      if (!pagination?.nextPage || !pagination.nextPageUrl) break;
+      const base = new URL(target.url);
+      nextUrl = new URL(pagination.nextPageUrl, `${base.origin}/`).toString();
+    }
+    return partials;
+  }
+  async requestWithRetry(url) {
+    let attempt = 0;
+    while (true) {
+      await this.throttle();
+      const response = await this.fetchImpl(url, {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      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(
+          `Squarespace 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();
+  }
+};
+
+// src/parsers/squarespace/parse-export.ts
+var PLATFORM = "squarespace";
+var UNSUPPORTED_ATTR = "data-artinstack-unsupported-block";
+var BLOCK_ID_ATTR = "data-artinstack-block-id";
+var SUPPORTED_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "html",
+  "text",
+  "markdown",
+  "image",
+  "gallery",
+  "quote",
+  "button",
+  "video",
+  "code",
+  "spacer",
+  "line",
+  "horizontalrule",
+  "hr"
+]);
+var UNSUPPORTED_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "product",
+  "products",
+  "form",
+  "newsletter",
+  "donation",
+  "calendar",
+  "chart",
+  "map",
+  "music",
+  "social",
+  "summary",
+  "archive",
+  "acuity",
+  "member-area",
+  "digital-product",
+  "folder",
+  "index",
+  "tock",
+  "opentable",
+  "soundcloud",
+  "foursquare"
+]);
+function sourceMeta(id, url, exportedAt) {
+  return {
+    platform: PLATFORM,
+    id,
+    url,
+    path: linkToPath(url),
+    exportedAt
+  };
+}
+function mapPublishStatus(status) {
+  switch ((status ?? "published").toLowerCase()) {
+    case "published":
+      return "published";
+    case "draft":
+    case "scheduled":
+      return "draft";
+    default:
+      return "archived";
+  }
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function blockShell(type, inner, blockId) {
+  const idAttr = blockId ? ` id="sqs-block-${blockId}"` : "";
+  return `<div class="sqs-block sqs-block-${type}"${idAttr}>${inner}</div>`;
+}
+function unsupportedPlaceholder(type, blockId) {
+  const idPart = blockId ? ` ${BLOCK_ID_ATTR}="${escapeHtml(blockId)}"` : "";
+  return `<div class="sqs-block sqs-block-unsupported" ${UNSUPPORTED_ATTR}="${escapeHtml(type)}"${idPart} aria-hidden="true"></div>`;
+}
+function flattenGalleryItem(item) {
+  const alt = item.altText ? ` alt="${escapeHtml(item.altText)}"` : "";
+  const caption = item.caption ? `<figcaption>${item.caption}</figcaption>` : "";
+  return `<figure><img src="${escapeHtml(item.imageUrl)}"${alt} />${caption}</figure>`;
+}
+function flattenSquarespaceBlock(block) {
+  const type = block.type.toLowerCase();
+  const blockId = block.id;
+  const assetUrls = [];
+  if (UNSUPPORTED_BLOCK_TYPES.has(type)) {
+    return {
+      contentHtml: unsupportedPlaceholder(type, blockId),
+      assetUrls
+    };
+  }
+  if (!SUPPORTED_BLOCK_TYPES.has(type)) {
+    return {
+      contentHtml: unsupportedPlaceholder(type || "unknown", blockId),
+      assetUrls
+    };
+  }
+  switch (type) {
+    case "html":
+    case "text":
+      return {
+        contentHtml: blockShell(type, block.html ?? block.value ?? "", blockId),
+        assetUrls
+      };
+    case "markdown":
+      return {
+        contentHtml: blockShell(
+          type,
+          block.html ?? `<div class="sqs-markdown">${escapeHtml(block.value ?? "")}</div>`,
+          blockId
+        ),
+        assetUrls
+      };
+    case "image": {
+      const url = block.imageUrl ?? "";
+      if (url) assetUrls.push(url);
+      const alt = block.altText ? ` alt="${escapeHtml(block.altText)}"` : "";
+      const caption = block.caption ? `<figcaption>${block.caption}</figcaption>` : "";
+      const inner = url ? `<figure><img src="${escapeHtml(url)}"${alt} />${caption}</figure>` : "";
+      return { contentHtml: blockShell(type, inner, blockId), assetUrls };
+    }
+    case "gallery": {
+      const figures = (block.items ?? []).map((item) => {
+        assetUrls.push(item.imageUrl);
+        return flattenGalleryItem(item);
+      }).join("");
+      return {
+        contentHtml: blockShell(type, `<div class="sqs-gallery">${figures}</div>`, blockId),
+        assetUrls
+      };
+    }
+    case "quote": {
+      const inner = block.html ?? `<blockquote>${escapeHtml(block.value ?? "")}</blockquote>`;
+      return { contentHtml: blockShell(type, inner, blockId), assetUrls };
+    }
+    case "button": {
+      const href = block.url ?? "#";
+      const label = escapeHtml(block.label ?? block.value ?? "Learn more");
+      return {
+        contentHtml: blockShell(
+          type,
+          `<p><a class="sqs-block-button" href="${escapeHtml(href)}">${label}</a></p>`,
+          blockId
+        ),
+        assetUrls
+      };
+    }
+    case "video": {
+      const inner = block.embedHtml ?? block.html ?? (block.url ? `<p><a href="${escapeHtml(block.url)}">Video</a></p>` : "");
+      return { contentHtml: blockShell(type, inner, blockId), assetUrls };
+    }
+    case "code": {
+      const inner = block.html ?? `<pre><code>${escapeHtml(block.value ?? "")}</code></pre>`;
+      return { contentHtml: blockShell(type, inner, blockId), assetUrls };
+    }
+    case "spacer":
+      return {
+        contentHtml: blockShell(type, `<div class="sqs-spacer" aria-hidden="true"></div>`, blockId),
+        assetUrls
+      };
+    case "line":
+    case "horizontalrule":
+    case "hr":
+      return { contentHtml: blockShell("line", "<hr />", blockId), assetUrls };
+    default:
+      return {
+        contentHtml: unsupportedPlaceholder(type, blockId),
+        assetUrls
+      };
+  }
+}
+function flattenSquarespaceBlocks(blocks) {
+  const parts = [];
+  const assetUrls = [];
+  for (const block of blocks) {
+    const flattened = flattenSquarespaceBlock(block);
+    parts.push(flattened.contentHtml);
+    assetUrls.push(...flattened.assetUrls);
+  }
+  return {
+    contentHtml: parts.join("\n"),
+    assetUrls
+  };
+}
+function resolveContentHtml(entity) {
+  if (entity.blocks?.length) {
+    return flattenSquarespaceBlocks(entity.blocks);
+  }
+  const html = entity.contentHtml ?? "";
+  return {
+    contentHtml: html,
+    assetUrls: [...discoverContentAssetUrls(html)]
+  };
+}
+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",
+    svg: "image/svg+xml"
+  };
+  return ext ? map[ext] : void 0;
+}
+function filenameFromUrl(url, fallback) {
+  try {
+    return basename(new URL(url).pathname) || fallback;
+  } catch {
+    return basename(url.split("?")[0] ?? "") || fallback;
+  }
+}
+function assetFromUrl(url, exportedAt, index) {
+  const filename = filenameFromUrl(url, `asset-${index}.jpg`);
+  const sourceId = `asset-${sanitizeSlug(filename)}-${index}`;
+  return {
+    type: "asset",
+    source: sourceMeta(sourceId, url, exportedAt),
+    sourceId,
+    sourceUrl: url,
+    filename,
+    mimeType: guessMime(filename)
+  };
+}
+function isSquarespaceExport(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  const version = record.exportVersion;
+  return (version === 1 || version === "1") && Array.isArray(record.pages);
+}
+async function loadSquarespaceExport(options) {
+  if (options.data) return options.data;
+  if (options.client) {
+    if (!options.collectTargets?.length) {
+      throw new Error("Squarespace client.collectExport requires collectTargets");
+    }
+    return options.client.collectExport(options.collectTargets);
+  }
+  if (options.collectTargets?.length) {
+    const client = new SquarespaceCollectionClient(options.clientOptions);
+    return client.collectExport(options.collectTargets);
+  }
+  if (!options.filePath) {
+    throw new Error("Squarespace parser requires filePath, data, client, or collectTargets");
+  }
+  const raw = JSON.parse(await readFile(options.filePath, "utf8"));
+  if (isSquarespaceExport(raw)) return raw;
+  throw new Error("Invalid Squarespace export: expected exportVersion 1 with pages[]");
+}
+function* emitAssetsFromContent(contentHtml, explicitUrls, exportedAt) {
+  const seen = /* @__PURE__ */ new Set();
+  const urls = [...explicitUrls, ...discoverContentAssetUrls(contentHtml)];
+  let index = 0;
+  for (const url of urls) {
+    if (seen.has(url)) continue;
+    seen.add(url);
+    yield assetFromUrl(url, exportedAt, index);
+    index += 1;
+  }
+}
+async function* emitPage(page, exportedAt) {
+  const { contentHtml, assetUrls } = resolveContentHtml(page);
+  yield {
+    type: "page",
+    source: sourceMeta(page.id, page.url, exportedAt),
+    sourceId: page.id,
+    title: page.title,
+    slug: sanitizeSlug(page.slug),
+    contentHtml,
+    contentCss: page.contentCss,
+    isHomePage: page.isHomePage,
+    status: mapPublishStatus(page.status),
+    seoTitle: page.seoTitle,
+    seoDescription: page.seoDescription
+  };
+  yield* emitAssetsFromContent(contentHtml, assetUrls, exportedAt);
+}
+async function* emitPost(post, exportedAt) {
+  const { contentHtml, assetUrls } = resolveContentHtml(post);
+  let featuredAssetSourceId;
+  if (post.featuredImageUrl) {
+    featuredAssetSourceId = `featured-${post.id}`;
+  }
+  yield {
+    type: "post",
+    source: sourceMeta(post.id, post.url, exportedAt),
+    sourceId: post.id,
+    title: post.title,
+    slug: sanitizeSlug(post.slug),
+    excerpt: post.excerpt,
+    contentHtml,
+    publishedAt: post.publishedAt,
+    status: mapPublishStatus(post.status),
+    categorySlugs: post.categorySlugs,
+    tagSlugs: post.tagSlugs,
+    featuredAssetSourceId,
+    seoTitle: post.seoTitle,
+    seoDescription: post.seoDescription
+  };
+  if (post.featuredImageUrl) {
+    const filename = filenameFromUrl(post.featuredImageUrl, `${post.id}-featured.jpg`);
+    yield {
+      type: "asset",
+      source: sourceMeta(featuredAssetSourceId, post.featuredImageUrl, exportedAt),
+      sourceId: featuredAssetSourceId,
+      sourceUrl: post.featuredImageUrl,
+      filename,
+      mimeType: guessMime(filename)
+    };
+  }
+  yield* emitAssetsFromContent(contentHtml, assetUrls, exportedAt);
+}
+async function* enumerateSquarespaceEntities(options) {
+  const doc = await loadSquarespaceExport(options);
+  const exportedAt = doc.exportedAt;
+  for (const category of doc.categories ?? []) {
+    yield {
+      type: "category",
+      source: sourceMeta(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: sourceMeta(tag.id, void 0, exportedAt),
+      sourceId: tag.id,
+      name: tag.name,
+      slug: sanitizeSlug(tag.slug)
+    };
+  }
+  for (const page of doc.pages) {
+    yield* emitPage(page, exportedAt);
+  }
+  for (const post of doc.posts ?? []) {
+    yield* emitPost(post, exportedAt);
+  }
+}
+function summarizeSquarespaceExport(doc) {
+  return {
+    pages: doc.pages.length,
+    posts: doc.posts?.length ?? 0,
+    categories: doc.categories?.length ?? 0,
+    tags: doc.tags?.length ?? 0
+  };
+}
+async function validateSquarespaceExportFile(filePath) {
+  const issues = [];
+  let doc;
+  try {
+    doc = await loadSquarespaceExport({ filePath });
+  } catch (error) {
+    return {
+      ok: false,
+      issues: [
+        {
+          code: "invalid_export",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ],
+      summary: {}
+    };
+  }
+  if (doc.pages.length === 0 && (doc.posts?.length ?? 0) === 0) {
+    issues.push({ code: "empty_export", message: "No pages or posts in export" });
+  }
+  const summary = summarizeSquarespaceExport(doc);
+  return {
+    ok: issues.length === 0,
+    issues,
+    summary: {
+      pages: summary.pages,
+      posts: summary.posts,
+      categories: summary.categories,
+      tags: summary.tags,
+      portfolios: 0,
+      assets: 0
+    }
+  };
+}
+function findUnsupportedBlockMarkers(html) {
+  const markers = [];
+  const pattern = /data-artinstack-unsupported-block="([^"]+)"(?:\s+data-artinstack-block-id="([^"]*)")?/g;
+  for (const match of html.matchAll(pattern)) {
+    markers.push({
+      blockType: match[1] ?? "unknown",
+      blockId: match[2] || void 0
+    });
+  }
+  return markers;
+}
+
+// src/sinks/conflicts.ts
+function emptyConflictReport() {
+  return {
+    duplicatePostSlugs: [],
+    duplicatePageSlugs: [],
+    missingFeaturedImages: [],
+    staleAssetUrls: [],
+    invalidHtml: [],
+    unresolvedInlineImages: [],
+    unsupportedBlocks: [],
+    redirectLoops: []
+  };
+}
+function findDuplicateSlugs(items, entityType) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const list = bySlug.get(item.slug) ?? [];
+    list.push(item.sourceId);
+    bySlug.set(item.slug, list);
+  }
+  const conflicts = [];
+  for (const [slug, sourceIds] of bySlug) {
+    if (sourceIds.length > 1) {
+      conflicts.push({ entityType, slug, sourceIds });
+    }
+  }
+  return conflicts;
+}
+function analyzeHtml(html) {
+  const issues = [];
+  if (/<script\b/i.test(html)) {
+    issues.push("script_tag_present");
+  }
+  try {
+    const $ = cheerio4.load(html, { xml: false });
+    $("p").each((_, el) => {
+      const inner = $(el).html() ?? "";
+      if (inner.includes("<p")) {
+        issues.push("nested_paragraph");
+      }
+    });
+  } catch {
+    issues.push("html_parse_error");
+  }
+  return [...new Set(issues)];
+}
+function mediaUrlSet(bundle) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const asset of bundle.media) {
+    const normalized = normalizeAssetUrl(asset.sourceUrl);
+    if (normalized) urls.add(normalized);
+    urls.add(asset.sourceUrl);
+  }
+  return urls;
+}
+function findUnresolvedInlineImages(sourceId, contentHtml, mediaUrls) {
+  const conflicts = [];
+  for (const raw of discoverRawImgSrcs(contentHtml)) {
+    const normalized = normalizeAssetUrl(raw);
+    if (!normalized) continue;
+    if (!mediaUrls.has(normalized) && !mediaUrls.has(raw)) {
+      conflicts.push({ postOrPageSourceId: sourceId, src: raw });
+    }
+  }
+  return conflicts;
+}
+function findUnsupportedBlocks(entityType, sourceId, contentHtml) {
+  return findUnsupportedBlockMarkers(contentHtml).map((marker) => ({
+    entityType,
+    sourceId,
+    blockType: marker.blockType,
+    blockId: marker.blockId
+  }));
+}
+function analyzeConflicts(bundle, options) {
+  const report = emptyConflictReport();
+  const mediaUrls = mediaUrlSet(bundle);
+  report.duplicatePostSlugs = findDuplicateSlugs(bundle.posts, "post");
+  report.duplicatePageSlugs = findDuplicateSlugs(bundle.pages, "page");
+  for (const post of bundle.posts) {
+    if (post.sourceFeaturedMediaId && !post.featuredAssetSourceId) {
+      report.missingFeaturedImages.push({
+        postSourceId: post.sourceId,
+        featuredMediaSourceId: post.sourceFeaturedMediaId,
+        reason: "attachment_not_in_export"
+      });
+    }
+    const htmlIssues = analyzeHtml(post.contentHtml);
+    if (htmlIssues.length) {
+      report.invalidHtml.push({
+        entityType: "post",
+        sourceId: post.sourceId,
+        issues: htmlIssues
+      });
+    }
+    report.unresolvedInlineImages.push(
+      ...findUnresolvedInlineImages(post.sourceId, post.contentHtml, mediaUrls)
+    );
+    report.unsupportedBlocks.push(
+      ...findUnsupportedBlocks("post", post.sourceId, post.contentHtml)
+    );
+  }
+  for (const page of bundle.pages) {
+    const htmlIssues = analyzeHtml(page.contentHtml);
+    if (htmlIssues.length) {
+      report.invalidHtml.push({
+        entityType: "page",
+        sourceId: page.sourceId,
+        issues: htmlIssues
+      });
+    }
+    report.unresolvedInlineImages.push(
+      ...findUnresolvedInlineImages(page.sourceId, page.contentHtml, mediaUrls)
+    );
+    report.unsupportedBlocks.push(
+      ...findUnsupportedBlocks("page", page.sourceId, page.contentHtml)
+    );
+  }
+  if (options?.staleAssetUrls) {
+    report.staleAssetUrls = options.staleAssetUrls;
+  }
+  if (options?.redirectLoops) {
+    report.redirectLoops = options.redirectLoops;
+  }
+  return report;
+}
+function hasBlockingConflicts(report) {
+  return report.duplicatePageSlugs.length > 0 || report.redirectLoops.some((r) => r.blocked);
+}
+function hasWarnings(report) {
+  return report.duplicatePostSlugs.length > 0 || report.missingFeaturedImages.length > 0 || report.staleAssetUrls.length > 0 || report.invalidHtml.length > 0 || report.unresolvedInlineImages.length > 0 || report.unsupportedBlocks.length > 0;
+}
+function buildRedirectMap(bundle) {
+  const redirects = [];
+  for (const post of bundle.posts) {
+    const from = post.source.path;
+    if (!from) continue;
+    const to = `/blog/${post.slug}`;
+    if (from.replace(/\/$/, "") === to.replace(/\/$/, "")) continue;
+    redirects.push({ fromPath: from, toPath: to, statusCode: 301 });
+  }
+  for (const page of bundle.pages) {
+    const from = page.source.path;
+    if (!from) continue;
+    const to = `/${page.slug}`;
+    if (from.replace(/\/$/, "") === to.replace(/\/$/, "")) continue;
+    redirects.push({ fromPath: from, toPath: to, statusCode: 301 });
+  }
+  return redirects;
+}
+function detectRedirectLoops(redirects) {
+  const loops = [];
+  for (const row of redirects) {
+    if (row.fromPath.replace(/\/$/, "") === row.toPath.replace(/\/$/, "")) {
+      loops.push({ fromPath: row.fromPath, toPath: row.toPath, blocked: true });
+    }
+  }
+  return loops;
+}
+
+// src/sinks/run-migration.ts
+async function runMigration(options) {
+  const bundle = await collectEntities(options.entities);
+  return runMigrationFromBundle(bundle, options);
+}
+async function runMigrationFromBundle(bundle, options) {
+  const { sink, platform, onEntityProcessed } = options;
+  const checkpointEntities = [];
+  const uploadedAssets = /* @__PURE__ */ new Map();
+  let processed = 0;
+  let failed = 0;
+  let skipped = 0;
+  const track = async (stage, key, action) => {
+    if (!shouldProcessEntity(key, checkpointEntities)) {
+      skipped += 1;
+      onEntityProcessed?.(key, "skipped");
+      return;
+    }
+    const existingTargetId = await sink.findExisting?.(key);
+    if (existingTargetId) {
+      skipped += 1;
+      onEntityProcessed?.(key, "skipped");
+      return;
+    }
+    try {
+      await sink.reportProgress?.({
+        stage,
+        progress: processed + failed + skipped,
+        message: `${stage}:${key.entityType}:${key.sourceId}`
+      });
+      await action();
+      processed += 1;
+      onEntityProcessed?.(key, "done");
+    } catch (error) {
+      failed += 1;
+      const message = error instanceof Error ? error.message : String(error);
+      onEntityProcessed?.(key, "failed", message);
+    }
+  };
+  for (const category of bundle.categories) {
+    const key = entityKey(category, platform);
+    await track("taxonomy", key, async () => {
+      if (!sink.createCategory) return;
+      await sink.createCategory(category);
+    });
+  }
+  for (const tag of bundle.tags) {
+    const key = entityKey(tag, platform);
+    await track("taxonomy", key, async () => {
+      if (!sink.createTag) return;
+      await sink.createTag(tag);
+    });
+  }
+  for (const asset of bundle.media) {
+    const key = entityKey(asset, platform);
+    await track("assets", key, async () => {
+      const stream = options.resolveAssetStream ? await options.resolveAssetStream(asset) : null;
+      const result = await sink.uploadAsset({
+        asset,
+        body: stream?.body ?? emptyBody(),
+        contentLength: stream?.contentLength
+      });
+      uploadedAssets.set(asset.sourceId, result);
+    });
+  }
+  for (const portfolio of bundle.portfolios) {
+    const key = entityKey(portfolio, platform);
+    await track("portfolios", key, async () => {
+      if (!sink.createPortfolio) {
+        throw new Error("Sink does not support portfolios");
+      }
+      await sink.createPortfolio(portfolio);
+    });
+  }
+  for (const post of bundle.posts) {
+    const key = entityKey(post, platform);
+    await track("content", key, async () => {
+      await sink.createPost(
+        prepareContentEntity(post, options, uploadedAssets, bundle)
+      );
+    });
+  }
+  for (const page of bundle.pages) {
+    const key = entityKey(page, platform);
+    await track("content", key, async () => {
+      await sink.createPage(
+        prepareContentEntity(page, options, uploadedAssets, bundle)
+      );
+    });
+  }
+  const portfolioLinks = buildPortfolioMediaLinks(bundle);
+  for (const link of portfolioLinks) {
+    const key = {
+      platform,
+      entityType: "asset",
+      sourceId: `${link.portfolioSourceId}:${link.assetSourceId}`
+    };
+    await track("bindings", key, async () => {
+      if (!sink.linkPortfolioMedia) return;
+      await sink.linkPortfolioMedia(link);
+    });
+  }
+  const redirects = buildRedirectMap(bundle);
+  for (const redirect of redirects) {
+    const key = {
+      platform,
+      entityType: "page",
+      sourceId: `redirect:${redirect.fromPath}`
+    };
+    await track("redirects", key, async () => {
+      if (!sink.writeRedirect) return;
+      await sink.writeRedirect(redirect);
+    });
+  }
+  return { processed, failed, skipped };
+}
+function prepareContentEntity(entity, options, uploadedAssets, bundle) {
+  if (!options.rewriteInlineImages) return entity;
+  const rewriteOptions = mergeRewriteOptions(bundle, options.rewriteInlineImages);
+  const rewritten = rewriteInlineImages(entity.contentHtml, rewriteOptions, uploadedAssets);
+  return {
+    ...entity,
+    contentHtml: rewritten.html
+  };
+}
+function mergeRewriteOptions(bundle, options) {
+  const urlToSourceId = /* @__PURE__ */ new Map();
+  for (const asset of bundle.media) {
+    urlToSourceId.set(asset.sourceUrl, asset.sourceId);
+    const normalized = normalizeAssetUrl(asset.sourceUrl);
+    if (normalized) urlToSourceId.set(normalized, asset.sourceId);
+  }
+  return {
+    resolveAsset: (src) => {
+      const resolved = options.resolveAsset(src);
+      if (resolved) return resolved;
+      const normalized = normalizeAssetUrl(src);
+      const sourceAssetId = (normalized ? urlToSourceId.get(normalized) : void 0) ?? urlToSourceId.get(src);
+      if (!sourceAssetId) return void 0;
+      return { originalSrc: src, sourceAssetId };
+    },
+    replaceWith: options.replaceWith
+  };
+}
+function emptyBody() {
+  return Readable.from([]);
+}
+
+// src/sinks/filesystem.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+async function writeJson(path, data) {
+  await writeFile(path, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+async function writeFilesystemExport(options) {
+  await mkdir(options.outDir, { recursive: true });
+  await writeJson(join(options.outDir, "posts.json"), options.bundle.posts);
+  await writeJson(join(options.outDir, "pages.json"), options.bundle.pages);
+  await writeJson(join(options.outDir, "media.json"), options.bundle.media);
+  await writeJson(join(options.outDir, "portfolios.json"), options.bundle.portfolios);
+  await writeJson(
+    join(options.outDir, "portfolio-media.json"),
+    buildPortfolioMediaLinks(options.bundle)
+  );
+  await writeJson(join(options.outDir, "categories.json"), options.bundle.categories);
+  await writeJson(join(options.outDir, "tags.json"), options.bundle.tags);
+  if (options.conflicts) {
+    await writeJson(join(options.outDir, "conflicts.json"), options.conflicts);
+  }
+  if (options.report) {
+    await writeJson(join(options.outDir, "migration-report.json"), options.report);
+  }
+}
+function bundleToCombinedJson(bundle) {
+  return {
+    posts: bundle.posts,
+    pages: bundle.pages,
+    media: bundle.media,
+    portfolios: bundle.portfolios,
+    portfolioMedia: buildPortfolioMediaLinks(bundle),
+    categories: bundle.categories,
+    tags: bundle.tags
+  };
+}
+
+// src/sinks/filesystem-sink.ts
+var FilesystemMigrationSink = class {
+  bundle = emptyBundle();
+  portfolioMediaLinks = [];
+  redirects = [];
+  async createCategory(category) {
+    this.bundle.categories.push(category);
+    return { targetId: category.sourceId };
+  }
+  async createTag(tag) {
+    this.bundle.tags.push(tag);
+    return { targetId: tag.sourceId };
+  }
+  async uploadAsset(input) {
+    this.bundle.media.push(input.asset);
+    return {
+      targetId: input.asset.sourceId,
+      publicUrl: input.asset.sourceUrl
+    };
+  }
+  async createPortfolio(portfolio) {
+    this.bundle.portfolios.push(portfolio);
+    return { targetId: portfolio.sourceId };
+  }
+  async createPost(post) {
+    this.bundle.posts.push(post);
+    return {
+      targetId: post.sourceId,
+      publicPath: post.source.path ?? `/${post.slug}`
+    };
+  }
+  async createPage(page) {
+    this.bundle.pages.push(page);
+    return {
+      targetId: page.sourceId,
+      publicPath: page.source.path ?? `/${page.slug}`
+    };
+  }
+  async linkPortfolioMedia(link) {
+    this.portfolioMediaLinks.push(link);
+  }
+  async writeRedirect(redirect) {
+    this.redirects.push(redirect);
+  }
+  async flush(options) {
+    await writeFilesystemExport({
+      ...options,
+      bundle: this.bundle
+    });
+  }
+};
+function createFilesystemMigrationSink() {
+  return new FilesystemMigrationSink();
+}
+function portfolioMediaMatchesBundle(sink) {
+  const expected = buildPortfolioMediaLinks(sink.bundle);
+  if (expected.length !== sink.portfolioMediaLinks.length) return false;
+  return expected.every((link, index) => {
+    const actual = sink.portfolioMediaLinks[index];
+    return actual?.portfolioSourceId === link.portfolioSourceId && actual?.assetSourceId === link.assetSourceId && actual?.sort === link.sort;
+  });
+}
+
+// src/sinks/migration-report.ts
+import { randomUUID } from "crypto";
+function buildMigrationReport(input) {
+  const counts = bundleCounts(input.bundle);
+  return {
+    runId: input.runId ?? randomUUID(),
+    platform: input.platform,
+    mode: input.mode,
+    startedAt: input.startedAt.toISOString(),
+    finishedAt: (input.finishedAt ?? /* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      ...counts,
+      storageBytesEstimated: input.storageBytesEstimated
+    },
+    warnings: input.warnings ?? [],
+    errors: input.errors ?? [],
+    conflicts: input.conflicts,
+    redirectMap: input.redirectMap
+  };
+}
+
+// src/sinks/storage-estimate.ts
+var FALLBACK_ASSET_BYTES = 4 * 1024 * 1024;
+async function estimateStorage(options) {
+  const fetchFn = options.fetchFn ?? fetch;
+  const results = [];
+  for (const asset of options.assets) {
+    if (options.offline) {
+      results.push({
+        sourceId: asset.sourceId,
+        url: asset.sourceUrl,
+        bytes: FALLBACK_ASSET_BYTES,
+        source: "fallback",
+        error: "offline_mode"
+      });
+      continue;
+    }
+    try {
+      const response = await fetchFn(asset.sourceUrl, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (response.ok) {
+        const length = response.headers.get("content-length");
+        const bytes = length ? Number.parseInt(length, 10) : FALLBACK_ASSET_BYTES;
+        results.push({
+          sourceId: asset.sourceId,
+          url: asset.sourceUrl,
+          bytes: Number.isFinite(bytes) ? bytes : FALLBACK_ASSET_BYTES,
+          source: "head"
+        });
+      } else {
+        results.push({
+          sourceId: asset.sourceId,
+          url: asset.sourceUrl,
+          bytes: FALLBACK_ASSET_BYTES,
+          source: "fallback",
+          error: `http_${response.status}`
+        });
+      }
+    } catch (error) {
+      results.push({
+        sourceId: asset.sourceId,
+        url: asset.sourceUrl,
+        bytes: FALLBACK_ASSET_BYTES,
+        source: "fallback",
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const totalBytes = results.reduce((sum, r) => sum + r.bytes, 0);
+  return { totalBytes, assets: results };
+}
+function staleUrlsFromEstimate(estimate) {
+  return estimate.assets.filter((a) => a.source === "fallback" && a.error && a.error !== "offline_mode").map((a) => ({
+    sourceId: a.sourceId,
+    url: a.url,
+    reason: a.error ?? "unknown"
+  }));
+}
+
+// src/sinks/dry-run.ts
+async function runDryRun(options) {
+  const startedAt = /* @__PURE__ */ new Date();
+  const bundle = await collectEntities(
+    options.adapter.enumerateEntities({ input: options.input })
+  );
+  const estimate = await estimateStorage({
+    assets: bundle.media,
+    offline: options.offlineStorageEstimate,
+    fetchFn: options.fetchFn
+  });
+  const redirectMap = buildRedirectMap(bundle);
+  const redirectLoops = detectRedirectLoops(redirectMap);
+  const staleAssetUrls = staleUrlsFromEstimate(estimate);
+  const conflicts = analyzeConflicts(bundle, { staleAssetUrls, redirectLoops });
+  const warnings = [];
+  if (staleAssetUrls.length > 0) {
+    warnings.push(`${staleAssetUrls.length} asset URL(s) unreachable; used 4 MB fallback each`);
+  }
+  if (conflicts.duplicatePostSlugs.length > 0) {
+    warnings.push(
+      `${conflicts.duplicatePostSlugs.length} duplicate post slug group(s); host may auto-suffix`
+    );
+  }
+  const report = buildMigrationReport({
+    platform: options.platform,
+    mode: "dry-run",
+    bundle,
+    conflicts,
+    redirectMap,
+    startedAt,
+    storageBytesEstimated: estimate.totalBytes,
+    warnings
+  });
+  let exitCode = 0;
+  if (hasBlockingConflicts(conflicts)) exitCode = 1;
+  else if (hasWarnings(conflicts) || warnings.length > 0) exitCode = 2;
+  return { bundle, conflicts, report, exitCode };
+}
+
+export {
+  MIGRATION_WRITE_STAGES,
+  discoverContentAssetUrls,
+  rewriteInlineImages,
+  sanitizeSlug,
+  linkToPath,
+  SQUARESPACE_JSON_FORMAT,
+  buildJsonPrettyUrl,
+  mapJsonPrettyWire,
+  SquarespaceCollectionClient,
+  enumerateSquarespaceEntities,
+  summarizeSquarespaceExport,
+  validateSquarespaceExportFile,
+  emptyConflictReport,
+  analyzeConflicts,
+  hasBlockingConflicts,
+  hasWarnings,
+  buildRedirectMap,
+  detectRedirectLoops,
+  runMigration,
+  runMigrationFromBundle,
+  writeFilesystemExport,
+  bundleToCombinedJson,
+  FilesystemMigrationSink,
+  createFilesystemMigrationSink,
+  portfolioMediaMatchesBundle,
+  buildMigrationReport,
+  FALLBACK_ASSET_BYTES,
+  estimateStorage,
+  staleUrlsFromEstimate,
+  runDryRun
+};
+//# sourceMappingURL=chunk-LKNIQQJO.js.map